.cargo/config.toml

@@ -1,7 +1,17 @@
 # ./cargo/config.toml
+[target.x86_64-unknown-linux-gnu]
+linker = "/usr/bin/clang-16"
+rustflags = [
+  "-C",
+  "link-arg=--ld-path=/usr/bin/mold",
+  "--cfg",
+  "tokio_unstable",
+]
+
 [profile.dev]
 debug = 0
 strip = "debuginfo"
 
 [env]
 RUST_LOG = "hyper=warn,git_url_parse=warn,debug"
+RUSTFLAGS = "--cfg tokio_unstable"

.forgejo/workflows/publish-to-crates-io.yml.disabled

@@ -0,0 +1,25 @@
+name: Publish to crates.io
+
+on:
+  release:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+    runs-on: docker
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Login
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
+        with:
+          args: login "$CARGO_REGISTRY_TOKEN"
+
+      - name: Publish
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
+        with:
+          args: publish --registry crates-io --no-verify

.forgejo/workflows/push-main.yml

@@ -1,35 +0,0 @@
-name: Release Please
-
-permissions:
-  pull-requests: write
-  contents: write
-
-on:
-  push:
-    branches:
-      - main
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  release-plz:
-    name: Release-plz
-    runs-on: docker
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Run release-plz release-pr
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
-        with:
-          args: release-plz release-pr --backend gitea --git-token ${{ secrets.FORGEJO_TOKEN }}
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
-      - name: Run release-plz release
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
-        with:
-          args: release-plz release --backend gitea --git-token ${{ secrets.FORGEJO_TOKEN }}
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.forgejo/workflows/push-next.yml

@@ -13,40 +13,26 @@ jobs:
   build:
     runs-on: docker
 
-    strategy:
-      matrix:
-        toolchain:
-          - name: stable
-          - name: nightly
-
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Check TODOs
-        uses: kemitix/todo-checker@v1.1.0
-
-      - name: Machete
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
-        with:
-          args: ${{ matrix.toolchain.name }} cargo machete
-      
       - name: Format
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
         with:
-          args: ${{ matrix.toolchain.name }} cargo fmt --all -- --check
+          args: fmt --all -- --check
 
       - name: Clippy
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
         with:
-          args: ${{ matrix.toolchain.name }} cargo hack --feature-powerset clippy
+          args: clippy
 
       - name: Build
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
         with:
-          args: ${{ matrix.toolchain.name }} cargo hack --feature-powerset build
+          args: build
 
       - name: Test
-        uses: https://git.kemitix.net/kemitix/rust@v2.3.0
+        uses: https://git.kemitix.net/kemitix/rust@v0.3.1
         with:
-          args: ${{ matrix.toolchain.name }} cargo hack --feature-powerset test
+          args: test

.gitignore

@@ -1,6 +1,3 @@
-# git-next ui logs
-.local/
-
 # ---> Rust
 # Generated by Cargo
 # will have compiled files and executables
@@ -12,7 +9,7 @@ target/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-# Cargo.lock
+Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

.woodpecker/push-next.yml

@@ -1,13 +1,13 @@
 steps:
-  docker-build:
+  todo_check:
+    # INFO: This doesn't have an equivalent yet for Forgejo Actions
+    # INFO: https://woodpecker-ci.org/plugins/TODO-Checker
+    image: codeberg.org/epsilon_02/todo-checker:1.1
     when:
       - event: push
         branch: next
-    # INFO: https://woodpecker-ci.org/plugins/Docker%20Buildx
-    image: docker.io/woodpeckerci/plugin-docker-buildx:5.0.0
     settings:
-      username: kemitix
+      # git-next-woodpecker-todo-checker - read:issue
-      repo: git.kemitix.net/kemitix/git-next
+      repository_token: "776a3b928b852472c2af727a360c85c00af64b9f"
-      dockerfile: Dockerfile
+      prefix_regex: "(#|//) (TODO|FIXME): "
-      auto_tag: false
+      debug: false
-      dry-run: true # don't push to remote repo

.woodpecker/tag-created.yml

@@ -1,10 +1,23 @@
 steps:
+  publish-to-forgejo:
+    when:
+      - event: tag
+        ref: refs/tags/v*
+    # INFO: https://woodpecker-ci.org/plugins/Gitea%20Release
+    image: docker.io/woodpeckerci/plugin-gitea-release:0.3.2
+    settings:
+      base_url: https://git.kemitix.net
+      api_key:
+        from_secret: FORGEJO_RELEASE_PLUGIN
+      target: main
+      prerelease: true
+
   docker-build:
     when:
       - event: tag
         ref: refs/tags/v*
     # INFO: https://woodpecker-ci.org/plugins/Docker%20Buildx
-    image: docker.io/woodpeckerci/plugin-docker-buildx:5.0.0
+    image: docker.io/woodpeckerci/plugin-docker-buildx:4.0.0
     settings:
       username: kemitix
       repo: git.kemitix.net/kemitix/git-next

CHANGELOG.md

@@ -2,449 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
-## `git-next-core` - [0.13.11](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.10...git-next-core-v0.13.11) - 2024-09-14
-
-### Added
-- should fetch repo on startup when not cloning
-- Remove branches when fetching from remote
-
-### Other
-- reimplement git fetch using git
-
-## `git-next` - [0.13.11](https://git.kemitix.net/kemitix/git-next/compare/v0.13.10...v0.13.11) - 2024-09-14
-
-### Added
-- *(tui)* add time and version in border
-- should fetch repo on startup when not cloning
-- Remove branches when fetching from remote
-
-### Other
-- Update TUI sooner when receiving CI status
-- reimplement git fetch using git
-- mark tui as complete on roadmap
-- Add missing port mapping parameter for running in docker
-
-## `git-next-forge-github` - [0.13.10](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-github-v0.13.9...git-next-forge-github-v0.13.10) - 2024-09-12
-
-### Added
-- optionally specify max commits between dev and main
-
-## `git-next-forge-forgejo` - [0.13.10](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-forgejo-v0.13.9...git-next-forge-forgejo-v0.13.10) - 2024-09-12
-
-### Added
-- optionally specify max commits between dev and main
-
-## `git-next-core` - [0.13.10](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.9...git-next-core-v0.13.10) - 2024-09-12
-
-### Added
-- optionally specify max commits between dev and main
-
-## `git-next` - [0.13.10](https://git.kemitix.net/kemitix/git-next/compare/v0.13.9...v0.13.10) - 2024-09-12
-
-### Added
-- optionally specify max commits between dev and main
-
-### Fixed
-- *(tui)* make tui work from docker image
-- *(tui)* alerts, such as WIP aren't being reset
-- *(test)* tests requiring .git pass when not present
-- *(tui)* update ui when push next or main finishes
-- *(tui)* don't set background for normal repo alias
-
-## `git-next` - [0.13.9](https://git.kemitix.net/kemitix/git-next/compare/v0.13.8...v0.13.9) - 2024-09-04
-
-### Fixed
-- *(tui)* alerts are cleared on next repo update
-- shutdown properly on error
-- shutdown properly on file parse error
-
-### Other
-- Expand docker docmentation
-
-## `git-next-forge-forgejo` - [0.13.8](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-forgejo-v0.13.7...git-next-forge-forgejo-v0.13.8) - 2024-09-01
-
-### Other
-- flatten nested blocks with early returns
-- rename method as peel
-
-## `git-next-core` - [0.13.8](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.7...git-next-core-v0.13.8) - 2024-09-01
-
-### Fixed
-- use configured branch names in user notification
-- create git graph log to after doing a fetch
-
-### Other
-- flatten nested blocks with early returns
-- rename method as peel
-
-## `git-next` - [0.13.8](https://git.kemitix.net/kemitix/git-next/compare/v0.13.7...v0.13.8) - 2024-09-01
-
-### Added
-- improved error display when startup fails
-- *(tui)* clean up alert display
-- *(tui)* remove some borders to clean up appearance
-- *(tui)* make progression of branches clearer
-- *(tui)* remove label from repo identity widget
-- *(tui)* hightlight repo alias in red when in alert
-- *(tui)* branch names look more like 'pills'
-- *(tui)* highlight branchs in log
-- *(tui)* hightlight status message in colour
-- *(tui)* use moving heart emoji as liveness indicator
-- *(tui)* add scrolling when overflow screen
-- *(tui)* forge widgets only use required lines
-- *(tui)* repo widgets only use required lines
-- *(tui)* move forge alias to left and add prefix
-- *(tui)* remove count of forges
-- *(tui)* remove duplicate messages from repo body
-- *(tui)* highlight user interventions in red
-
-### Fixed
-- use configured branch names in user notification
-- remove unused imports
-- *(tui)* remove logging from inside ui loop
-- *(tui)* don't show HEAD in log
-- *(tui)* improve colour contrast on light background
-- *(tui)* remove unused import
-- *(alert)* typo in email message
-- *(repo)* avoid blocking threads when pausing
-- *(test)* give actix more time to process message
-- *(test)* give actix more time to process message
-- *(test)* give actix more time to process message
-- *(tui)* improve reliability of status updates
-- create git graph log to after doing a fetch
-- *(tui)* remove logging of tui updates
-
-### Other
-- flatten nested blocks with early returns
-- merge identical match branches
-- *(tui)* add regex dependency
-- *(tui)* introduce LogLine to wrap log formatting
-- *(tui)* simplify repo identity widget
-- rename method as peel
-- *(tui)* child widget can provide constraint to container
-- *(tui)* merge repo widgets into one
-
-## `git-next-core` - [0.13.7](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.6...git-next-core-v0.13.7) - 2024-08-25
-
-### Added
-- *(tui)* (experimental) show repo state, messages and git log
-
-## `git-next` - [0.13.7](https://git.kemitix.net/kemitix/git-next/compare/v0.13.6...v0.13.7) - 2024-08-25
-
-### Added
-- *(tui)* (experimental) show repo state, messages and git log
-
-## `git-next-forge-github` - [0.13.6](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-github-v0.13.5...git-next-forge-github-v0.13.6) - 2024-08-23
-
-### Fixed
-- *(github)* register webhook with valid callback url
-
-## `git-next-core` - [0.13.6](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.5...git-next-core-v0.13.6) - 2024-08-23
-
-### Added
-- *(tui)* (experimental) tui option
-
-## `git-next` - [0.13.6](https://git.kemitix.net/kemitix/git-next/compare/v0.13.5...v0.13.6) - 2024-08-23
-
-### Added
-- *(tui)* (experimental) tui option
-
-### Fixed
-- file_watcher runs on own thread
-
-### Other
-- test all feature combinations
-
-## `git-next` - [0.13.5](https://git.kemitix.net/kemitix/git-next/compare/git-next-v0.13.4...git-next-v0.13.5) - 2024-08-10
-
-### Added
-- make forge and repo alias more prominent in email
-
-### Fixed
-- invalid config section typo in README
-
-## `git-next-forge-github` - [0.13.4](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-github-v0.13.3...git-next-forge-github-v0.13.4) - 2024-08-08
-
-### Other
-- cleanup pedantic clippy in forge-github crate
-
-## `git-next-forge-forgejo` - [0.13.4](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-forgejo-v0.13.3...git-next-forge-forgejo-v0.13.4) - 2024-08-08
-
-### Other
-- cleanup pedantic clippy in forge-forgejo crate
-
-## `git-next-core` - [0.13.4](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.3...git-next-core-v0.13.4) - 2024-08-08
-
-### Added
-- add short git log graph to notifications
-
-### Other
-- macros use a more common syntax
-- cleanup pedantic clippy in core crate
-
-## `git-next` - [0.13.4](https://git.kemitix.net/kemitix/git-next/compare/v0.13.3...v0.13.4) - 2024-08-08
-
-### Added
-- add short git log graph to notifications
-
-### Fixed
-- remove dependcy on clang & mold
-
-### Other
-- macros use a more common syntax
-- cleanup pedantic clippy in core crate
-- cleanup pedantic clippy in cli crate
-
-## `git-next-core` - [0.13.3](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.2...git-next-core-v0.13.3) - 2024-08-04
-
-### Fixed
-- shout.desktop should be optional
-
-## `git-next` - [0.13.3](https://git.kemitix.net/kemitix/git-next/compare/v0.13.2...v0.13.3) - 2024-08-04
-
-### Fixed
-- shout.desktop should be optional
-
-## `git-next` - [0.13.2](https://git.kemitix.net/kemitix/git-next/compare/v0.13.1...v0.13.2) - 2024-08-04
-
-### Other
-- timing test waits longer than expiry
-
-## `git-next-forge-github` - [0.13.1](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-github-v0.13.0...git-next-forge-github-v0.13.1) - 2024-08-04
-
-### Other
-
-- remove unused dependencies
-
-## `git-next-forge-forgejo` - [0.13.1](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-forgejo-v0.13.0...git-next-forge-forgejo-v0.13.1) - 2024-08-04
-
-### Other
-
-- remove unused dependencies
-
-## `git-next-core` - [0.13.1](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.13.0...git-next-core-v0.13.1) - 2024-08-04
-
-### Added
-
-- prevent duplicate alerts
-- add support for desktop notifications
-
-### Other
-
-- remove unused dependencies
-- update tests to check for email config parsing
-
-## `git-next` - [0.13.1](https://git.kemitix.net/kemitix/git-next/compare/v0.13.0...v0.13.1) - 2024-08-04
-
-### Added
-
-- prevent duplicate alerts
-- add support for desktop notifications
-
-### Fixed
-
-- add example email config to server default template
-
-### Other
-
-- remove unused dependencies
-- extract alerts into own actor
-- add example to readme for listen, shout & storage
-- add config details for sending emails
-
-## `git-next-forge-github` [0.13.0](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-github-v0.12.1...git-next-forge-github-v0.13.0) - 2024-08-02
-
-### Added
-
-- [**breaking**] restructured server config into listen & shout sections
-
-## `git-next-forge-forgejo` [0.13.0](https://git.kemitix.net/kemitix/git-next/compare/git-next-forge-forgejo-v0.12.1...git-next-forge-forgejo-v0.13.0) - 2024-08-02
-
-### Added
-
-- [**breaking**] restructured server config into listen & shout sections
-
-## `git-next-core` [0.13.0](https://git.kemitix.net/kemitix/git-next/compare/git-next-core-v0.12.1...git-next-core-v0.13.0) - 2024-08-02
-
-### Added
-
-- send email notifications (sendmail/smtp)
-- [**breaking**] restructured server config into listen & shout sections
-- remove notification.type
-- [**breaking**] reduce the max commit dev can be ahead of main
-
-## `git-next` [0.13.0](https://git.kemitix.net/kemitix/git-next/compare/git-next-v0.12.1...git-next-v0.13.0) - 2024-08-02
-
-### Added
-
-- send email notifications (sendmail/smtp)
-- [**breaking**] restructured server config into listen & shout sections
-- remove notification.type
-- terminate process if config file is invalid
-- return better errors to user on server failure
-- return better errors to the user on init
-
-## [0.12.1] - 2024-07-29
-
-### Bug Fixes
-
-- Webhook secret doesn't need to be base64 encoded ([691a733](https://git.kemitix.net/kemitix/git-next/commit/691a733fc37cfba5d9be72b57e24c5b9d3c1218a))
-- Remove requirement for RUSTFLAGS to be set ([e56d6a3](https://git.kemitix.net/kemitix/git-next/commit/e56d6a3ebbb4b4bfcaacc986269ba898ffbd1bc6))
-- Make default server config example valid ([b7abe94](https://git.kemitix.net/kemitix/git-next/commit/b7abe949e2067e1c3663d45a520385d967f19af8))
-
-### Miscellaneous Tasks
-
-- Update create publishing command ([bf12712](https://git.kemitix.net/kemitix/git-next/commit/bf12712bcaaefe6ae7da113e03b739b42d860fcf))
-- Remove deprecated crates ([5dc0de8](https://git.kemitix.net/kemitix/git-next/commit/5dc0de8a05d610c3a5b7be00aac1033763a76949))
-
-## [0.12.0] - 2024-07-28
-
-[656ec4a](https://git.kemitix.net/kemitix/git-next/commit/656ec4a534b5b55ddceb05eee6ed610207ac33d4)...[b89431b](https://git.kemitix.net/kemitix/git-next/commit/b89431b7798dec0ab80010d76327bef89b94eeb0)
-
-### Bug Fixes
-
-- Don't log content of internal messages ([3ae1132](https://git.kemitix.net/kemitix/git-next/commit/3ae113212af3ee43f36383a22984e03e3f44f3f2))
-
-### Documentation
-
-- Add missing readme for git-next-core ([11de4ef](https://git.kemitix.net/kemitix/git-next/commit/11de4efae6e8e460f93ba05e91278d9239d98c9c))
-- Add missing notification config details ([991d0d1](https://git.kemitix.net/kemitix/git-next/commit/991d0d1a08c9730942d53313f9015f8f610dc8bb))
-
-### Features
-
-- Support macOS ([a56c6df](https://git.kemitix.net/kemitix/git-next/commit/a56c6df3f1ad8943185941ca733a4d91069994c1))
-- Avoid resetting next to main when dev is ahead of main ([d2ea93f](https://git.kemitix.net/kemitix/git-next/commit/d2ea93f05ec81f7b9af4e2a347fc0b324eb3770f))
-
-### Miscellaneous Tasks
-
-- Remove deprecated crates ([5a595ec](https://git.kemitix.net/kemitix/git-next/commit/5a595ec9eed77cf961f01c671c69ca2bc7988092))
-- Bump gix from 0.63 to 0.64 ([b24675d](https://git.kemitix.net/kemitix/git-next/commit/b24675d48a3e35a9d780a7f7f8cbfb1477765a7b))
-- Bump mockall from 0.12 to 0.13 ([22faa85](https://git.kemitix.net/kemitix/git-next/commit/22faa851dcdd99451c736290bc17b17cbe6aa55c))
-- Release 0.12.0 ([b89431b](https://git.kemitix.net/kemitix/git-next/commit/b89431b7798dec0ab80010d76327bef89b94eeb0))
-
-### Refactor
-
-- Merge server crate into cli crate ([1427284](https://git.kemitix.net/kemitix/git-next/commit/1427284c2a378d29246a7b92d4a5c5d9601793d0))
-- Merge server-actor crate into cli crate ([a679abe](https://git.kemitix.net/kemitix/git-next/commit/a679abeafcb624f400c33721b5828c5137d96fc6))
-- Merge file-watcher-crate into cli crate ([9ca532a](https://git.kemitix.net/kemitix/git-next/commit/9ca532a2b466b3a23e957a282e54c8985e0794d6))
-- Merge file-watcher-crate into cli crate ([366930b](https://git.kemitix.net/kemitix/git-next/commit/366930bcfcdb424e853bb8f81fdad0d719a50a69))
-- Merge webhook-actor crate into cli crate ([12ecc30](https://git.kemitix.net/kemitix/git-next/commit/12ecc308d559ed509da9db8016332c877efda3d0))
-- Merge repo-actor crate into cli crate ([c1981d8](https://git.kemitix.net/kemitix/git-next/commit/c1981d862c2da6a992475effe70061f56a67ff10))
-- Merge forge crate into cli crate ([5745817](https://git.kemitix.net/kemitix/git-next/commit/57458173d033936206d2225ec3b3b6fc8291229e))
-
-## [0.11.0] - 2024-07-26
-
-[f8fefcd](https://git.kemitix.net/kemitix/git-next/commit/f8fefcdeddf556b28dc611b85db8e2b5ffbb570d)...[656ec4a](https://git.kemitix.net/kemitix/git-next/commit/656ec4a534b5b55ddceb05eee6ed610207ac33d4)
-
-### Bug Fixes
-
-- Remove unused dependecy from file-watcher-actor ([b8f4ade](https://git.kemitix.net/kemitix/git-next/commit/b8f4adeb50a98e64efe2a1a9009c4d6a6b458e3b))
-
-### Documentation
-
-- Document Notifications to user ([1690e1b](https://git.kemitix.net/kemitix/git-next/commit/1690e1bff6a3b54ff59b0763ecc2e50c25f9b896))
-- Update message graph for repo-actor ([758ca5c](https://git.kemitix.net/kemitix/git-next/commit/758ca5c2dc9273be15cdfb383bdc35095bc7834e))
-- Update package graph ([768ec6a](https://git.kemitix.net/kemitix/git-next/commit/768ec6ae02fe7d850ff976d51aa3278c01ce1013))
-
-### Features
-
-- Enable configuration of a webhook for receiving notifications ([c86d890](https://git.kemitix.net/kemitix/git-next/commit/c86d890c2cbbbe87fde58664c68c91b698862044))
-- Support sending messages to the user ([e9877ca](https://git.kemitix.net/kemitix/git-next/commit/e9877ca9fa0addf3f018527712355ca0c3d9eb77))
-- Dispatch NotifyUser messages to server for user (1/2) ([bcf57bc](https://git.kemitix.net/kemitix/git-next/commit/bcf57bc728fd53f0abb9c4e94d9768fcce5e9dbe))
-- Dispatch NotifyUser messages to server for user (2/2) ([288c20c](https://git.kemitix.net/kemitix/git-next/commit/288c20c24b59b2fa5054c81c22d42af2af06afc7))
-- Post webhook notifications to user ([9e12f5e](https://git.kemitix.net/kemitix/git-next/commit/9e12f5eb5db5f3b150886b444af4c0ce3dbf2ed9))
-
-### Miscellaneous Tasks
-
-- Release 0.11.0 ([656ec4a](https://git.kemitix.net/kemitix/git-next/commit/656ec4a534b5b55ddceb05eee6ed610207ac33d4))
-
-### Refactor
-
-- Reduce cognitive complexity of `WebhookNotification` handler. 1/2 ([06292c2](https://git.kemitix.net/kemitix/git-next/commit/06292c2711f3aca6bc369b78f67e1936fdba7eb8))
-- Reduce cognitive complexity of `WebhookNotification` handler. 2/2 ([c104dfe](https://git.kemitix.net/kemitix/git-next/commit/c104dfedc1f41020b3468d73a52ae49e0050ebb2))
-- Reduce cognitive complexity of 'validate_position' ([92ebd45](https://git.kemitix.net/kemitix/git-next/commit/92ebd453076015993d25102d262a4821fe416e06))
-- Flag internally that dev not based on main will require used intervention ([ba67b1e](https://git.kemitix.net/kemitix/git-next/commit/ba67b1ebcba46308a44d3f6dccc16ed8b0acefe3))
-- Extract messages and handlers modules from webhook-actor ([8f95ae0](https://git.kemitix.net/kemitix/git-next/commit/8f95ae0058a9f426c5d3f8f96990f6b0eb358b9e))
-- Use Option<&T> over &Option<T> ([4978400](https://git.kemitix.net/kemitix/git-next/commit/4978400ece7c37ed51328da0667b2abb1b528fc7))
-- Merge actor-macros into core ([48c968d](https://git.kemitix.net/kemitix/git-next/commit/48c968db2d166942ba1be0f09f729d5611cedf18))
-- Merge config crate into core crate ([ab728c7](https://git.kemitix.net/kemitix/git-next/commit/ab728c7364caa0c8481cd2a10c3fa57bdc7f2d16))
-- Merge git create into core crate ([fa5fa80](https://git.kemitix.net/kemitix/git-next/commit/fa5fa809d99b70970d8f0f2f910afb99837e3913))
-
-### Testing
-
-- Restore unlinked test file ([2ec5ae1](https://git.kemitix.net/kemitix/git-next/commit/2ec5ae1d51b48198d0bb96ed5477e6e77f095f76))
-
-## [0.10.0] - 2024-07-16
-
-[41c8a31](https://git.kemitix.net/kemitix/git-next/commit/41c8a319b1344d2ce04bfa8f45eb9a267d8e9a3c)...[f8fefcd](https://git.kemitix.net/kemitix/git-next/commit/f8fefcdeddf556b28dc611b85db8e2b5ffbb570d)
-
-### Bug Fixes
-
-- Move server-default.toml inside crate that uses it ([639e561](https://git.kemitix.net/kemitix/git-next/commit/639e561be60a6e22eda14e2b44764eee6afb6ae7))
-- Move default.toml inside crate that uses it ([e2b545a](https://git.kemitix.net/kemitix/git-next/commit/e2b545ae396354cd009c12dc44daadac923f140b))
-
-### Documentation
-
-- Update installation instructions ([050e117](https://git.kemitix.net/kemitix/git-next/commit/050e1171b3b047bc5b5dfd22c1e8d8f4f76efaab))
-- Move main README into cli crate ([6981a7b](https://git.kemitix.net/kemitix/git-next/commit/6981a7b5e30c854ede6303958db9ab05600bca79))
-- Add readmes to each crate to direct users to main crate ([6c92f64](https://git.kemitix.net/kemitix/git-next/commit/6c92f64f8bcec3306ef13a22e91939f555a9c77d))
-- Add UnRegisterWebhook from RepoActor ([f44865f](https://git.kemitix.net/kemitix/git-next/commit/f44865fa92857c9c53c124e520a13cd10ce17a22))
-- Update link from root README to cli README ([619e1d5](https://git.kemitix.net/kemitix/git-next/commit/619e1d517d07297fc1e9e0d89fafb93e9136cc07))
-
-### Features
-
-- Unregister webhooks form forge during shutdown ([b715755](https://git.kemitix.net/kemitix/git-next/commit/b715755b91cecd8fa6b67a58ac3e6fd322c9c005))
-- Reload server config when file is touched ([33907a1](https://git.kemitix.net/kemitix/git-next/commit/33907a1d3284a2df27994f7da1ef65d3047f165f))
-
-### Miscellaneous Tasks
-
-- Restore clean check and tag checkout to publish script ([95129dd](https://git.kemitix.net/kemitix/git-next/commit/95129ddeefa26db7cb538f2be2ab5b3609e9a175))
-- Release 0.10.0 ([f8fefcd](https://git.kemitix.net/kemitix/git-next/commit/f8fefcdeddf556b28dc611b85db8e2b5ffbb570d))
-
-### Build
-
-- Add more metadata for crates.io ([69211a8](https://git.kemitix.net/kemitix/git-next/commit/69211a87a3aaba2c8e4037d5f1a8adbca185f13d))
-
-## [0.9.4] - 2024-07-14
-
-[d24bcd9](https://git.kemitix.net/kemitix/git-next/commit/d24bcd9ab1a31afe20501c6b6e0f08436683c1c2)...[41c8a31](https://git.kemitix.net/kemitix/git-next/commit/41c8a319b1344d2ce04bfa8f45eb9a267d8e9a3c)
-
-### Bug Fixes
-
-- Add missing version for workspace dependencies ([fa7f78c](https://git.kemitix.net/kemitix/git-next/commit/fa7f78c7347ea2cd7a1a854e8aa07acb881911b2))
-
-### Miscellaneous Tasks
-
-- Release 0.9.4 ([41c8a31](https://git.kemitix.net/kemitix/git-next/commit/41c8a319b1344d2ce04bfa8f45eb9a267d8e9a3c))
-
-### Revert
-
-- Fix: explicitly specify version in each crate ([adf56c1](https://git.kemitix.net/kemitix/git-next/commit/adf56c1b38f7ae397a1187302cead4864b3bddab))
-
-## [0.9.3] - 2024-07-14
-
-[59e8fc0](https://git.kemitix.net/kemitix/git-next/commit/59e8fc050d70db2779855f7d1d73e4cf00edd461)...[d24bcd9](https://git.kemitix.net/kemitix/git-next/commit/d24bcd9ab1a31afe20501c6b6e0f08436683c1c2)
-
-### Bug Fixes
-
-- Explicitly specify version in each crate ([cd93d04](https://git.kemitix.net/kemitix/git-next/commit/cd93d047cb948118f32ae0b8b0880a42a74226fb))
-
-### Miscellaneous Tasks
-
-- Release 0.9.3 ([d24bcd9](https://git.kemitix.net/kemitix/git-next/commit/d24bcd9ab1a31afe20501c6b6e0f08436683c1c2))
-
 ## [0.9.2] - 2024-07-14
 
-[4c2e122](https://git.kemitix.net/kemitix/git-next/commit/4c2e1223467a3799506d9f44931aeec1d51cd26c)...[59e8fc0](https://git.kemitix.net/kemitix/git-next/commit/59e8fc050d70db2779855f7d1d73e4cf00edd461)
-
 ### Bug Fixes
 
 - Typo and missing repository entry in Cargo.toml files ([c289617](https://git.kemitix.net/kemitix/git-next/commit/c289617ba9d530fc04bb197745b75e0c852a7711))
 
-### Miscellaneous Tasks
-
-- Release 0.9.2 ([59e8fc0](https://git.kemitix.net/kemitix/git-next/commit/59e8fc050d70db2779855f7d1d73e4cf00edd461))
-
 ## [0.9.1] - 2024-07-14
 
 [43c6e81](https://git.kemitix.net/kemitix/git-next/commit/43c6e812dc611a2538b45b48e2014e42ef492904)...[4c2e122](https://git.kemitix.net/kemitix/git-next/commit/4c2e1223467a3799506d9f44931aeec1d51cd26c)

Cargo.toml

@@ -3,45 +3,37 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.13.11"
+version = "0.9.2"
-
 edition = "2021"
 license = "MIT"
 repository = "https://git.kemitix.net/kemitix/git-next"
-authors = ["Paul Campbell <pcampbell@kemitix.net>"]
-rust-version = "1.76"
-description = "trunk-based development manager"
-documentation = "https://git.kemitix.net/kemitix/git-next/src/branch/main/README.md"
-keywords = ["git", "cli", "server", "tool"]
-categories = ["development-tools"]
 
-# [workspace.lints.clippy]
+[workspace.lints.clippy]
-# pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
-# nursery = { level = "warn", priority = -1 }
+# pedantic = "warn"
-# unwrap_used = "warn"
+unwrap_used = "warn"
-# expect_used = "warn"
+expect_used = "warn"
 
 [workspace.dependencies]
-git-next-core = { path = "crates/core", version = "0.13" }
+git-next-server = { path = "crates/server" }
-git-next-forge-forgejo = { path = "crates/forge-forgejo", version = "0.13" }
+git-next-server-actor = { path = "crates/server-actor" }
-git-next-forge-github = { path = "crates/forge-github", version = "0.13" }
+git-next-config = { path = "crates/config" }
-
+git-next-git = { path = "crates/git" }
-# TUI
+git-next-forge = { path = "crates/forge" }
-ratatui = "0.29"
+git-next-forge-forgejo = { path = "crates/forge-forgejo" }
-directories = "5.0"
+git-next-forge-github = { path = "crates/forge-github" }
-lazy_static = "1.5"
+git-next-repo-actor = { path = "crates/repo-actor" }
-color-eyre = "0.6"
+git-next-webhook-actor = { path = "crates/webhook-actor" }
-tui-scrollview = "0.5"
+git-next-file-watcher-actor = { path = "crates/file-watcher-actor" }
-regex = "1.10"
+git-next-actor-macros = { path = "crates/actor-macros" }
-chrono = "0.4"
 
 # CLI parsing
 clap = { version = "4.5", features = ["cargo", "derive"] }
 
 # logging
+console-subscriber = "0.3"
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-subscriber = "0.3"
-tracing-error = "0.2.0"
 
 # base64 decoding
 base64 = "0.22"
@@ -52,7 +44,8 @@ sha2 = "0.10"
 hex = "0.4"
 
 # git
-gix = { version = "0.67", features = [
+# gix = "0.62"
+gix = { version = "0.63", features = [
   "dirwalk",
   "blocking-http-transport-reqwest-rust-tls",
 ] }
@@ -68,7 +61,7 @@ serde_json = "1.0"
 toml = "0.8"
 
 # Secrets and Password
-secrecy = "0.10"
+secrecy = "0.8"
 
 # Conventional Commit check
 git-conventional = "0.12"
@@ -77,12 +70,9 @@ git-conventional = "0.12"
 bytes = "1.6"
 ulid = "1.1"
 warp = "0.3"
-time = "0.3"
-standardwebhooks = "1.0"
 
 # boilerplate
-bon = "2.0"
+derive_more = { version = "1.0.0-beta.6", features = [
-derive_more = { version = "1.0.0-beta", features = [
   "as_ref",
   "constructor",
   "display",
@@ -90,32 +80,20 @@ derive_more = { version = "1.0.0-beta", features = [
   "from",
 ] }
 derive-with = "0.5"
-anyhow = "1.0"
 thiserror = "1.0"
 pike = "0.1"
 
-# iters
-take-until = "0.2"
-
 # file watcher
-notify = "7.0"
+inotify = "0.10"
 
 # Actors
 actix = "0.13"
 actix-rt = "2.9"
 tokio = { version = "1.37", features = ["rt", "macros"] }
 
-# email
-lettre = "0.11"
-sendmail = "2.0"
-
-# desktop notifications
-notifica = "3.0"
-
 # Testing
 assert2 = "0.3"
 pretty_assertions = "1.4"
 rand = "0.8"
-mockall = "0.13"
+mockall = "0.12"
 test-log = "0.2"
-rstest = { version = "0.23", features = ["async-timeout"] }

Dockerfile

@@ -1,6 +1,6 @@
 # Leveraging the pre-built Docker images with
 # cargo-chef and the Rust toolchain
-FROM git.kemitix.net/kemitix/git-next-builder:2024.08.04 AS chef
+FROM git.kemitix.net/kemitix/git-next-builder:2024.07.05 AS chef
 WORKDIR /app
 
 FROM chef AS planner
@@ -12,19 +12,19 @@ FROM chef AS builder
 COPY --from=planner /app/recipe.json recipe.json
 RUN cargo chef cook --profile release --recipe-path recipe.json
 COPY . .
-RUN cargo build --release --bin git-next --all-features && \
+RUN cargo build --release --bin git-next && \
   strip target/release/git-next
 
-FROM docker.io/debian:stable-20240904-slim AS runtime
+FROM docker.io/debian:stable-20240701-slim AS runtime
 WORKDIR /app
 RUN apt-get update && \
-  apt-get satisfy -y "git (>=2.39), libssl3 (>=3.0.14), libdbus-1-dev (>=1.14.10), ca-certificates (>=20230311)" \
+  apt-get install --no-install-recommends -y \
+  git=1:2.39.2-1.1 \
+  libssl3=3.0.13-1~deb12u1 \
+  ca-certificates=20230311 \
   && \
   rm -rf /var/lib/apt/lists/*
 USER 1000
 COPY --from=builder /app/target/release/git-next /usr/local/bin
 
-ENV HOME=/app
+ENTRYPOINT [ "/usr/local/bin/git-next", "server", "start" ]
-
-ENTRYPOINT [ "/usr/local/bin/git-next" ]
-CMD [ "server", "start" ]

Dockerfile.builder

@@ -1,7 +1,7 @@
-FROM docker.io/rust:1.82.0-bookworm
+FROM docker.io/rust:1.79.0-bookworm
 
 RUN apt-get update && \
-  apt-get install -y libdbus-1-dev && \
+  apt-get install -y clang-16 mold && \
   curl -L https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz -o cargo-binstall.tgz && \
   tar -xzf cargo-binstall.tgz && \
   rm cargo-binstall.tgz && \
@@ -15,6 +15,8 @@ RUN cargo chef --version
 RUN rustfmt --version
 RUN cargo fmt --version
 RUN cargo clippy --version
+RUN mold --version
+RUN clang-16 --version
 RUN cargo --version
 RUN rustc --version
 RUN rustup --version

README.md

@@ -1,12 +1,441 @@
 # git-next
 
-## Trunk-based developement manager.
+- Status: **BETA** - dog-fooding
 
 `git-next` is a combined server and command-line tool that enables trunk-based
 development workflows where each commit must pass CI before being included in
 the main branch.
 
-![Demo](./demo.gif)
+## Features
 
+- Allows enforce the requirement for each commit to pass the CI pipeline before being
+  included in the main branch
+- Provides a server component that manages the trunk-based development process
+- Ensure a consistent, high-quality codebase by preventing untested changes
+  from being added to main
 
-See [README.md](https://git.kemitix.net/kemitix/git-next/src/branch/main/crates/cli/README.md) for more information.
+See [Behaviour](#behaviour) to learn how we do this.
+
+## Prerequisits
+
+- Rust 1.76.0 or later - https://www.rust-lang.org
+- pgk-config
+- libssl-dev
+
+### x86_64-unknown-linux-gnu
+
+Additionally for this platform, to improved compilation times:
+
+- clang-16
+- mold
+
+See `.cargo/config.toml` for how they are configured.
+
+## Installation
+
+You can install `git-next` using Cargo:
+
+```shell
+cargo install --path crates/cli
+```
+
+Not yet available to install from `crates.io`.
+
+## Roadmap
+
+- [x] cli
+- [x] server
+- [ ] notifications - notify user when intervention required (e.g. to rebase)
+- [ ] tui overview
+- [ ] webui overview
+
+## Branch Names
+
+`git-next` uses three branches, `main`, `next` and `dev`, although they do not
+need to have those names. In the documentation we will use those names, but
+each repo must specify the names of the branches to use for each, even if they
+happen to have those same names.
+
+## Configuration
+
+- The branches to use for `main`, `next` and `dev` must be specified in either
+  the `.git-next.toml` in the repo itself, or in the server configuration file,
+  `git-next-server.toml`. See below for details.
+- CI checks should be configured to run when the `next` branch is `pushed`.
+- The `dev` branch _must_ have the `main` branch as an ancestor.
+- The `next` branch _must_ have the `main` branch as an ancestor.
+
+### Server
+
+The server is configured by the `git-next-server.toml` file.
+
+#### http
+
+The server needs to be able to receive webhook notifications from your forge,
+(e.g. github.com). You can do this via any method that suits your environment,
+e.g. ngrok or a reverse proxy from a web server that itself can route traffic
+to the machine you are running the git-next server on.
+
+Specify the address and port the server should listen to for incoming webhooks.
+This is the address and port that your reverse proxy should route traffic to.
+
+- **addr** - the IP address the server should bind to
+- **port** - the IP port the server should bind to
+
+#### webhook
+
+Your forges need to know where they should route webhooks to. This should be
+an address this is accessible to the forge. So, for github.com, it would need
+to be a publicly accessible HTTPS URL. For a self-hosted forge, e.g. ForgeJo,
+on your own network, then it only needs to be accessible from the server your
+forge is running on.
+
+- **url** - the HTTPS URL for forges to send webhook to
+
+#### storage
+
+`git-next` will create a bare clone of each repo that you configure it to
+monitor. They will all be created in the directory specified here. This data
+does not need to be backed up, as any missing information will be cloned when
+the server starts up.
+
+- **path** - directory to store local copies of monitored repos
+
+#### forge
+
+Within the forge tree, specify each forge you want to monitor repos on.
+
+Give your forge an alias, e.g. `default`, `gh`, `github`.
+
+e.g.
+
+```toml
+[forge.github]
+forge_type = "GitHub"
+hostname = "github.com"
+user = "username"
+token = "api-key"
+```
+
+- **forge_type** - one of: `ForgeJo` or `GitHub`
+- **hostname** - the hostname for the forge.
+- **user** - the user to authenticate as
+- **token** - application token for the user. See below for the permissions
+  required for on each forge.
+
+Generally, the `user` will need to be able to push to `main` and to _force-push_
+to `next`.
+
+#### repos
+
+For each forge, you need to specify which repos on the forge you want to
+monitor. They do not need to be owned by the `user`, but they `user` must have
+the `push` and `force-push` permissions as mentioned above for each of the
+repositories.
+
+e.g.
+
+```toml
+[forge.github.repos]
+my-repo = { repo = "owner/repo", branch = "main", gitdir = "/home/pcampbell/project/my-repo" }
+
+[forge.github.repos.other-repo]
+repo = "user/other"
+branch = "master"
+main = "master"
+next = "ci-testing"
+dev = "trunk"
+```
+
+Note that toml allows specifying the values on one line, or across multiple
+lines. Both are equivalent. What is not equivalent between `my-repo` and
+`other-repo`, is that one will require a configuration file within the repo
+itself. `other-repo` specifies the `main`, `next` and `dev` branches to be
+used, but `my-repo` doesn't.
+
+A sample `.git-next-toml` file that would need to exist in `my-repo`'s `owner/repo`
+repo, on the `main` branch:
+
+```toml
+[branches]
+main = "main"
+next = "next"
+dev = "dev"
+```
+
+- **repo** - the owner and name of the repo to be monitored
+- **branch** - the branch to look for a `.git-next.toml` file if needed
+- **gitdir** - (optional) you can use a local copy of the repo
+- **main** - the branch to use as `main`
+- **next** - the branch to use as `next`
+- **dev** - the branch to use as `dev`
+
+##### gitdir
+
+Additional notes on using `gitdir`:
+
+When you specify the `gitdir` value, the repo cloned in that directory will
+be used for perform the equivalent of `git fetch`, `git push` and `git push
+--force-with-lease`.
+
+These commands will not affect the contents of your working tree, nor will
+it change any local branches. Only the details about branches on the remote
+forge will be updated.
+
+Currently `git-next` can only use a `gitdir` if the forge and repo is the
+same one specified as the `origin` remote. Otherwise the behaviour is
+untested and undefined.
+
+## Behaviour
+
+The branch names are configurable, but we will talk about `main`, `next` and `dev`.
+
+Development happens on the `dev` branch, where each commit is expected to
+be able to pass the CI checks.
+
+(Note: in the diagrams, mermaid isn't capable of showing `main` and `next` on
+the same commit, so we show `next` as empty)
+
+```mermaid
+gitGraph
+    commit
+    commit
+
+    branch next
+
+    branch dev
+    commit
+    commit
+    commit
+```
+
+When the `git-next` server sees that the `dev` branch is ahead of the `next`
+branch, it will push the `next` branch fast-forward one commit along the `dev`
+branch.
+
+```mermaid
+gitGraph
+    commit
+    commit
+
+    branch next
+    commit
+
+    branch dev
+    commit
+    commit
+```
+
+It will then wait for the CI checks to pass for the newly updated `next` branch.
+When the CI checks for the `next` branch pass, it will push the `main` branch
+fast-forward to the `next` branch. We return to the top and start again.
+
+```mermaid
+gitGraph
+    commit
+    commit
+    commit
+
+    branch next
+
+    branch dev
+    commit
+    commit
+```
+
+If the CI checks should fail for the `next` branch, the developer should
+**amend** that commit **in the history of their `dev` branch**.
+They should then force-push their rebased `dev` branch.
+
+```mermaid
+gitGraph
+    commit
+    commit
+
+    branch next
+    commit
+
+    checkout main
+
+    branch dev
+    commit
+
+    commit
+    commit
+```
+
+`git-next` will then detect that the `next` branch is no longer part of the
+`dev` branch ancestory, and will reset `next` back to `main`.
+We then return to the top, where `git-next` sees that `dev` is ahead of `next`.
+
+When the `dev` branch is on the same commit as the `main` branch, then there
+are no pending commits and `git-next` will wait until it receives a webhook
+indicating that there has been a push to one of the branches. At which point
+it will start at the top again.
+
+### Important
+
+The `dev` branch _should_ have the `next` branch as an ancestor.
+
+However, when the commit on tip of the `next` branch has failed CI and is
+amended, this will not be the case. When this happens `git-next` will
+**force-push** the `next` branch back to the same commit as the `main` branch.
+
+This is the only time a force-push will happen in `git-next`.
+
+In short, the `next` branch **belongs** to `git-next`. Don't try to update it
+yourself. `git-next` will update the `next` it as it sees fit.
+
+## Getting Started
+
+To use `git-next` for trunk-based development, follow these steps:
+
+### Initialise the repo (optional)
+
+You need to specify which branches you are using. You can do this in the repo,
+or in the server configuration.
+
+To create a default config file for the repo, run this command in the root of
+your repo:
+
+```shell
+git next init
+```
+
+This will create a `.git-next.toml` file. [Default](./default.toml)
+
+By default the expected branches are `main`, `next` and `dev`. Each of these
+three branches _must_ exist in your repo.
+
+### Initialise the server
+
+The server uses the file `git-next-server.toml` for configuration. It expects
+to find this file the the current directory when executed.
+
+The create the default config file, run this command:
+
+```shell
+git next server init
+```
+
+This will create a `git-next-server.toml` file. [Default](./server-default.toml)
+
+Edit this file to your needs. See the [Configuration](#configuration) section above.
+
+### Run the server
+
+In the directory with your `git-next-server.toml` file, run the command:
+
+```shell
+git next server start
+```
+
+### Forges
+
+The following forges are supported:
+
+- [ForgeJo](https://forgejo.org) (probably compatible with Gitea, but not tested)
+- [GitHub](https://github.com/)
+
+Note: ForgeJo is a hard fork of Gitea, but currently they are largely compatible.
+For now using a `forge_type` of `ForgeJo` with a Gitea instance will probably work
+okay. The only API calls we make are around registering and unregistering webhooks.
+So, as long as those APIs remain the same, they should be compatible.
+
+#### ForgeJo
+
+Configure the forge in `git-next-server.toml` like:
+
+```toml
+[forge.jo]
+forge_type = "ForgeJo"
+hostname = "git.myforgejo.com"
+user = "bob"
+token = "..."
+
+[forge.jo.repos]
+hello = { repo = "user/hello", branch = "main", gitdir = "/opt/git/projects/user/hello.git" }             # maps to https://git.example.net/user/hello on the branch 'main'
+world = { repo = "user/world", branch = "master", main = "master", next = "upcoming", "dev" = "develop" } # maps to the 'master' branch
+```
+
+The token is created on your ForgeJo instance at (for example)
+`https://git.myforgejo.com/user/settings/applications`
+and requires the `write:repository` permission.
+
+#### GitHub
+
+Configure the forge in `git-next-server.toml` like:
+
+```toml
+[forge.gh]
+forge_type = "GitHub"
+hostname = "github.com" # required even for GitHub
+user = "bob"
+token = "..."
+
+[forge.gh.repos]
+hello = { repo = "user/hello", branch = "main", gitdir = "/opt/git/projects/user/hello.git" }             # maps to https://github.com/user/hello on the branch 'main'
+world = { repo = "user/world", branch = "master", main = "master", next = "upcoming", "dev" = "develop" } # maps to the 'master' branch
+```
+
+The token is created [here](https://github.com/settings/tokens/new) and requires the `repo` and `admin:repo_hook` permissions.
+
+## Contributing
+
+Contributions to `git-next` are welcome! If you find a bug or have a feature
+request, please
+[create an issue](https://git.kemitix.net/kemitix/git-next/issues/new).
+If you'd like to contribute code, feel free to submit changes.
+
+Before you start committing, run the `just install-hooks` command to setup the
+Git Hooks. ([Get Just](https://just.systems/man/en/chapter_3.html))
+
+## Crate Dependency
+
+The following diagram shows the dependency between the crates that make up `git-next`:
+
+```mermaid
+stateDiagram-v2
+
+    cli --> server
+
+    file_watcher_actor --> config
+    file_watcher_actor --> actor_macros
+
+    forge --> config
+    forge --> git
+    forge --> forge_forgejo
+    forge --> forge_github
+
+    forge_forgejo --> config
+    forge_forgejo --> git
+
+    forge_github --> config
+    forge_github --> git
+
+    git --> config
+
+    repo_actor --> config
+    repo_actor --> git
+    repo_actor --> forge
+    repo_actor --> actor_macros
+
+    server --> config
+    server --> file_watcher_actor
+    server --> server_actor
+
+    server_actor --> config
+    server_actor --> git
+    server_actor --> forge
+    server_actor --> repo_actor
+    server_actor --> actor_macros
+    server_actor --> file_watcher_actor
+    server_actor --> webhook_actor
+
+    webhook_actor --> config
+    webhook_actor --> repo_actor
+```
+
+## License
+
+`git-next` is released under the [MIT License](./LICENSE).

RELEASE.md

@@ -1,18 +0,0 @@
-# How to create a new Release
-
-## TLDR
-
-1. Merge PR `chore: release`
-2. Wait for [`push-main` workflow](https://git.kemitix.net/kemitix/git-next/actions?workflow=push-main.yml) to complete
-3. Replace [Release Notes](https://git.kemitix.net/kemitix/git-next/releases) body with details from [CHANGELOG](https://git.kemitix.net/kemitix/git-next/src/branch/main/CHANGELOG.md) (remove crates and duplicates)
-4. Update thread: <https://mitra.kemitix.net/post/01907ef5-5bd9-b0b6-2b8a-e29762541d78>
-
-## Detail
-
-The workflow in `.forgejo/workflows/push-main.yaml` will create or update a PR whenever `main` branch is updated.
-
-The create the new release, merge this PR. It will automatically create the Release on the `git-next` repo, and publish crates to <https://crates/io>.
-
-The Release notes that are included with the create Release are currently incorrect, and will need to be manually updated from the `CHANGELOG.md`. Remove crate headers and any resulting duplicates.
-
-Post an update to the Fediverse. See link above.

crates/actor-macros/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "git-next-actor-macros"
+version = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+repository = { workspace = true }
+description = "macros for actors for git-next, the trunk-based development manager"
+
+[dependencies]
+# Actors
+actix = { workspace = true }
+
+[lints.clippy]
+nursery = { level = "warn", priority = -1 }
+# pedantic = "warn"
+unwrap_used = "warn"
+expect_used = "warn"

crates/actor-macros/src/lib.rs

@@ -1,2 +1 @@
 mod message;
-mod newtype;

crates/actor-macros/src/message.rs

@@ -1,25 +1,25 @@
 #[macro_export]
 macro_rules! message {
-    ($name:ident, $value:ty, $docs:literal) => {
+    ($name:ident: $value:ty: $docs:literal) => {
-        git_next_core::newtype!($name, $value, $docs);
+        git_next_config::newtype!($name: $value: $docs);
         impl actix::prelude::Message for $name {
             type Result = ();
         }
     };
-    ($name:ident, $docs:literal) => {
+    ($name:ident: $docs:literal) => {
-        git_next_core::newtype!($name, $docs);
+        git_next_config::newtype!($name: $docs);
         impl actix::prelude::Message for $name {
             type Result = ();
         }
     };
-    ($name:ident, $value:ty => $result:ty, $docs:literal) => {
+    ($name:ident: $value:ty => $result:ty: $docs:literal) => {
-        git_next_core::newtype!($name, $value, $docs);
+        git_next_config::newtype!($name is a $value: $docs);
         impl actix::prelude::Message for $name {
             type Result = $result;
         }
     };
-    ($name:ident => $result:ty, $docs:literal) => {
+    ($name:ident => $result:ty: $docs:literal) => {
-        git_next_core::newtype!($name, $docs);
+        git_next_config::newtype!($name: $docs);
         impl actix::prelude::Message for $name {
             type Result = $result;
         }

crates/cli/Cargo.toml

@@ -4,33 +4,10 @@ version = { workspace = true }
 edition = { workspace = true }
 license = { workspace = true }
 repository = { workspace = true }
-description = "git-next, the trunk-based development manager"
+description = "CLI support for git-next, the trunk-based development manager"
-authors = { workspace = true }
-rust-version = { workspace = true }
-documentation = { workspace = true }
-keywords = { workspace = true }
-categories = { workspace = true }
-
-[features]
-# default = ["forgejo", "github"]
-default = ["forgejo", "github", "tui"]
-forgejo = ["git-next-forge-forgejo"]
-github = ["git-next-forge-github"]
-tui = ["ratatui", "directories", "lazy_static", "tui-scrollview", "regex", "chrono"]
 
 [dependencies]
-git-next-core = { workspace = true }
+git-next-server = { workspace = true }
-git-next-forge-forgejo = { workspace = true, optional = true }
-git-next-forge-github = { workspace = true, optional = true }
-
-# TUI
-ratatui = { workspace = true, optional = true }
-directories = { workspace = true, optional = true }
-lazy_static = { workspace = true, optional = true }
-color-eyre = { workspace = true }
-tui-scrollview = { workspace = true, optional = true }
-regex = { workspace = true, optional = true }
-chrono = { workspace = true, optional = true }
 
 # CLI parsing
 clap = { workspace = true }
@@ -38,62 +15,8 @@ clap = { workspace = true }
 # fs/network
 kxio = { workspace = true }
 
-# logging
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
-tracing-error.workspace = true
-
-# Conventional Commit check
-git-conventional = { workspace = true }
-
-# TOML parsing
-toml = { workspace = true }
-
-# Actors
-actix = { workspace = true }
-actix-rt = { workspace = true }
-tokio = { workspace = true }
-
-# boilerplate
-bon = { workspace = true }
-derive_more = { workspace = true }
-derive-with = { workspace = true }
-anyhow = { workspace = true }
-thiserror = { workspace = true }
-
-# Webhooks
-serde_json = { workspace = true }
-ulid = { workspace = true }
-time = { workspace = true }
-secrecy = { workspace = true }
-standardwebhooks = { workspace = true }
-bytes = { workspace = true }
-warp = { workspace = true }
-
-# file watcher (linux)
-notify = { workspace = true }
-
-# email
-lettre = { workspace = true }
-sendmail = { workspace = true }
-
-# desktop notifications
-notifica = { workspace = true }
-
-[dev-dependencies]
-# Testing
-assert2 = { workspace = true }
-test-log = { workspace = true }
-rand = { workspace = true }
-pretty_assertions = { workspace = true }
-mockall = { workspace = true }
-rstest = { workspace = true }
-
 [lints.clippy]
 nursery = { level = "warn", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
+# pedantic = "warn"
 unwrap_used = "warn"
 expect_used = "warn"
-
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }

crates/cli/README.md

@@ -1,660 +0,0 @@
-# git-next
-
-## Trunk-based developement manager.
-
-> A source-control branching model, where developers collaborate on code in a single branch
-> called ‘trunk’, resist any pressure to create other long-lived development branches by
-> employing documented techniques. They therefore avoid merge hell, do not break the build,
-> and live happily ever after. - [source](https://trunkbaseddevelopment.com)
-
-- Status: **BETA** - dog-fooding
-
-`git-next` is a combined server and command-line tool that enables trunk-based
-development workflows where each commit must pass CI before being included in
-the main branch.
-
-## Features
-
-- Allows enforcing the requirement for each commit to pass the CI pipeline before being
-  included in the main branch
-- Provides a server component that manages the trunk-based development process
-- Ensure a consistent, high-quality codebase by preventing untested changes
-  from being added to main
-- Requires each commit uses conventional commit format.
-
-See [Behaviour](#behaviour) to learn how we do this.
-
-## Prerequisits
-
-- Rust 1.76.0 or later - https://www.rust-lang.org
-- pgk-config
-- libssl-dev
-- libdbus-1-dev (ubuntu/debian)
-- dbus-devel (fedora)
-
-See `.cargo/config.toml` for how they are configured.
-
-## Installation
-
-You can install `git-next` from <https://crates.io/>:
-
-```shell
-cargo install git-next
-```
-
-If you use [mise](https://mise.jdx.dev):
-
-```shell
-mise use -g cargo:git-next
-```
-
-Or you can install `git-next` from source after cloning:
-
-```shell
-cargo install --path crates/cli
-```
-
-## Roadmap
-
-- [x] cli
-- [x] server
-- [x] notifications - notify user when intervention required (e.g. to rebase)
-- [x] tui overview
-- [ ] webui overview
-
-## Branch Names
-
-`git-next` uses three branches, `main`, `next` and `dev`, although they do not
-need to have those names. In the documentation we will use those names, but
-each repo must specify the names of the branches to use for each, even if they
-happen to have those same names.
-
-## Configuration
-
-- The branches to use for `main`, `next` and `dev` must be specified in either
-  the `.git-next.toml` in the repo itself, or in the server configuration file,
-  `git-next-server.toml`. See below for details.
-- CI checks should be configured to run when the `next` branch is `pushed`.
-- The `dev` branch _must_ have the `main` branch as an ancestor.
-- The `next` branch _must_ have the `main` branch as an ancestor.
-
-### Server
-
-The server is configured by the `git-next-server.toml` file.
-
-#### listen
-
-The server should listen for webhook notifications from each forge.
-
-```toml
-[listen]
-http = { addr = "0.0.0.0", port = 8080 }
-url = "https://localhost:8080"
-```
-
-##### http
-
-The server needs to be able to receive webhook notifications from your forge,
-(e.g. github.com). You can do this via any method that suits your environment,
-e.g. ngrok or a reverse proxy from a web server that itself can route traffic
-to the machine you are running the git-next server on.
-
-Specify the address and port the server should listen to for incoming webhooks.
-This is the address and port that your reverse proxy should route traffic to.
-
-- **addr** - the IP address the server should bind to
-- **port** - the IP port the server should bind to
-
-##### url
-
-The HTTPS URL for forges to send webhooks to.
-
-Your forges need to know where they should route webhooks to. This should be
-an address this is accessible to the forge. So, for github.com, it would need
-to be a publicly accessible HTTPS URL. For a self-hosted forge, e.g. ForgeJo,
-on your own network, then it only needs to be accessible from the server your
-forge is running on.
-
-#### shout
-
-The server should be able to notify the user when manual intervention is required.
-
-```toml
-[shout]
-desktop = true
-
-[shout.webhook]
-url = "https//localhost:9090"
-secret = "secret-password"
-
-[shout.email]
-from = "git-next@example.com"
-to = "developer@example.com"
-
-[shout.email.smtp]
-hostname = "smtp.example.com"
-username = "git-next@example.com"
-password = "MySecretEmailPassword42"
-```
-
-##### desktop
-
-When specified as `true`, desktop notifications will be sent for some events.
-
-##### webhook
-
-Will send a POST request for some events.
-
-- **url** - the URL to POST the notification to and the
-- **secret** - the sync key used to sign the webhook payload
-
-See [Notifications](#notifications) for more details.
-
-##### email
-
-Will send an email for some events.
-
-- **from** - the email address to send the email from
-- **to** - the email address to send the email to
-
-With just `from` and `to` specified, `git-next` will attempt to send emails
-with `sendmail` if it is configured.
-
-Alternativly, you can use an SMTP relay.
-
-###### smtp
-
-Will send emails using an SMTP relay.
-
-- **hostname** - the SMTP relay server
-- **username** - the account to authenticate as
-- **password** - the password to authenticate with
-
-#### storage
-
-```toml
-[storage]
-path = "./data"
-```
-
-`git-next` will create a bare clone of each repo that you configure it to
-monitor. They will all be created in the directory specified here. This data
-does not need to be backed up, as any missing information will be cloned when
-the server starts up.
-
-- **path** - directory to store local copies of monitored repos
-
-#### forge
-
-Within the forge tree, specify each forge you want to monitor repos on.
-
-Give your forge an alias, e.g. `default`, `gh`, `github`.
-
-e.g.
-
-```toml
-[forge.github]
-forge_type = "GitHub"
-hostname = "github.com"
-user = "username"
-token = "api-key"
-max_dev_commits = 25
-```
-
-- **forge_type** - one of: `ForgeJo` or `GitHub`
-- **hostname** - the hostname for the forge.
-- **user** - the user to authenticate as
-- **token** - application token for the user. See [Forges](#forges) below for the permissions required for each forge.
-- **max_dev_commits** - [optional] the maximum number of commits allowed between `dev` and `main`. Defaults to 25.
-
-Generally, the `user` will need to be able to push to `main` and to _force-push_
-to `next`.
-
-#### repos
-
-For each forge, you need to specify which repos on the forge you want to
-monitor. They do not need to be owned by the `user`, but they `user` must have
-the `push` and `force-push` permissions as mentioned above for each of the
-repositories.
-
-e.g.
-
-```toml
-[forge.github.repos]
-my-repo = { repo = "owner/repo", branch = "main", gitdir = "/home/pcampbell/project/my-repo" }
-
-[forge.github.repos.other-repo]
-repo = "user/other"
-branch = "master"
-main = "master"
-next = "ci-testing"
-dev = "trunk"
-```
-
-Note that toml allows specifying the values on one line, or across multiple
-lines. Both are equivalent. What is not equivalent between `my-repo` and
-`other-repo`, is that one will require a configuration file within the repo
-itself. `other-repo` specifies the `main`, `next` and `dev` branches to be
-used, but `my-repo` doesn't.
-
-A sample `.git-next-toml` file that would need to exist in `my-repo`'s `owner/repo`
-repo, on the `main` branch:
-
-```toml
-[branches]
-main = "main"
-next = "next"
-dev = "dev"
-```
-
-- **repo** - the owner and name of the repo to be monitored
-- **branch** - the branch to look for a `.git-next.toml` file if needed
-- **gitdir** - (optional) you can use a local copy of the repo
-- **main** - the branch to use as `main`
-- **next** - the branch to use as `next`
-- **dev** - the branch to use as `dev`
-
-##### gitdir
-
-Additional notes on using `gitdir`:
-
-When you specify the `gitdir` value, the repo cloned in that directory will
-be used for perform the equivalent of `git fetch`, `git push` and `git push
---force-with-lease`.
-
-These commands will not affect the contents of your working tree, nor will
-it change any local branches. Only the details about branches on the remote
-forge will be updated.
-
-Currently `git-next` can only use a `gitdir` if the forge and repo is the
-same one specified as the `origin` remote. Otherwise the behaviour is
-untested and undefined.
-
-## Webhook Notifications
-
-When sending a Webhook Notification to a user they are sent using the
-Standard Webhooks format. That means all POST messages have the
-following headers:
-
-- `Webhook-Id`
-- `Webhook-Signature`
-- `Webhook-Timestamp`
-
-### Events
-
-#### Dev Not Based on Main
-
-This message `type` indicates that the `dev` branch is not based on `main`.
-
-**Action Required**: Rebase the `dev` branch onto the `main` branch.
-
-Sample payload:
-
-```json
-{
-  "data": {
-    "branches": {
-      "dev": "dev",
-      "main": "main"
-    },
-    "forge_alias": "jo",
-    "repo_alias": "kxio",
-    "log": [
-      "* 9bfce91 (origin/dev) fix: add log graph to notifications",
-      "| * c37bd2c (origin/next, origin/main) feat: add log graph to notifications",
-      "|/",
-      "* 8c19680 refactor: macros use a more common syntax"
-    ]
-  },
-  "timestamp": "1721760933",
-  "type": "branch.dev.not-on-main"
-}
-```
-
-#### CI Check Failed
-
-This message `type` indicates that the commit on the tip of the `next` branch has failed the
-configured CI checks.
-
-**Action Required**: Either update the commit to correct the issue CI raised, or, if the issue
-is transient (e.g. a network issue), re-run/re-start the job in your CI.
-
-Sample payload:
-
-```json
-{
-  "data": {
-    "commit": {
-      "sha": "c37bd2caf6825f9770d725a681e5cfc09d7fd4f2",
-      "message": "feat: add log graph to notifications (1 of 2)"
-    },
-    "forge_alias": "jo",
-    "repo_alias": "kxio",
-    "log": [
-      "* 9bfce91 (origin/dev) feat: add log graph to notifications (2 of 2)",
-      "* c37bd2c (origin/next) feat: add log graph to notifications (1 of 2)",
-      "* 8c19680 (origin/main) refactor: macros use a more common syntax"
-    ]
-  },
-  "timestamp": "1721760933",
-  "type": "cicheck.failed"
-}
-```
-
-#### Repo Config Load Failed
-
-This message `type` indicates that `git-next` wasn't able to load the configuration for the
-repo from the `git-next.toml` file in the repository.
-
-**Action Required**: Review the `reason` provided.
-
-Sample payload:
-
-```json
-{
-  "data": {
-    "reason": "File not found: .git-next.toml",
-    "forge_alias": "jo",
-    "repo_alias": "kxio"
-  },
-  "timestamp": "1721760933",
-  "type": "config.load.failed"
-}
-```
-
-#### Webhook Registration Failed
-
-This message `type` indicates that `git-next` wasn't able to register it's webhook with the
-forge repository, so will not receive updates when the branches in the repo are updated.
-
-**Action Required**: Review the `reason` provided.
-
-Sample payload:
-
-```json
-{
-  "data": {
-    "reason": "repo config not loaded",
-    "forge_alias": "jo",
-    "repo_alias": "kxio"
-  },
-  "timestamp": "1721760933",
-  "type": "webhook.registration.failed"
-}
-```
-
-## Behaviour
-
-The branch names are configurable, but we will talk about `main`, `next` and `dev`.
-
-Development happens on the `dev` branch, where each commit is expected to
-be able to pass the CI checks.
-
-(Note: in the diagrams, mermaid isn't capable of showing `main` and `next` on
-the same commit, so we show `next` as empty)
-
-```mermaid
-gitGraph
-    commit
-    commit
-
-    branch next
-
-    branch dev
-    commit
-    commit
-    commit
-```
-
-When the `git-next` server sees that the `dev` branch is ahead of the `next`
-branch, it will push the `next` branch fast-forward one commit along the `dev`
-branch.
-
-```mermaid
-gitGraph
-    commit
-    commit
-
-    branch next
-    commit
-
-    branch dev
-    commit
-    commit
-```
-
-It will then wait for the CI checks to pass for the newly updated `next` branch.
-When the CI checks for the `next` branch pass, it will push the `main` branch
-fast-forward to the `next` branch. We return to the top and start again.
-
-```mermaid
-gitGraph
-    commit
-    commit
-    commit
-
-    branch next
-
-    branch dev
-    commit
-    commit
-```
-
-If the CI checks should fail for the `next` branch, the developer should
-**amend** that commit **in the history of their `dev` branch**.
-They should then force-push their rebased `dev` branch.
-
-```mermaid
-gitGraph
-    commit
-    commit
-
-    branch next
-    commit
-
-    checkout main
-
-    branch dev
-    commit
-
-    commit
-    commit
-```
-
-`git-next` will then detect that the `next` branch is no longer part of the
-`dev` branch ancestory, and will reset `next` back to `main`.
-We then return to the top, where `git-next` sees that `dev` is ahead of `next`.
-
-When the `dev` branch is on the same commit as the `main` branch, then there
-are no pending commits and `git-next` will wait until it receives a webhook
-indicating that there has been a push to one of the branches. At which point
-it will start at the top again.
-
-### Important
-
-The `dev` branch _should_ have the `next` branch as an ancestor.
-
-However, when the commit on tip of the `next` branch has failed CI and is
-amended, this will not be the case. When this happens `git-next` will
-**force-push** the `next` branch back to the same commit as the `main` branch.
-
-This is the only time a force-push will happen in `git-next`.
-
-In short, the `next` branch **belongs** to `git-next`. Don't try to update it
-yourself. `git-next` will update the `next` it as it sees fit.
-
-## Getting Started
-
-To use `git-next` for trunk-based development, follow these steps:
-
-### Initialise the repo (optional)
-
-You need to specify which branches you are using. You can do this in the repo,
-or in the server configuration.
-
-To create a default config file for the repo, run this command in the root of
-your repo:
-
-```shell
-git next init
-```
-
-This will create a `.git-next.toml` file. [Default](./crates/cli/default.toml)
-
-By default the expected branches are `main`, `next` and `dev`. Each of these
-three branches _must_ exist in your repo.
-
-### Initialise the server
-
-The server uses the file `git-next-server.toml` for configuration. It expects
-to find this file the the current directory when executed.
-
-The create the default config file, run this command:
-
-```shell
-git next server init
-```
-
-This will create a `git-next-server.toml` file. [Default](./crates/server/server-default.toml)
-
-Edit this file to your needs. See the [Configuration](#configuration) section above.
-
-### Run the server
-
-In the directory with your `git-next-server.toml` file, run the command:
-
-```shell
-git next server start
-```
-
-### Forges
-
-The following forges are supported:
-
-- [ForgeJo](https://forgejo.org) (probably compatible with Gitea, but not tested)
-- [GitHub](https://github.com/)
-
-Note: ForgeJo is a hard fork of Gitea, but currently they are largely compatible.
-For now using a `forge_type` of `ForgeJo` with a Gitea instance will probably work
-okay. The only API calls we make are around registering and unregistering webhooks.
-So, as long as those APIs remain the same, they should be compatible.
-
-#### ForgeJo
-
-Configure the forge in `git-next-server.toml` like:
-
-```toml
-[forge.jo]
-forge_type = "ForgeJo"
-hostname = "git.myforgejo.com"
-user = "bob"
-token = "..."
-
-[forge.jo.repos]
-hello = { repo = "user/hello", branch = "main", gitdir = "/opt/git/projects/user/hello.git" }             # maps to https://git.example.net/user/hello on the branch 'main'
-world = { repo = "user/world", branch = "master", main = "master", next = "upcoming", "dev" = "develop" } # maps to the 'master' branch
-```
-
-The token is created on your ForgeJo instance at (for example)
-`https://git.myforgejo.com/user/settings/applications`
-and requires the `write:repository` permission.
-
-#### GitHub
-
-Configure the forge in `git-next-server.toml` like:
-
-```toml
-[forge.gh]
-forge_type = "GitHub"
-hostname = "github.com" # required even for GitHub
-user = "bob"
-token = "..."
-
-[forge.gh.repos]
-hello = { repo = "user/hello", branch = "main", gitdir = "/opt/git/projects/user/hello.git" }             # maps to https://github.com/user/hello on the branch 'main'
-world = { repo = "user/world", branch = "master", main = "master", next = "upcoming", "dev" = "develop" } # maps to the 'master' branch
-```
-
-The token is created [here](https://github.com/settings/tokens/new) and requires the `repo` and `admin:repo_hook` permissions.
-
-## Docker
-
-`git-next` is available as a [Docker image](https://git.kemitix.net/kemitix/-/packages/container/git-next/).
-
-```shell
-docker pull docker pull git.kemitix.net/kemitix/git-next:latest
-```
-
-### Docker Compose
-
-Here is an example `docker-compose.yml`:
-
-```yaml
-services:
-  server:
-    image: git.kemitix.net/kemitix/git-next:latest
-    container_name: git-next-server
-    restart: unless-stopped
-    environment:
-      RUST_LOG: "hyper=warn,info"
-    ports:
-      - 8080:8092
-    volumes:
-      - ./:/app/
-```
-
-Note: this assumes the `git-next-server.toml` has a `listen.http.port` of
-`8092` and that you are using a reverse proxy to route traffic arriving at
-`listen.url` to port `8080`.
-
-### Docker Run
-
-This will run with the `server start` options:
-
-```shell
-docker run -it -p "8080:8092" -v .:/app/ git.kemitix.net/kemitix/git-next:latest
-```
-
-To perform `server init`:
-
-```shell
-docker run -it -v .:/app/ git.kemitix.net/kemitix/git-next:latest server init
-```
-
-To perform repo `init`:
-
-```shell
-docker run -it -v .:/app/ git.kemitix.net/kemitix/git-next:latest init
-```
-
-TUI support is not available in the docker container. See [kemitix/git-next#154](https://git.kemitix.net/kemitix/git-next/issues/154).
-
-## Contributing
-
-Contributions to `git-next` are welcome! If you find a bug or have a feature
-request, please
-[create an issue](https://git.kemitix.net/kemitix/git-next/issues/new).
-If you'd like to contribute code, feel free to submit changes.
-
-Before you start committing, run the `just install-hooks` command to setup the
-Git Hooks. ([Get Just](https://just.systems/man/en/chapter_3.html))
-
-## Crate Dependency
-
-The following diagram shows the dependency between the crates that make up `git-next`:
-
-```mermaid
-stateDiagram-v2
-
-    cli --> core
-    cli --> forge_forgejo
-    cli --> forge_github
-
-    forge_forgejo --> core
-
-    forge_github --> core
-```
-
-## License
-
-`git-next` is released under the [MIT License](./LICENSE).

crates/cli/src/alerts/desktop.rs

@@ -1,10 +0,0 @@
-//
-use crate::alerts::short_message;
-use git_next_core::git::UserNotification;
-
-pub(super) fn send_desktop_notification(user_notification: &UserNotification) {
-    let message = short_message(user_notification);
-    if let Err(err) = notifica::notify("git-next", &message) {
-        tracing::warn!(?err, "failed to send desktop notification");
-    }
-}

crates/cli/src/alerts/email.rs

@@ -1,71 +0,0 @@
-//
-use git_next_core::{
-    git::UserNotification,
-    server::{EmailConfig, SmtpConfig},
-};
-
-use crate::alerts::{full_message, short_message};
-
-#[derive(Debug)]
-struct EmailMessage {
-    from: String,
-    to: String,
-    subject: String,
-    body: String,
-}
-
-pub(super) fn send_email(user_notification: &UserNotification, email_config: &EmailConfig) {
-    let email_message = EmailMessage {
-        from: email_config.from().to_string(),
-        to: email_config.to().to_string(),
-        subject: short_message(user_notification),
-        body: full_message(user_notification),
-    };
-    match email_config.smtp() {
-        Some(smtp) => send_email_smtp(email_message, smtp),
-        None => send_email_sendmail(&email_message),
-    }
-}
-
-fn send_email_sendmail(email_message: &EmailMessage) {
-    use sendmail::email;
-    match email::send(
-        &email_message.from,
-        [email_message.to.as_ref()],
-        &email_message.subject,
-        &email_message.body,
-    ) {
-        Ok(()) => tracing::info!("Email sent successfully!"),
-        Err(e) => tracing::warn!("Could not send email: {:?}", e),
-    }
-}
-
-fn send_email_smtp(email_message: EmailMessage, smtp: &SmtpConfig) {
-    if let Err(err) = do_send_email_smtp(email_message, smtp) {
-        tracing::warn!(?err, "sending email");
-    }
-}
-
-fn do_send_email_smtp(email_message: EmailMessage, smtp: &SmtpConfig) -> Result<(), anyhow::Error> {
-    use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
-    let email = Message::builder()
-        .from(email_message.from.parse()?)
-        .to(email_message.to.parse()?)
-        .subject(email_message.subject)
-        .body(email_message.body)?;
-    let creds = Credentials::new(smtp.username().to_string(), smtp.password().to_string());
-    let mailer = SmtpTransport::relay(smtp.hostname())?
-        .credentials(creds)
-        .build();
-    Ok(mailer
-        .send(&email)
-        .map(|response| {
-            response
-                .message()
-                .map(ToString::to_string)
-                .collect::<Vec<_>>()
-        })
-        .map(|response| {
-            tracing::info!(?response, "email sent via smtp");
-        })?)
-}

crates/cli/src/alerts/handlers/mod.rs

@@ -1,2 +0,0 @@
-mod notify_user;
-mod update_shout;

crates/cli/src/alerts/handlers/notify_user.rs

@@ -1,41 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{info, Instrument as _};
-
-use crate::alerts::{
-    desktop::send_desktop_notification, email::send_email, messages::NotifyUser,
-    webhook::send_webhook, AlertsActor,
-};
-
-impl Handler<NotifyUser> for AlertsActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: NotifyUser, ctx: &mut Self::Context) -> Self::Result {
-        let Some(shout) = &self.shout else {
-            info!("No shout config available");
-            return;
-        };
-        let net = self.net.clone();
-        let shout = shout.clone();
-        let Some(user_notification) = self.history.sendable(msg.peel()) else {
-            return;
-        };
-        async move {
-            if let Some(webhook_config) = shout.webhook() {
-                send_webhook(&user_notification, webhook_config, &net).await;
-            }
-            if let Some(email_config) = shout.email() {
-                send_email(&user_notification, email_config);
-            }
-            if let Some(desktop) = shout.desktop() {
-                if desktop {
-                    send_desktop_notification(&user_notification);
-                }
-            }
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-    }
-}

crates/cli/src/alerts/handlers/update_shout.rs

@@ -1,12 +0,0 @@
-//
-use actix::prelude::*;
-
-use crate::alerts::{messages::UpdateShout, AlertsActor};
-
-impl Handler<UpdateShout> for AlertsActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: UpdateShout, _ctx: &mut Self::Context) -> Self::Result {
-        self.shout.replace(msg.peel());
-    }
-}

crates/cli/src/alerts/history.rs

@@ -1,50 +0,0 @@
-//
-use git_next_core::git::UserNotification;
-use tracing::info;
-
-use std::{
-    collections::HashMap,
-    time::{Duration, Instant},
-};
-
-#[derive(Debug)]
-pub struct History {
-    /// The maximum age of an item in the history.
-    ///
-    /// Items older than this will be dropped.
-    max_age_seconds: Duration,
-
-    /// Maps a user notification to when it was last seen.
-    ///
-    /// The user notification will not be sent until after `max_age_seconds` from last seen.
-    ///
-    /// Each time we see a given user notification, the last seen time will be updated.
-    items: HashMap<UserNotification, Instant>,
-}
-impl History {
-    pub fn new(max_age_seconds: Duration) -> Self {
-        Self {
-            max_age_seconds,
-            items: HashMap::default(),
-        }
-    }
-
-    pub fn sendable(&mut self, user_notification: UserNotification) -> Option<UserNotification> {
-        let now = Instant::now();
-        self.prune(&now); // remove expired items first
-        let contains_key = self.items.contains_key(&user_notification);
-        self.items.insert(user_notification.clone(), now);
-        if contains_key {
-            info!("previously sent");
-            return None;
-        }
-        info!("not sent before");
-        Some(user_notification)
-    }
-
-    pub fn prune(&mut self, now: &Instant) {
-        if let Some(threshold) = now.checked_sub(self.max_age_seconds) {
-            self.items.retain(|_, last_seen| *last_seen > threshold);
-        };
-    }
-}

crates/cli/src/alerts/messages.rs

@@ -1,10 +0,0 @@
-//
-use git_next_core::{git::UserNotification, message, server::Shout};
-
-message!(UpdateShout, Shout, "Updated Shout configuration");
-
-message!(
-    NotifyUser,
-    UserNotification,
-    "Request to send the message payload to the notification webhook"
-);

crates/cli/src/alerts/mod.rs

@@ -1,93 +0,0 @@
-//
-use actix::prelude::*;
-
-use derive_more::derive::Constructor;
-
-use git_next_core::{git::UserNotification, server::Shout};
-
-pub use history::History;
-
-mod desktop;
-mod email;
-mod handlers;
-mod history;
-pub mod messages;
-mod webhook;
-
-#[cfg(test)]
-mod tests;
-
-#[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Constructor)]
-pub struct AlertsActor {
-    shout: Option<Shout>, // config for sending alerts to users
-    history: History,     // record of alerts sent recently (e.g. 24 hours)
-    net: kxio::network::Network,
-}
-
-impl Actor for AlertsActor {
-    type Context = Context<Self>;
-}
-
-fn short_message(user_notification: &UserNotification) -> String {
-    let (forge_alias, repo_alias) = user_notification.aliases();
-    format!("[git-next] {forge_alias}/{repo_alias}: {user_notification}")
-}
-
-fn full_message(user_notification: &UserNotification) -> String {
-    match user_notification {
-        UserNotification::CICheckFailed {
-            forge_alias,
-            repo_alias,
-            commit,
-            log,
-        } => {
-            let sha = commit.sha();
-            let message = commit.message();
-            [
-                "CI Checks have Failed".to_string(),
-                format!("Forge: {forge_alias}\nRepo : {repo_alias}"),
-                format!("Commit:\n - {sha}\n - {message}"),
-                "Log:".to_string(),
-                log.join("\n"),
-            ]
-            .join("\n\n")
-        }
-        UserNotification::RepoConfigLoadFailure {
-            forge_alias,
-            repo_alias,
-            reason,
-        } => [
-            "Failed to read or parse the .git-next.toml file from repo".to_string(),
-            format!(" - {reason}"),
-            format!("Forge: {forge_alias}\nRepo : {repo_alias}"),
-        ]
-        .join("\n\n"),
-        UserNotification::WebhookRegistration {
-            forge_alias,
-            repo_alias,
-            reason,
-        } => [
-            "Failed to register webhook with the forge".to_string(),
-            format!(" - {reason}"),
-            format!("Forge: {forge_alias}\nRepo : {repo_alias}"),
-        ]
-        .join("\n\n"),
-        UserNotification::DevNotBasedOnMain {
-            forge_alias,
-            repo_alias,
-            dev_branch,
-            main_branch,
-            dev_commit: _,
-            main_commit: _,
-            log,
-        } => [
-            format!("The branch '{dev_branch}' is not based on the branch '{main_branch}'."),
-            format!("TODO: Rebase '{dev_branch}' onto '{main_branch}'."),
-            format!("Forge: {forge_alias}\nRepo : {repo_alias}"),
-            "Log:".to_string(),
-            log.join("\n"),
-        ]
-        .join("\n\n"),
-    }
-}

crates/cli/src/alerts/tests/history.rs

@@ -1,68 +0,0 @@
-use std::time::Duration;
-
-use assert2::let_assert;
-use git_next_core::git::UserNotification;
-
-use crate::{alerts::History, repo::tests::given};
-
-#[test]
-fn when_history_is_empty_then_message_is_passed() {
-    let mut history = History::new(Duration::from_millis(1));
-
-    let user_notification = UserNotification::RepoConfigLoadFailure {
-        forge_alias: given::a_forge_alias(),
-        repo_alias: given::a_repo_alias(),
-        reason: given::a_name(),
-    };
-
-    let result = history.sendable(user_notification);
-
-    assert!(result.is_some());
-}
-
-#[test]
-fn when_history_has_expired_then_message_is_passed() {
-    let dur = Duration::from_millis(1);
-    let mut history = History::new(dur);
-
-    let user_notification = UserNotification::RepoConfigLoadFailure {
-        forge_alias: given::a_forge_alias(),
-        repo_alias: given::a_repo_alias(),
-        reason: given::a_name(),
-    };
-
-    // add message to history
-    let result = history.sendable(user_notification);
-    let_assert!(Some(user_notification) = result);
-
-    std::thread::sleep(dur);
-    // twice the expiry duration to avoid things happening in the wrong order
-    std::thread::sleep(dur);
-
-    // after dur, message has expired, so is still valid
-    let result = history.sendable(user_notification);
-    assert!(result.is_some());
-}
-
-#[test]
-fn when_history_has_unexpired_then_message_is_blocked() {
-    let dur = Duration::from_secs(1);
-    let mut history = History::new(dur);
-
-    let user_notification = UserNotification::RepoConfigLoadFailure {
-        forge_alias: given::a_forge_alias(),
-        repo_alias: given::a_repo_alias(),
-        reason: given::a_name(),
-    };
-
-    // add message to history
-    let result = history.sendable(user_notification);
-    let_assert!(Some(user_notification) = result);
-
-    // no time passed
-    // std::thread::sleep(dur);
-
-    // after dur, message has expired, so is still valid
-    let result = history.sendable(user_notification);
-    assert!(result.is_none());
-}

crates/cli/src/alerts/tests/mod.rs

@@ -1 +0,0 @@
-mod history;

crates/cli/src/alerts/webhook.rs

@@ -1,54 +0,0 @@
-//
-use git_next_core::{git::UserNotification, server::OutboundWebhook};
-use kxio::network::{NetRequest, NetUrl, RequestBody, ResponseType};
-use secrecy::ExposeSecret as _;
-use standardwebhooks::Webhook;
-
-pub(super) async fn send_webhook(
-    user_notification: &UserNotification,
-    webhook_config: &OutboundWebhook,
-    net: &kxio::network::Network,
-) {
-    let Ok(webhook) =
-        Webhook::from_bytes(webhook_config.secret().expose_secret().as_bytes().into())
-    else {
-        tracing::warn!("Invalid notification configuration (signer) - can't sent notification");
-        return;
-    };
-    do_send_webhook(user_notification, webhook, webhook_config, net).await;
-}
-
-async fn do_send_webhook(
-    user_notification: &UserNotification,
-    webhook: Webhook,
-    webhook_config: &OutboundWebhook,
-    net: &kxio::network::Network,
-) {
-    let message_id = format!("msg_{}", ulid::Ulid::new());
-    let timestamp = time::OffsetDateTime::now_utc();
-    let payload = user_notification.as_json(timestamp);
-    let timestamp = timestamp.unix_timestamp();
-    let to_sign = format!("{message_id}.{timestamp}.{payload}");
-    tracing::info!(?to_sign, "");
-    #[allow(clippy::expect_used)]
-    let signature = webhook
-        .sign(&message_id, timestamp, payload.to_string().as_ref())
-        .expect("signature");
-    tracing::info!(?signature, "");
-    let url = webhook_config.url();
-
-    let net_url = NetUrl::new(url.to_string());
-    let request = NetRequest::post(net_url)
-        .body(RequestBody::Json(payload))
-        .header("webhook-id", &message_id)
-        .header("webhook-timestamp", &timestamp.to_string())
-        .header("webhook-signature", &signature)
-        .response_type(ResponseType::None)
-        .build();
-    net.post_json::<()>(request).await.map_or_else(
-        |err| {
-            tracing::warn!(?err, "sending webhook");
-        },
-        |_| (),
-    );
-}

crates/cli/src/file_watcher.rs

@@ -1,66 +0,0 @@
-//
-use actix::prelude::*;
-
-use actix::Recipient;
-use anyhow::{Context, Result};
-use notify::{event::ModifyKind, Watcher};
-use tracing::{error, info};
-
-use std::{
-    path::PathBuf,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-    time::Duration,
-};
-
-#[derive(Debug, Message)]
-#[rtype(result = "()")]
-pub struct FileUpdated;
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("io")]
-    Io(#[from] std::io::Error),
-}
-pub fn watch_file(path: PathBuf, recipient: Recipient<FileUpdated>) -> Result<Arc<AtomicBool>> {
-    let (tx, rx) = std::sync::mpsc::channel();
-    let shutdown = Arc::new(AtomicBool::default());
-
-    let mut handler = notify::recommended_watcher(tx).context("file watcher")?;
-    handler
-        .watch(&path, notify::RecursiveMode::NonRecursive)
-        .with_context(|| format!("Watching: {path:?}"))?;
-    let thread_shutdown = shutdown.clone();
-    actix_rt::task::spawn_blocking(move || {
-        loop {
-            if thread_shutdown.load(Ordering::Relaxed) {
-                drop(handler);
-                break;
-            }
-            for result in rx.try_iter() {
-                match result {
-                    Ok(event) => match event.kind {
-                        notify::EventKind::Modify(ModifyKind::Data(_)) => {
-                            info!("File modified");
-                            recipient.do_send(FileUpdated);
-                            break;
-                        }
-                        notify::EventKind::Modify(_)
-                        | notify::EventKind::Create(_)
-                        | notify::EventKind::Remove(_)
-                        | notify::EventKind::Any
-                        | notify::EventKind::Access(_)
-                        | notify::EventKind::Other => { /* do nothing */ }
-                    },
-                    Err(err) => {
-                        error!(?err, "Watching file: {path:?}");
-                    }
-                }
-            }
-            std::thread::sleep(Duration::from_millis(1000));
-        }
-    });
-    Ok(shutdown)
-}

crates/cli/src/forge/mod.rs

@@ -1,32 +0,0 @@
-//
-use git_next_core::git::{ForgeLike, RepoDetails};
-
-#[cfg(feature = "forgejo")]
-use git_next_forge_forgejo::ForgeJo;
-
-#[cfg(feature = "github")]
-use git_next_forge_github::Github;
-
-use kxio::network::Network;
-
-#[derive(Clone, Debug)]
-pub struct Forge;
-
-impl Forge {
-    pub fn create(repo_details: RepoDetails, net: Network) -> Box<dyn ForgeLike> {
-        match repo_details.forge.forge_type() {
-            #[cfg(feature = "forgejo")]
-            git_next_core::ForgeType::ForgeJo => Box::new(ForgeJo::new(repo_details, net)),
-            #[cfg(feature = "github")]
-            git_next_core::ForgeType::GitHub => Box::new(Github::new(repo_details, net)),
-            _ => {
-                drop(repo_details);
-                drop(net);
-                unreachable!();
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod tests;

crates/cli/src/forge/tests.rs

@@ -1,42 +0,0 @@
-//
-#[cfg(any(feature = "forgejo", feature = "github"))]
-use super::*;
-
-use git_next_core::{
-    self as core,
-    git::{self, RepoDetails},
-    GitDir, RepoConfigSource, StoragePathType,
-};
-
-#[cfg(feature = "forgejo")]
-#[test]
-fn test_forgejo_name() {
-    let net = Network::new_mock();
-    let repo_details = given_repo_details(git_next_core::ForgeType::ForgeJo);
-    let forge = Forge::create(repo_details, net);
-    assert_eq!(forge.name(), "forgejo");
-}
-
-#[cfg(feature = "github")]
-#[test]
-fn test_github_name() {
-    let net = Network::new_mock();
-    let repo_details = given_repo_details(git_next_core::ForgeType::GitHub);
-    let forge = Forge::create(repo_details, net);
-    assert_eq!(forge.name(), "github");
-}
-
-#[allow(dead_code)]
-fn given_repo_details(forge_type: git_next_core::ForgeType) -> RepoDetails {
-    let fs = kxio::fs::temp().unwrap_or_else(|e| {
-        println!("{e}");
-        panic!("fs")
-    });
-    git::repo_details(
-        1,
-        git::Generation::default(),
-        core::common::forge_details(1, forge_type),
-        Some(core::common::repo_config(1, RepoConfigSource::Repo)),
-        GitDir::new(fs.base().to_path_buf(), StoragePathType::Internal),
-    )
-}

crates/cli/src/init.rs

@@ -1,18 +1,28 @@
-//
-use color_eyre::{eyre::Context, Result};
 use kxio::fs::FileSystem;
 
-pub fn run(fs: &FileSystem) -> Result<()> {
+pub fn run(fs: FileSystem) {
-    let pathbuf = fs.base().join(".git-next.toml");
+    let file_name = ".git-next.toml";
-    if fs
+    let pathbuf = fs.base().join(file_name);
-        .path_exists(&pathbuf)
+    match fs.path_exists(&pathbuf) {
-        .with_context(|| format!("Checking for existing file: {pathbuf:?}"))?
+        Ok(exists) => {
-    {
+            if exists {
-        eprintln!("The configuration file already exists at {pathbuf:?} - not overwritting it.",);
+                eprintln!(
-    } else {
+                    "The configuration file already exists at {} - not overwritting it.",
-        fs.file_write(&pathbuf, include_str!("../default.toml"))
+                    file_name
-            .with_context(|| format!("Writing file: {pathbuf:?}"))?;
+                );
-        println!("Created a default configuration file at {pathbuf:?}");
+            } else {
+                match fs.file_write(&pathbuf, include_str!("../../../default.toml")) {
+                    Ok(_) => {
+                        println!("Created a default configuration file at {}", file_name);
+                    }
+                    Err(e) => {
+                        eprintln!("Failed to write to the configuration file: {}", e)
+                    }
+                }
+            }
+        }
+        Err(err) => {
+            eprintln!("Could not check if file exist: {} - {err:?}", file_name);
+        }
     }
-    Ok(())
 }

crates/cli/src/main.rs

@@ -1,26 +1,11 @@
-//
-#![allow(clippy::module_name_repetitions)]
-
-mod alerts;
-mod file_watcher;
-mod forge;
 mod init;
-mod repo;
-mod server;
-
-#[cfg(feature = "tui")]
-mod tui;
 
 #[cfg(test)]
 mod tests;
-mod webhook;
-
-use git_next_core::git;
 
 use std::path::PathBuf;
 
 use clap::Parser;
-use color_eyre::Result;
 use kxio::{fs, network::Network};
 
 #[derive(Parser, Debug)]
@@ -38,40 +23,27 @@ enum Command {
 #[derive(Parser, Debug)]
 enum Server {
     Init,
-    Start {
+    Start,
-        /// Display a UI (experimental)
-        #[cfg(feature = "tui")]
-        #[arg(long, required = false)]
-        ui: bool,
-    },
 }
 
-fn main() -> Result<()> {
+fn main() {
     let fs = fs::new(PathBuf::default());
     let net = Network::new_real();
-    let repository_factory = git::repository::factory::real();
+    let repository_factory = git_next_server::repository_factory();
     let commands = Commands::parse();
 
     match commands.command {
-        Command::Init => init::run(&fs),
+        Command::Init => {
+            init::run(fs);
+        }
         Command::Server(server) => match server {
-            Server::Init => server::init(&fs),
+            Server::Init => {
-            #[cfg(not(feature = "tui"))]
+                git_next_server::init(fs);
-            Server::Start {} => server::start(
+            }
-                false,
+            Server::Start => {
-                fs,
+                let sleep_duration = std::time::Duration::from_secs(10);
-                net,
+                git_next_server::start(fs, net, repository_factory, sleep_duration);
-                repository_factory,
+            }
-                std::time::Duration::from_secs(10),
-            ),
-            #[cfg(feature = "tui")]
-            Server::Start { ui } => server::start(
-                ui,
-                fs,
-                net,
-                repository_factory,
-                std::time::Duration::from_secs(10),
-            ),
         },
     }
 }

crates/cli/src/repo/handlers/advance_main.rs

@@ -1,59 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::{git, RepoConfigSource};
-
-use tracing::warn;
-
-use crate::{
-    repo::{
-        branch::advance_main,
-        do_send,
-        messages::{AdvanceMain, LoadConfigFromRepo, ValidateRepo},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<AdvanceMain> for RepoActor {
-    type Result = ();
-    #[tracing::instrument(name = "RepoActor::AdvanceMainTo", skip_all, fields(repo = %self.repo_details, commit = ?msg))]
-    fn handle(&mut self, msg: AdvanceMain, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
-            warn!("No config loaded");
-            return;
-        };
-        let Some(open_repository) = &self.open_repository else {
-            return;
-        };
-        let repo_details = self.repo_details.clone();
-        let addr = ctx.address();
-        let message_token = self.message_token;
-        let commit = msg.peel();
-
-        self.update_tui(RepoUpdate::AdvancingMain {
-            commit: commit.clone(),
-        });
-
-        if let Err(err) = advance_main(commit, &repo_details, &repo_config, &**open_repository) {
-            warn!("advance main: {err}");
-            self.alert_tui(format!("advance main: {err}"));
-        } else {
-            self.update_tui(RepoUpdate::MainUpdated);
-            if let Some(open_repository) = &self.open_repository {
-                match open_repository.fetch() {
-                    Ok(()) => self.update_tui_log(git::graph::log(&self.repo_details)),
-                    Err(err) => self.alert_tui(format!("fetching: {err}")),
-                }
-            }
-            match repo_config.source() {
-                RepoConfigSource::Repo => {
-                    do_send(&addr, LoadConfigFromRepo, self.log.as_ref());
-                }
-                RepoConfigSource::Server => {
-                    do_send(&addr, ValidateRepo::new(message_token), self.log.as_ref());
-                }
-            }
-        }
-    }
-}

crates/cli/src/repo/handlers/advance_next.rs

@@ -1,75 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::git;
-use tracing::{warn, Instrument};
-
-use crate::{
-    repo::{
-        branch::{advance_next, find_next_commit_on_dev},
-        do_send,
-        messages::{AdvanceNext, AdvanceNextPayload, ValidateRepo},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<AdvanceNext> for RepoActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: AdvanceNext, ctx: &mut Self::Context) -> Self::Result {
-        let Some(repo_config) = &self.repo_details.repo_config else {
-            return;
-        };
-        let Some(open_repository) = &self.open_repository else {
-            return;
-        };
-
-        let AdvanceNextPayload {
-            next,
-            main,
-            dev_commit_history,
-        } = msg.peel();
-        let repo_details = self.repo_details.clone();
-        let repo_config = repo_config.clone();
-        let addr = ctx.address();
-
-        let (commit, force) = find_next_commit_on_dev(&next, &main, &dev_commit_history);
-        if let Some(commit) = &commit {
-            self.update_tui(RepoUpdate::AdvancingNext {
-                commit: commit.clone(),
-                force: force.clone(),
-            });
-        };
-        match advance_next(
-            commit,
-            force,
-            &repo_details,
-            repo_config,
-            &**open_repository,
-            self.message_token,
-        ) {
-            Ok(message_token) => {
-                self.update_tui(RepoUpdate::NextUpdated);
-                match open_repository.fetch() {
-                    Ok(()) => self.update_tui_log(git::graph::log(&self.repo_details)),
-                    Err(err) => self.alert_tui(format!("fetching: {err}")),
-                }
-                // INFO: pause to allow any CI checks to be started
-                let sleep_duration = self.sleep_duration;
-                let log = self.log.clone();
-                async move {
-                    actix_rt::time::sleep(sleep_duration).await;
-                    do_send(&addr, ValidateRepo::new(message_token), log.as_ref());
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-            Err(err) => {
-                warn!("advance next: {err}");
-                self.alert_tui(err.to_string());
-            }
-        }
-    }
-}

crates/cli/src/repo/handlers/check_ci_status.rs

@@ -1,37 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{debug, Instrument as _};
-
-use crate::{
-    repo::{
-        do_send,
-        messages::{CheckCIStatus, ReceiveCIStatus},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<CheckCIStatus> for RepoActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: CheckCIStatus, ctx: &mut Self::Context) -> Self::Result {
-        crate::repo::logger(self.log.as_ref(), "start: CheckCIStatus");
-
-        let addr = ctx.address();
-        let forge = self.forge.duplicate();
-        let next = msg.peel();
-        let log = self.log.clone();
-
-        self.update_tui(RepoUpdate::CheckingCI);
-        // get the status - pass, fail, pending (all others map to fail, e.g. error)
-        async move {
-            let status = forge.commit_status(&next).await;
-            debug!("got status: {status:?}");
-            do_send(&addr, ReceiveCIStatus::new((next, status)), log.as_ref());
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-    }
-}

crates/cli/src/repo/handlers/clone_repo.rs

@@ -1,43 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::git;
-use tracing::{debug, instrument, warn};
-
-use crate::{
-    repo::{
-        do_send, logger,
-        messages::{CloneRepo, LoadConfigFromRepo, RegisterWebhook},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<CloneRepo> for RepoActor {
-    type Result = ();
-    #[instrument(name = "RepoActor::CloneRepo", skip_all, fields(repo = %self.repo_details))]
-    fn handle(&mut self, _msg: CloneRepo, ctx: &mut Self::Context) -> Self::Result {
-        logger(self.log.as_ref(), "Handler: CloneRepo: start");
-        self.update_tui(RepoUpdate::Opening);
-        debug!("Handler: CloneRepo: start");
-        match git::repository::open(&*self.repository_factory, &self.repo_details) {
-            Ok(repository) => {
-                logger(self.log.as_ref(), "open okay");
-                debug!("open okay");
-                self.update_tui(RepoUpdate::Opened);
-                self.open_repository.replace(repository);
-                if self.repo_details.repo_config.is_none() {
-                    do_send(&ctx.address(), LoadConfigFromRepo, self.log.as_ref());
-                } else {
-                    do_send(&ctx.address(), RegisterWebhook::new(), self.log.as_ref());
-                }
-            }
-            Err(err) => {
-                logger(self.log.as_ref(), "open failed");
-                warn!("Could not open repo: {err:?}");
-                self.alert_tui(err.to_string());
-            }
-        }
-        debug!("Handler: CloneRepo: finish");
-    }
-}

crates/cli/src/repo/handlers/load_config_from_repo.rs

@@ -1,54 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::git::UserNotification;
-
-use tracing::{debug, instrument, Instrument as _};
-
-use crate::{
-    repo::{
-        do_send, load,
-        messages::{LoadConfigFromRepo, ReceiveRepoConfig},
-        notify_user, RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<LoadConfigFromRepo> for RepoActor {
-    type Result = ();
-    #[instrument(name = "Repocrate::repo::LoadConfigFromRepo", skip_all, fields(repo = %self.repo_details))]
-    fn handle(&mut self, _msg: LoadConfigFromRepo, ctx: &mut Self::Context) -> Self::Result {
-        debug!("Handler: LoadConfigFromRepo: start");
-        self.update_tui(RepoUpdate::LoadingConfigFromRepo);
-        let Some(open_repository) = &self.open_repository else {
-            return;
-        };
-        let open_repository = open_repository.duplicate();
-        let repo_details = self.repo_details.clone();
-        let forge_alias = repo_details.forge.forge_alias().clone();
-        let repo_alias = repo_details.repo_alias.clone();
-        let addr = ctx.address();
-        let notify_user_recipient = self.notify_user_recipient.clone();
-        let log = self.log.clone();
-        async move {
-            match load::config_from_repository(repo_details, &*open_repository).await {
-                Ok(repo_config) => {
-                    do_send(&addr, ReceiveRepoConfig::new(repo_config), log.as_ref());
-                }
-                Err(err) => notify_user(
-                    notify_user_recipient.as_ref(),
-                    UserNotification::RepoConfigLoadFailure {
-                        forge_alias,
-                        repo_alias,
-                        reason: err.to_string(),
-                    },
-                    log.as_ref(),
-                ),
-            }
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-        debug!("Handler: LoadConfigFromRepo: finish");
-    }
-}

crates/cli/src/repo/handlers/receive_ci_status.rs

@@ -1,75 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::git::{forge::commit::Status, graph, UserNotification};
-use tracing::{debug, Instrument};
-
-use crate::{
-    repo::{
-        do_send, logger,
-        messages::{AdvanceMain, ReceiveCIStatus, ValidateRepo},
-        notify_user, RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<ReceiveCIStatus> for RepoActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: ReceiveCIStatus, ctx: &mut Self::Context) -> Self::Result {
-        logger(self.log.as_ref(), "start: ReceiveCIStatus");
-        let (next, status) = msg.peel();
-        self.update_tui(RepoUpdate::ReceiveCIStatus {
-            status: status.clone(),
-        });
-        debug!(?status, "");
-        let graph_log = graph::log(&self.repo_details);
-        self.update_tui_log(graph_log.clone());
-
-        let addr = ctx.address();
-        let forge_alias = self.repo_details.forge.forge_alias().clone();
-        let repo_alias = self.repo_details.repo_alias.clone();
-        let message_token = self.message_token;
-        let sleep_duration = self.sleep_duration;
-        match status {
-            Status::Pass => {
-                do_send(&addr, AdvanceMain::new(next), self.log.as_ref());
-            }
-            Status::Pending => {
-                let log = self.log.clone();
-                async move {
-                    actix_rt::time::sleep(sleep_duration).await;
-                    do_send(&addr, ValidateRepo::new(message_token), log.as_ref());
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-            Status::Fail => {
-                tracing::warn!("Checks have failed");
-
-                notify_user(
-                    self.notify_user_recipient.as_ref(),
-                    UserNotification::CICheckFailed {
-                        forge_alias,
-                        repo_alias,
-                        commit: next,
-                        log: graph_log,
-                    },
-                    self.log.as_ref(),
-                );
-                let log = self.log.clone();
-                async move {
-                    debug!("sleeping before retrying...");
-                    logger(log.as_ref(), "before sleep");
-                    actix_rt::time::sleep(sleep_duration).await;
-                    logger(log.as_ref(), "after sleep");
-                    do_send(&addr, ValidateRepo::new(message_token), log.as_ref());
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-        }
-    }
-}

crates/cli/src/repo/handlers/receive_repo_config.rs

@@ -1,26 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::instrument;
-
-use crate::{
-    repo::{
-        do_send,
-        messages::{ReceiveRepoConfig, RegisterWebhook},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<ReceiveRepoConfig> for RepoActor {
-    type Result = ();
-    #[instrument(name = "RepoActor::ReceiveRepoConfig", skip_all, fields(repo = %self.repo_details, branches = ?msg))]
-    fn handle(&mut self, msg: ReceiveRepoConfig, ctx: &mut Self::Context) -> Self::Result {
-        let repo_config = msg.peel();
-        self.update_tui(RepoUpdate::ReceiveRepoConfig {
-            repo_config: repo_config.clone(),
-        });
-        self.repo_details.repo_config.replace(repo_config);
-        self.update_tui_branches();
-        do_send(&ctx.address(), RegisterWebhook::new(), self.log.as_ref());
-    }
-}

crates/cli/src/repo/handlers/register_webhook.rs

@@ -1,64 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{debug, error, Instrument as _};
-
-use crate::{
-    repo::{
-        do_send,
-        messages::{RegisterWebhook, WebhookRegistered},
-        notify_user, RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-use git_next_core::git::UserNotification;
-
-impl Handler<RegisterWebhook> for RepoActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: RegisterWebhook, ctx: &mut Self::Context) -> Self::Result {
-        if self.webhook_id.is_none() {
-            let forge_alias = self.repo_details.forge.forge_alias().clone();
-            let repo_alias = self.repo_details.repo_alias.clone();
-            let repo_listen_url = self
-                .listen_url
-                .repo_url(forge_alias.clone(), repo_alias.clone());
-            let forge = self.forge.duplicate();
-            let addr = ctx.address();
-            let notify_user_recipient = self.notify_user_recipient.clone();
-            let log = self.log.clone();
-            self.update_tui(RepoUpdate::RegisteringWebhook);
-            debug!("registering webhook");
-            async move {
-                match forge.register_webhook(&repo_listen_url).await {
-                    Ok(registered_webhook) => {
-                        debug!(?registered_webhook, "webhook registered");
-                        do_send(
-                            &addr,
-                            WebhookRegistered::from(registered_webhook),
-                            log.as_ref(),
-                        );
-                    }
-                    Err(err) => {
-                        error!(?err, "failed to register webhook");
-                        notify_user(
-                            notify_user_recipient.as_ref(),
-                            UserNotification::WebhookRegistration {
-                                forge_alias,
-                                repo_alias,
-                                reason: err.to_string(),
-                            },
-                            log.as_ref(),
-                        );
-                    }
-                }
-            }
-            .in_current_span()
-            .into_actor(self)
-            .wait(ctx);
-        } else {
-            self.alert_tui("already have a webhook id - cant register webhook");
-        }
-    }
-}

crates/cli/src/repo/handlers/unregister_webhook.rs

@@ -1,32 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{debug, warn, Instrument as _};
-
-use crate::{
-    repo::{messages::UnRegisterWebhook, RepoActor},
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<UnRegisterWebhook> for RepoActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: UnRegisterWebhook, ctx: &mut Self::Context) -> Self::Result {
-        let Some(webhook_id) = self.webhook_id.take() else {
-            return;
-        };
-        self.update_tui(RepoUpdate::UnregisteringWebhook);
-        let forge = self.forge.duplicate();
-        debug!("unregistering webhook");
-        async move {
-            match forge.unregister_webhook(&webhook_id).await {
-                Ok(()) => debug!("unregistered webhook"),
-                Err(err) => warn!(?err, "unregistering webhook"),
-            }
-        }
-        .in_current_span()
-        .into_actor(self)
-        .wait(ctx);
-        debug!("unregistering webhook done");
-    }
-}

crates/cli/src/repo/handlers/validate_repo.rs

@@ -1,161 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{info, instrument, Instrument as _};
-
-use crate::{
-    repo::{
-        do_send, logger,
-        messages::{AdvanceNext, AdvanceNextPayload, CheckCIStatus, MessageToken, ValidateRepo},
-        notify_user, RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-use git_next_core::git::{
-    push::Force,
-    validation::positions::{validate, Error, Positions},
-    UserNotification,
-};
-
-impl Handler<ValidateRepo> for RepoActor {
-    type Result = ();
-
-    #[instrument(name = "RepoActor::ValidateRepo", skip_all, fields(repo = %self.repo_details, token = %&*msg))]
-    fn handle(&mut self, msg: ValidateRepo, ctx: &mut Self::Context) -> Self::Result {
-        logger(self.log.as_ref(), "start: ValidateRepo");
-
-        // Message Token - make sure we are only triggered for the latest/current token
-        match self.token_status(msg.peel()) {
-            TokenStatus::Current => {} // do nothing
-            TokenStatus::Expired => {
-                logger(
-                    self.log.as_ref(),
-                    format!("discarded: old message token: {}", self.message_token),
-                );
-                return; // message is expired
-            }
-            TokenStatus::New(message_token) => {
-                self.message_token = message_token;
-                logger(
-                    self.log.as_ref(),
-                    format!("new message token: {}", self.message_token),
-                );
-            }
-        }
-        logger(
-            self.log.as_ref(),
-            format!("accepted token: {}", self.message_token),
-        );
-
-        self.update_tui(RepoUpdate::ValidateRepo);
-
-        // Repository positions
-        let Some(ref open_repository) = self.open_repository else {
-            logger(self.log.as_ref(), "no open repository");
-            self.alert_tui("repo not open");
-            return;
-        };
-        logger(self.log.as_ref(), "have open repository");
-        let Some(repo_config) = self.repo_details.repo_config.clone() else {
-            logger(self.log.as_ref(), "no repo config");
-            self.alert_tui("no repo config");
-            return;
-        };
-        logger(self.log.as_ref(), "have repo config");
-
-        match validate(&**open_repository, &self.repo_details, &repo_config) {
-            Ok((
-                Positions {
-                    main,
-                    next,
-                    dev,
-                    dev_commit_history,
-                    next_is_valid,
-                },
-                git_log,
-            )) => {
-                info!(%main, %next, %dev, "positions");
-                self.update_tui_log(git_log);
-                if next_is_valid && next != main {
-                    info!("Checking CI");
-                    do_send(&ctx.address(), CheckCIStatus::new(next), self.log.as_ref());
-                } else if next != dev {
-                    info!("Advance next");
-                    self.update_tui(RepoUpdate::AdvancingNext {
-                        commit: next.clone(),
-                        force: Force::No,
-                    });
-                    do_send(
-                        &ctx.address(),
-                        AdvanceNext::new(AdvanceNextPayload {
-                            next,
-                            main,
-                            dev_commit_history,
-                        }),
-                        self.log.as_ref(),
-                    );
-                } else {
-                    info!("do nothing");
-                    self.update_tui(RepoUpdate::Okay { main, next, dev });
-                }
-            }
-            Err(Error::Retryable(message)) => {
-                info!(?message, "Retryable");
-                self.alert_tui(format!("retryable: {message}"));
-                logger(self.log.as_ref(), message);
-                let addr = ctx.address();
-                let message_token = self.message_token;
-                let sleep_duration = self.sleep_duration;
-                let log = self.log.clone();
-                async move {
-                    info!("sleeping before retrying...");
-                    logger(log.as_ref(), "before sleep");
-                    actix_rt::time::sleep(sleep_duration).await;
-                    logger(log.as_ref(), "after sleep");
-                    do_send(&addr, ValidateRepo::new(message_token), log.as_ref());
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-            }
-            Err(Error::UserIntervention(user_notification)) => {
-                info!(?user_notification, "User Intervention");
-                self.alert_tui(format!("USER INTERVENTION: {user_notification}"));
-                if let UserNotification::CICheckFailed { log, .. }
-                | UserNotification::DevNotBasedOnMain { log, .. } = &user_notification
-                {
-                    self.update_tui_log(log.clone());
-                }
-                notify_user(
-                    self.notify_user_recipient.as_ref(),
-                    user_notification,
-                    self.log.as_ref(),
-                );
-            }
-            Err(Error::NonRetryable(message)) => {
-                info!(?message, "NonRetryable");
-                self.alert_tui(format!("Error: {message}"));
-                logger(self.log.as_ref(), message);
-            }
-        }
-    }
-}
-
-enum TokenStatus {
-    Current,
-    Expired,
-    New(MessageToken),
-}
-impl RepoActor {
-    fn token_status(&self, new: MessageToken) -> TokenStatus {
-        let current = &self.message_token;
-        if &new > current {
-            return TokenStatus::New(new);
-        }
-        if current > &new {
-            return TokenStatus::Expired;
-        }
-        TokenStatus::Current
-    }
-}

crates/cli/src/repo/handlers/webhook_notification.rs

@@ -1,166 +0,0 @@
-//
-use actix::prelude::*;
-
-use tracing::{info, instrument, warn};
-
-use crate::{
-    repo::{
-        do_send, logger,
-        messages::{ValidateRepo, WebhookNotification},
-        ActorLog, RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-use git_next_core::{
-    git::{Commit, ForgeLike},
-    webhook::{push::Branch, Push},
-    BranchName, WebhookAuth,
-};
-
-impl Handler<WebhookNotification> for RepoActor {
-    type Result = ();
-
-    #[instrument(name = "RepoActor::WebhookMessage", skip_all, fields(token = %self.message_token, repo = %self.repo_details))]
-    fn handle(&mut self, msg: WebhookNotification, ctx: &mut Self::Context) -> Self::Result {
-        let Some(config) = &self.repo_details.repo_config else {
-            logger(self.log.as_ref(), "server has no repo config");
-            warn!("No repo config");
-            return;
-        };
-        if validate_notification(
-            &msg,
-            self.webhook_auth.as_ref(),
-            &*self.forge,
-            self.log.as_ref(),
-        )
-        .is_err()
-        {
-            return;
-        }
-        let body = msg.body();
-        match self.forge.parse_webhook_body(body) {
-            Err(err) => {
-                logger(self.log.as_ref(), "message parse error - not a push");
-                warn!(?err, "Not a 'push'");
-                return;
-            }
-            Ok(push) => match push.branch(config.branches()) {
-                None => {
-                    logger(self.log.as_ref(), "unknown branch");
-                    warn!(
-                        ?push,
-                        "Unrecognised branch, we should be filtering to only the ones we want"
-                    );
-                    return;
-                }
-                Some(Branch::Main) => {
-                    self.update_tui(RepoUpdate::WebhookReceived {
-                        branch: Branch::Main,
-                        push: push.clone(),
-                    });
-                    if handle_push(
-                        push,
-                        &config.branches().main(),
-                        &mut self.last_main_commit,
-                        self.log.as_ref(),
-                    )
-                    .is_err()
-                    {
-                        return;
-                    };
-                }
-                Some(Branch::Next) => {
-                    self.update_tui(RepoUpdate::WebhookReceived {
-                        branch: Branch::Next,
-                        push: push.clone(),
-                    });
-                    if handle_push(
-                        push,
-                        &config.branches().next(),
-                        &mut self.last_next_commit,
-                        self.log.as_ref(),
-                    )
-                    .is_err()
-                    {
-                        return;
-                    };
-                }
-                Some(Branch::Dev) => {
-                    self.update_tui(RepoUpdate::WebhookReceived {
-                        branch: Branch::Dev,
-                        push: push.clone(),
-                    });
-                    if handle_push(
-                        push,
-                        &config.branches().dev(),
-                        &mut self.last_dev_commit,
-                        self.log.as_ref(),
-                    )
-                    .is_err()
-                    {
-                        return;
-                    };
-                }
-            },
-        }
-        let message_token = self.message_token.next();
-        info!(
-            token = %message_token,
-            "New commit"
-        );
-        do_send(
-            &ctx.address(),
-            ValidateRepo::new(message_token),
-            self.log.as_ref(),
-        );
-    }
-}
-
-fn validate_notification(
-    msg: &WebhookNotification,
-    webhook_auth: Option<&WebhookAuth>,
-    forge: &dyn ForgeLike,
-    log: Option<&ActorLog>,
-) -> Result<(), ()> {
-    let Some(expected_authorization) = webhook_auth else {
-        logger(log, "server has no auth token");
-        warn!("Don't know what authorization to expect");
-        return Err(());
-    };
-
-    if !forge.is_message_authorised(msg, expected_authorization) {
-        logger(log, "message authorisation is invalid");
-        warn!(
-            "Invalid authorization - expected {}",
-            expected_authorization
-        );
-        return Err(());
-    }
-    if forge.should_ignore_message(msg) {
-        logger(log, "forge sent ignorable message");
-        return Err(());
-    }
-    Ok(())
-}
-
-fn handle_push(
-    push: Push,
-    branch: &BranchName,
-    last_commit: &mut Option<Commit>,
-    log: Option<&ActorLog>,
-) -> Result<(), ()> {
-    logger(log, format!("message is for {branch} branch"));
-    let commit = Commit::from(push);
-    if last_commit.as_ref() == Some(&commit) {
-        logger(log, format!("not a new commit on {branch}"));
-        info!(
-            %branch ,
-            %commit,
-            "Ignoring - already aware of branch at commit",
-        );
-        return Err(());
-    }
-    last_commit.replace(commit);
-    Ok(())
-}

crates/cli/src/repo/handlers/webhook_registered.rs

@@ -1,27 +0,0 @@
-//
-use actix::prelude::*;
-use tracing::instrument;
-
-use crate::{
-    repo::{
-        do_send,
-        messages::{ValidateRepo, WebhookRegistered},
-        RepoActor,
-    },
-    server::actor::messages::RepoUpdate,
-};
-
-impl Handler<WebhookRegistered> for RepoActor {
-    type Result = ();
-    #[instrument(name = "RepoActor::WebhookRegistered", skip_all, fields(repo = %self.repo_details, webhook_id = %msg.webhook_id()))]
-    fn handle(&mut self, msg: WebhookRegistered, ctx: &mut Self::Context) -> Self::Result {
-        self.update_tui(RepoUpdate::RegisteredWebhook);
-        self.webhook_id.replace(msg.webhook_id().clone());
-        self.webhook_auth.replace(msg.webhook_auth().clone());
-        do_send(
-            &ctx.address(),
-            ValidateRepo::new(self.message_token),
-            self.log.as_ref(),
-        );
-    }
-}

crates/cli/src/repo/messages.rs

@@ -1,127 +0,0 @@
-//
-use derive_more::Display;
-
-use git_next_core::{
-    git::{forge::commit::Status, Commit, UserNotification},
-    message, newtype, ForgeNotification, RegisteredWebhook, RepoConfig, WebhookAuth, WebhookId,
-};
-
-message!(
-    LoadConfigFromRepo,
-    "Request to load the `git-next.toml` from the git repo."
-);
-message!(CloneRepo, "Request to clone (or open) the git repo.");
-message!(
-    ReceiveRepoConfig,
-    RepoConfig,
-    r#"Notification that the `git-next.toml` file has been loaded from the repo and parsed.
-
-Contains the parsed contents of the `git-next.toml` file."#
-);
-message!(
-    ValidateRepo,
-    MessageToken,
-    r#"Request that the state of the branches in the git repo be assessed and generate any followup actions.
-
-This is the main function of `git-next` where decisions are made on what branches need to be updated and when.
-
-Contains a [MessageToken] to reduce duplicate messages being sent. Only messages with the latest [MessageToken] are handled,
-all others are dropped."#
-);
-
-message!(
-    WebhookRegistered,
-    (WebhookId, WebhookAuth),
-    r#"Notification that a webhook has been registered with a forge.
-
-Contains a tuple of the ID for the webhook returned from the forge, and the unique authorisation token that
-incoming messages from the forge must provide."#
-);
-impl WebhookRegistered {
-    pub const fn webhook_id(&self) -> &WebhookId {
-        &self.0 .0
-    }
-    pub const fn webhook_auth(&self) -> &WebhookAuth {
-        &self.0 .1
-    }
-}
-impl From<RegisteredWebhook> for WebhookRegistered {
-    fn from(value: RegisteredWebhook) -> Self {
-        let webhook_id = value.id().clone();
-        let webhook_auth = value.auth().clone();
-        Self::from((webhook_id, webhook_auth))
-    }
-}
-
-message!(
-    UnRegisterWebhook,
-    "Request that the webhook be removed from the forge, so they will stop notifying us."
-);
-
-newtype!(
-    MessageToken,
-    u32,
-    Copy,
-    Default,
-    Display,
-    PartialOrd,
-    Ord,
-    r#"An incremental token used to identify the current set of messages.
-
-Primarily used by [ValidateRepo] to reduce duplicate messages. The token is incremented when a new Webhook message is
-received, marking that message the latest, and causing any previous messages still being processed to be dropped when
-they next send a [ValidateRepo] message."#
-);
-impl MessageToken {
-    pub const fn next(self) -> Self {
-        Self(self.0 + 1)
-    }
-}
-
-message!(
-    RegisterWebhook,
-    "Requests that a Webhook be registered with the forge."
-);
-message!(
-    CheckCIStatus,
-    Commit,
-    r#"Requests that the CI status for the commit be checked.
-
-Once the CI Status has been received it will be sent via a [ReceiveCIStatus] message.
-
-Contains the commit from the tip of the `next` branch."#
-); // next commit
-message!(
-    ReceiveCIStatus,
-    (Commit, Status),
-    r#"Notification of the status of the CI checks for the commit.
-
-Contains a tuple of the commit that was checked (the tip of the `next` branch) and the status."#
-); // commit and it's status
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct AdvanceNextPayload {
-    pub next: Commit,
-    pub main: Commit,
-    pub dev_commit_history: Vec<Commit>,
-}
-message!(
-    AdvanceNext,
-    AdvanceNextPayload,
-    "Request to advance the `next` branch on to the next commit on the `dev branch."
-); // next commit and the dev commit history
-message!(
-    AdvanceMain,
-    Commit,
-    "Request to advance the `main` branch on to same commit as the `next` branch."
-); // next commit
-message!(
-    WebhookNotification,
-    ForgeNotification,
-    "Notification of a webhook message from the forge."
-);
-message!(
-    NotifyUser,
-    UserNotification,
-    "Request to send the message payload to the notification webhook"
-);

crates/cli/src/repo/mod.rs

@@ -1,204 +0,0 @@
-//
-use actix::prelude::*;
-
-use crate::{
-    alerts::messages::NotifyUser,
-    server::{actor::messages::RepoUpdate, ServerActor},
-};
-use derive_more::Deref;
-use kxio::network::Network;
-use tracing::{info, instrument, warn, Instrument};
-
-use git_next_core::{
-    git::{
-        self,
-        repository::{factory::RepositoryFactory, open::OpenRepositoryLike},
-        UserNotification,
-    },
-    server::ListenUrl,
-    WebhookAuth, WebhookId,
-};
-
-mod branch;
-pub mod handlers;
-mod load;
-pub mod messages;
-mod notifications;
-
-#[cfg(test)]
-pub mod tests;
-
-#[derive(Clone, Debug, Default)]
-pub struct ActorLog(std::sync::Arc<std::sync::RwLock<Vec<String>>>);
-impl Deref for ActorLog {
-    type Target = std::sync::Arc<std::sync::RwLock<Vec<String>>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-/// An actor that represents a Git Repository.
-///
-/// When this actor is started it is sent the `CloneRepo` message.
-#[allow(clippy::module_name_repetitions)]
-#[derive(Debug, derive_more::Display, derive_with::With)]
-#[display("{}:{}:{}", generation, repo_details.forge.forge_alias(), repo_details.repo_alias)]
-pub struct RepoActor {
-    sleep_duration: std::time::Duration,
-    generation: git::Generation,
-    message_token: messages::MessageToken,
-    repo_details: git::RepoDetails,
-    listen_url: ListenUrl,
-    webhook_id: Option<WebhookId>, // INFO: if [None] then no webhook is configured
-    webhook_auth: Option<WebhookAuth>, // INFO: if [None] then no webhook is configured
-    last_main_commit: Option<git::Commit>,
-    last_next_commit: Option<git::Commit>,
-    last_dev_commit: Option<git::Commit>,
-    repository_factory: Box<dyn RepositoryFactory>,
-    open_repository: Option<Box<dyn OpenRepositoryLike>>,
-    net: Network,
-    forge: Box<dyn git::ForgeLike>,
-    log: Option<ActorLog>,
-    notify_user_recipient: Option<Recipient<NotifyUser>>,
-    server_addr: Option<Addr<ServerActor>>,
-}
-impl RepoActor {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        repo_details: git::RepoDetails,
-        forge: Box<dyn git::ForgeLike>,
-        listen_url: ListenUrl,
-        generation: git::Generation,
-        net: Network,
-        repository_factory: Box<dyn RepositoryFactory>,
-        sleep_duration: std::time::Duration,
-        notify_user_recipient: Option<Recipient<NotifyUser>>,
-        server_addr: Option<Addr<ServerActor>>,
-    ) -> Self {
-        let message_token = messages::MessageToken::default();
-        Self {
-            generation,
-            message_token,
-            repo_details,
-            listen_url,
-            webhook_id: None,
-            webhook_auth: None,
-            last_main_commit: None,
-            last_next_commit: None,
-            last_dev_commit: None,
-            repository_factory,
-            open_repository: None,
-            forge,
-            net,
-            sleep_duration,
-            log: None,
-            notify_user_recipient,
-            server_addr,
-        }
-    }
-
-    fn update_tui_branches(&self) {
-        if cfg!(feature = "tui") {
-            use crate::server::actor::messages::RepoUpdate;
-            let Some(repo_config) = &self.repo_details.repo_config else {
-                return;
-            };
-            let branches = repo_config.branches().clone();
-            self.update_tui(RepoUpdate::Branches { branches });
-        }
-    }
-
-    #[allow(unused_variables)]
-    fn update_tui_log(&self, log: git::graph::Log) {
-        if cfg!(feature = "tui") {
-            self.update_tui(RepoUpdate::Log { log });
-        }
-    }
-
-    #[allow(unused_variables)]
-    fn alert_tui(&self, alert: impl Into<String>) {
-        if cfg!(feature = "tui") {
-            self.update_tui(RepoUpdate::Alert {
-                alert: alert.into(),
-            });
-        }
-    }
-
-    #[allow(unused_variables)]
-    fn update_tui(&self, repo_update: RepoUpdate) {
-        if cfg!(feature = "tui") {
-            let Some(server_addr) = &self.server_addr else {
-                return;
-            };
-
-            let update = crate::server::actor::messages::ServerUpdate::RepoUpdate {
-                forge_alias: self.repo_details.forge.forge_alias().clone(),
-                repo_alias: self.repo_details.repo_alias.clone(),
-                repo_update,
-            };
-            server_addr.do_send(update);
-        }
-    }
-}
-impl Actor for RepoActor {
-    type Context = Context<Self>;
-    #[instrument(name = "RepoActor::stopping", skip_all, fields(repo = %self.repo_details))]
-    fn stopping(&mut self, ctx: &mut Self::Context) -> Running {
-        tracing::debug!("stopping");
-        info!("Checking webhook");
-        match self.webhook_id.take() {
-            Some(webhook_id) => {
-                tracing::warn!("stopping - unregistering webhook");
-                info!(%webhook_id, "Unregistring webhook");
-                let forge = self.forge.duplicate();
-                async move {
-                    if let Err(err) = forge.unregister_webhook(&webhook_id).await {
-                        warn!("unregistering webhook: {err}");
-                    }
-                }
-                .in_current_span()
-                .into_actor(self)
-                .wait(ctx);
-                Running::Continue
-            }
-            None => Running::Stop,
-        }
-    }
-}
-
-pub fn do_send<M>(addr: &Addr<RepoActor>, msg: M, log: Option<&ActorLog>)
-where
-    M: actix::Message + Send + 'static + std::fmt::Debug,
-    RepoActor: actix::Handler<M>,
-    <M as actix::Message>::Result: Send,
-{
-    let log_message = format!("send: {msg:?}");
-    info!(log_message);
-    logger(log, log_message);
-    if cfg!(not(test)) {
-        // #[cfg(not(test))]
-        addr.do_send(msg);
-    }
-}
-
-pub fn logger(log: Option<&ActorLog>, message: impl Into<String>) {
-    if let Some(log) = log {
-        let message: String = message.into();
-        tracing::debug!(message);
-        let _ = log.write().map(|mut l| l.push(message));
-    }
-}
-pub fn notify_user(
-    recipient: Option<&Recipient<NotifyUser>>,
-    user_notification: UserNotification,
-    log: Option<&ActorLog>,
-) {
-    let msg = NotifyUser::from(user_notification);
-    let log_message = format!("send: {msg:?}");
-    tracing::debug!(log_message);
-    logger(log, log_message);
-    if let Some(recipient) = &recipient {
-        recipient.do_send(msg);
-    }
-}

crates/cli/src/repo/notifications.rs

@@ -1,90 +0,0 @@
-//
-
-use crate::repo::messages::NotifyUser;
-
-use git_next_core::git::UserNotification;
-
-use serde_json::json;
-
-impl NotifyUser {
-    pub fn as_json(&self, timestamp: time::OffsetDateTime) -> serde_json::Value {
-        let timestamp = timestamp.unix_timestamp().to_string();
-        match &**self {
-            UserNotification::CICheckFailed {
-                forge_alias,
-                repo_alias,
-                commit,
-                log,
-            } => json!({
-                "type": "cicheck.failed",
-                "timestamp": timestamp,
-                "data": {
-                    "forge_alias": forge_alias,
-                    "repo_alias": repo_alias,
-                    "commit": {
-                        "sha": commit.sha(),
-                        "message": commit.message()
-                    },
-                    "log": **log
-                }
-            }),
-            UserNotification::RepoConfigLoadFailure {
-                forge_alias,
-                repo_alias,
-                reason,
-            } => json!({
-                "type": "config.load.failed",
-                "timestamp": timestamp,
-                "data": {
-                    "forge_alias": forge_alias,
-                    "repo_alias": repo_alias,
-                    "reason": reason
-                }
-            }),
-            UserNotification::WebhookRegistration {
-                forge_alias,
-                repo_alias,
-                reason,
-            } => json!({
-                "type": "webhook.registration.failed",
-                "timestamp": timestamp,
-                "data": {
-                    "forge_alias": forge_alias,
-                    "repo_alias": repo_alias,
-                    "reason": reason
-                }
-            }),
-            UserNotification::DevNotBasedOnMain {
-                forge_alias,
-                repo_alias,
-                dev_branch,
-                main_branch,
-                dev_commit,
-                main_commit,
-                log,
-            } => json!({
-                "type": "branch.dev.not-on-main",
-                "timestamp": timestamp,
-                "data": {
-                    "forge_alias": forge_alias,
-                    "repo_alias": repo_alias,
-                    "branches": {
-                        "dev": dev_branch,
-                        "main": main_branch
-                    },
-                    "commits": {
-                        "dev": {
-                            "sha": dev_commit.sha(),
-                            "message": dev_commit.message()
-                        },
-                        "main": {
-                            "sha": main_commit.sha(),
-                            "message": main_commit.message()
-                        }
-                    },
-                    "log": **log
-                }
-            }),
-        }
-    }
-}

crates/cli/src/repo/tests/branch/mod.rs

@@ -1,50 +0,0 @@
-use git_next_core::git::push::Force;
-use git_next_core::git::GitRef;
-
-//
-use super::*;
-
-mod advance_main;
-mod advance_next;
-
-use crate::git;
-use crate::repo::branch;
-
-#[actix_rt::test]
-async fn test_find_next_commit_on_dev_when_next_is_at_main() {
-    let next = given::a_commit(); // and main
-    let expected = given::a_commit();
-    let dev_commit_history = vec![
-        given::a_commit(), // dev HEAD
-        expected.clone(),
-        next.clone(),      // next - advancing towards dev HEAD
-        given::a_commit(), // parent of next
-    ];
-
-    let (next_commit, force) = branch::find_next_commit_on_dev(&next, &next, &dev_commit_history);
-
-    assert_eq!(next_commit, Some(expected), "Found the wrong commit");
-    assert_eq!(force, Force::No, "should not try to force");
-}
-
-#[actix_rt::test]
-async fn test_find_next_commit_on_dev_when_next_is_not_on_dev() {
-    let next = given::a_commit();
-    let main = given::a_commit();
-    let expected = given::a_commit();
-    let dev_commit_history = vec![
-        given::a_commit(), // dev HEAD
-        expected.clone(),
-        main.clone(),      // main - advancing towards dev HEAD
-        given::a_commit(), // parent of next
-    ];
-
-    let (next_commit, force) = branch::find_next_commit_on_dev(&next, &main, &dev_commit_history);
-
-    assert_eq!(next_commit, Some(expected), "Found the wrong commit");
-    assert_eq!(
-        force,
-        Force::From(GitRef::from(next.sha().clone())),
-        "should force back onto dev branch"
-    );
-}

crates/cli/src/repo/tests/when.rs

@@ -1,37 +0,0 @@
-//
-use super::*;
-
-pub fn start_actor(
-    repository_factory: MockRepositoryFactory,
-    repo_details: RepoDetails,
-    forge: Box<dyn ForgeLike>,
-) -> (actix::Addr<RepoActor>, ActorLog) {
-    let (actor, log) = given::a_repo_actor(
-        repo_details,
-        Box::new(repository_factory),
-        forge,
-        given::a_network().into(),
-    );
-    (actor.start(), log)
-}
-
-pub fn start_actor_with_open_repository(
-    open_repository: Box<dyn OpenRepositoryLike>,
-    repo_details: RepoDetails,
-    forge: Box<dyn ForgeLike>,
-) -> (actix::Addr<RepoActor>, ActorLog) {
-    let (actor, log) = given::a_repo_actor(repo_details, mock(), forge, given::a_network().into());
-    let actor = actor.with_open_repository(Some(open_repository));
-    (actor.start(), log)
-}
-
-pub fn commit_status(forge: &mut MockForgeLike, commit: Commit, status: Status) {
-    let mut commit_status_forge = MockForgeLike::new();
-    commit_status_forge
-        .expect_commit_status()
-        .with(mockall::predicate::eq(commit))
-        .return_once(|_| status);
-    forge
-        .expect_duplicate()
-        .return_once(move || Box::new(commit_status_forge));
-}

crates/cli/src/server/actor/handlers/file_updated.rs

@@ -1,20 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::server::AppConfig;
-
-use crate::{
-    file_watcher::FileUpdated,
-    server::actor::{messages::ReceiveAppConfig, ServerActor},
-};
-
-impl Handler<FileUpdated> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: FileUpdated, ctx: &mut Self::Context) -> Self::Result {
-        match AppConfig::load(&self.fs) {
-            Ok(app_config) => self.do_send(ReceiveAppConfig::new(app_config), ctx),
-            Err(err) => self.abort(ctx, format!("Failed to load config file. Error: {err}")),
-        };
-    }
-}

crates/cli/src/server/actor/handlers/mod.rs

@@ -1,7 +0,0 @@
-mod file_updated;
-mod receive_app_config;
-mod receive_valid_app_config;
-mod server_update;
-mod shutdown;
-mod shutdown_trigger;
-mod subscribe_updates;

crates/cli/src/server/actor/handlers/receive_app_config.rs

@@ -1,35 +0,0 @@
-use actix::prelude::*;
-
-use crate::server::actor::{
-    messages::{ReceiveAppConfig, ReceiveValidAppConfig, ValidAppConfig},
-    ServerActor,
-};
-
-impl Handler<ReceiveAppConfig> for ServerActor {
-    type Result = ();
-
-    #[allow(clippy::cognitive_complexity)]
-    fn handle(&mut self, msg: ReceiveAppConfig, ctx: &mut Self::Context) -> Self::Result {
-        tracing::info!("recieved server config");
-        let Ok(socket_addr) = msg.listen_socket_addr() else {
-            return self.abort(ctx, "Unable to parse http.addr");
-        };
-
-        let Some(server_storage) = self.server_storage(&msg) else {
-            return self.abort(ctx, "Server storage not available");
-        };
-
-        if msg.listen().url().ends_with('/') {
-            return self.abort(ctx, "webhook.url must not end with a '/'");
-        }
-
-        self.do_send(
-            ReceiveValidAppConfig::new(ValidAppConfig::new(
-                msg.peel(),
-                socket_addr,
-                server_storage,
-            )),
-            ctx,
-        );
-    }
-}

crates/cli/src/server/actor/handlers/receive_valid_app_config.rs

@@ -1,97 +0,0 @@
-//
-use actix::prelude::*;
-
-use git_next_core::{ForgeAlias, RepoAlias};
-use tracing::info;
-
-use crate::{
-    alerts::messages::UpdateShout,
-    repo::{messages::CloneRepo, RepoActor},
-    server::actor::{
-        messages::{ReceiveValidAppConfig, ServerUpdate, ValidAppConfig},
-        ServerActor,
-    },
-    webhook::{
-        messages::ShutdownWebhook,
-        router::{AddWebhookRecipient, WebhookRouterActor},
-        WebhookActor,
-    },
-};
-
-impl Handler<ReceiveValidAppConfig> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: ReceiveValidAppConfig, ctx: &mut Self::Context) -> Self::Result {
-        let ValidAppConfig {
-            app_config,
-            socket_address,
-            storage: server_storage,
-        } = msg.peel();
-        // shutdown any existing webhook actor
-        if let Some(webhook_actor_addr) = self.webhook_actor_addr.take() {
-            webhook_actor_addr.do_send(ShutdownWebhook);
-        }
-        self.generation.inc();
-        // Webhook Server
-        info!("Starting Webhook Server...");
-        let webhook_router = WebhookRouterActor::default().start();
-        let listen_url = app_config.listen().url();
-        let notify_user_recipient = self.alerts.clone().recipient();
-        let server_addr = Some(ctx.address());
-        // Forge Actors
-        for (forge_alias, forge_config) in app_config.forges() {
-            let repo_actors = self
-                .create_forge_repos(
-                    forge_config,
-                    forge_alias.clone(),
-                    &server_storage,
-                    listen_url,
-                    &notify_user_recipient,
-                    server_addr.clone(),
-                )
-                .into_iter()
-                .map(start_repo_actor)
-                .collect::<Vec<_>>();
-            repo_actors
-                .iter()
-                .map(|(repo_alias, addr)| {
-                    AddWebhookRecipient::new(
-                        forge_alias.clone(),
-                        repo_alias.clone(),
-                        addr.clone().recipient(),
-                    )
-                })
-                .for_each(|msg| webhook_router.do_send(msg));
-            for (repo_alias, addr) in repo_actors {
-                self.repo_actors
-                    .insert((forge_alias.clone(), repo_alias), addr);
-            }
-        }
-        let webhook_actor_addr =
-            WebhookActor::new(socket_address, webhook_router.recipient()).start();
-        self.webhook_actor_addr.replace(webhook_actor_addr);
-        let shout = app_config.shout().clone();
-        self.app_config.replace(app_config.clone());
-        self.do_send(
-            ServerUpdate::AppConfigLoaded {
-                app_config: ValidAppConfig {
-                    app_config,
-                    socket_address,
-                    storage: server_storage,
-                },
-            },
-            ctx,
-        );
-        self.alerts.do_send(UpdateShout::new(shout));
-    }
-}
-
-fn start_repo_actor(actor: (ForgeAlias, RepoAlias, RepoActor)) -> (RepoAlias, Addr<RepoActor>) {
-    let (forge_name, repo_alias, actor) = actor;
-    let span = tracing::info_span!("start_repo_actor", forge = %forge_name, repo = %repo_alias);
-    let _guard = span.enter();
-    let addr = actor.start();
-    addr.do_send(CloneRepo);
-    tracing::info!("Started");
-    (repo_alias, addr)
-}

crates/cli/src/server/actor/handlers/server_update.rs

@@ -1,14 +0,0 @@
-use actix::Handler;
-
-//
-use crate::server::{actor::messages::ServerUpdate, ServerActor};
-
-impl Handler<ServerUpdate> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: ServerUpdate, _ctx: &mut Self::Context) -> Self::Result {
-        self.subscribers.iter().for_each(move |subscriber| {
-            subscriber.do_send(msg.clone());
-        });
-    }
-}

crates/cli/src/server/actor/handlers/shutdown.rs

@@ -1,30 +0,0 @@
-//-
-
-use actix::prelude::*;
-use tracing::debug;
-
-use crate::{
-    repo::messages::UnRegisterWebhook,
-    server::actor::{messages::Shutdown, ServerActor},
-    webhook::messages::ShutdownWebhook,
-};
-
-impl Handler<Shutdown> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: Shutdown, _ctx: &mut Self::Context) -> Self::Result {
-        self.repo_actors
-            .iter()
-            .for_each(|((forge_alias, repo_alias), addr)| {
-                debug!(%forge_alias, %repo_alias, "removing webhook");
-                addr.do_send(UnRegisterWebhook::new());
-                debug!(%forge_alias, %repo_alias, "removed webhook");
-            });
-        debug!("server shutdown");
-        if let Some(webhook) = self.webhook_actor_addr.take() {
-            debug!("shutting down webhook");
-            webhook.do_send(ShutdownWebhook);
-            debug!("webhook shutdown");
-        }
-    }
-}

crates/cli/src/server/actor/handlers/shutdown_trigger.rs

@@ -1,12 +0,0 @@
-//
-use actix::Handler;
-
-use crate::server::{actor::messages::ShutdownTrigger, ServerActor};
-
-impl Handler<ShutdownTrigger> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: ShutdownTrigger, _ctx: &mut Self::Context) -> Self::Result {
-        self.shutdown_trigger.replace(msg.peel());
-    }
-}

crates/cli/src/server/actor/handlers/subscribe_updates.rs

@@ -1,10 +0,0 @@
-use crate::server::actor::{messages::SubscribeToUpdates, ServerActor};
-
-//
-impl actix::Handler<SubscribeToUpdates> for ServerActor {
-    type Result = ();
-
-    fn handle(&mut self, msg: SubscribeToUpdates, _ctx: &mut Self::Context) -> Self::Result {
-        self.subscribers.push(msg.peel());
-    }
-}

crates/cli/src/server/actor/messages.rs

@@ -1,113 +0,0 @@
-//
-use actix::{Message, Recipient};
-use derive_more::Constructor;
-
-use git_next_core::{
-    git::{self, forge::commit::Status, graph::Log, Commit},
-    message,
-    server::{AppConfig, Storage},
-    webhook::{push::Branch, Push},
-    ForgeAlias, RepoAlias, RepoBranches, RepoConfig,
-};
-
-use std::net::SocketAddr;
-
-// receive server config
-message!(
-    ReceiveAppConfig,
-    AppConfig,
-    "Notification of newly loaded server configuration.
-
-This message will prompt the `git-next` server to stop and restart all repo-actors.
-
-Contains the new server configuration."
-);
-
-// receive valid server config
-#[derive(Clone, Debug, PartialEq, Eq, Constructor)]
-pub struct ValidAppConfig {
-    pub app_config: AppConfig,
-    pub socket_address: SocketAddr,
-    pub storage: Storage,
-}
-message!(
-    ReceiveValidAppConfig,
-    ValidAppConfig,
-    "Notification of validated server configuration."
-);
-
-message!(Shutdown, "Notification to shutdown the server actor");
-
-#[derive(Clone, Debug, PartialEq, Eq, Message)]
-#[rtype(result = "()")]
-pub enum ServerUpdate {
-    /// List of all configured forges and aliases
-    AppConfigLoaded { app_config: ValidAppConfig },
-
-    RepoUpdate {
-        forge_alias: ForgeAlias,
-        repo_alias: RepoAlias,
-        repo_update: RepoUpdate,
-    },
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum RepoUpdate {
-    Branches {
-        branches: RepoBranches,
-    },
-    Log {
-        log: Log,
-    },
-    ValidateRepo,
-    Okay {
-        main: Commit,
-        next: Commit,
-        dev: Commit,
-    },
-    Alert {
-        alert: String,
-    },
-    CheckingCI,
-    AdvancingNext {
-        commit: git::Commit,
-        force: git::push::Force,
-    },
-    AdvancingMain {
-        commit: git::Commit,
-    },
-    Opening,
-    LoadingConfigFromRepo,
-    ReceiveCIStatus {
-        status: Status,
-    },
-    ReceiveRepoConfig {
-        repo_config: RepoConfig,
-    },
-    RegisteringWebhook,
-    UnregisteringWebhook,
-    WebhookReceived {
-        branch: Branch,
-        push: Push,
-    },
-    RegisteredWebhook,
-    Opened,
-    NextUpdated,
-    MainUpdated,
-}
-
-message!(
-    SubscribeToUpdates,
-    Recipient<ServerUpdate>,
-    "Subscribe to receive updates from the server"
-);
-
-/// Sends a channel to be used to shutdown the server
-#[derive(Message, Constructor)]
-#[rtype(result = "()")]
-pub struct ShutdownTrigger(std::sync::mpsc::Sender<String>);
-impl ShutdownTrigger {
-    pub fn peel(self) -> std::sync::mpsc::Sender<String> {
-        self.0
-    }
-}

crates/cli/src/server/actor/tests/given.rs

@@ -1,18 +0,0 @@
-use std::time::Duration;
-
-use actix::prelude::*;
-
-use crate::alerts::{AlertsActor, History};
-
-//
-pub fn a_filesystem() -> kxio::fs::FileSystem {
-    kxio::fs::temp().unwrap_or_else(|e| panic!("{}", e))
-}
-
-pub fn a_network() -> kxio::network::MockNetwork {
-    kxio::network::MockNetwork::new()
-}
-
-pub fn an_alerts_actor(net: kxio::network::Network) -> Addr<AlertsActor> {
-    AlertsActor::new(None, History::new(Duration::from_millis(1)), net).start()
-}

crates/cli/src/server/actor/tests/mod.rs

@@ -1,3 +0,0 @@
-mod receive_app_config;
-
-mod given;

crates/cli/src/server/actor/tests/receive_app_config.rs

@@ -1,56 +0,0 @@
-//
-use actix::prelude::*;
-
-use crate::server::actor::{tests::given, ReceiveAppConfig, ServerActor};
-use git_next_core::{
-    git,
-    server::{AppConfig, Http, Listen, ListenUrl, Shout, Storage},
-};
-
-use std::{
-    collections::BTreeMap,
-    sync::{Arc, RwLock},
-};
-
-#[test_log::test(actix::test)]
-async fn when_webhook_url_has_trailing_slash_should_not_send() {
-    //given
-    // parameters
-    let fs = given::a_filesystem();
-    let net = given::a_network();
-    let alerts = given::an_alerts_actor(net.clone().into());
-    let repo = git::repository::factory::mock();
-    let duration = std::time::Duration::from_millis(1);
-
-    // sut
-    let server = ServerActor::new(fs.clone(), net.into(), alerts, repo, duration);
-
-    // collaborators
-    let listen = Listen::new(
-        Http::new("0.0.0.0".to_string(), 80),
-        ListenUrl::new("http://localhost/".to_string()), // with trailing slash
-    );
-    let shout = Shout::default();
-    let server_storage = Storage::new((fs.base()).to_path_buf());
-    let repos = BTreeMap::default();
-
-    // debugging
-    let message_log: Arc<RwLock<Vec<String>>> = Arc::new(RwLock::new(vec![]));
-    let server = server.with_message_log(Some(message_log.clone()));
-
-    //when
-    server.start().do_send(ReceiveAppConfig::new(AppConfig::new(
-        listen,
-        shout,
-        server_storage,
-        repos,
-    )));
-    actix_rt::time::sleep(std::time::Duration::from_millis(1)).await;
-
-    //then
-    // INFO: assert that ReceiveValidServerConfig is NOT sent
-    tracing::debug!(?message_log, "");
-    assert!(message_log.read().iter().any(|log| !log
-        .iter()
-        .any(|line| line == "send: ReceiveValidServerConfig")));
-}

crates/cli/src/server/mod.rs

@@ -1,190 +0,0 @@
-//
-pub mod actor;
-
-#[cfg(test)]
-mod tests;
-
-use actix::prelude::*;
-use actix_rt::signal;
-use actor::messages::ShutdownTrigger;
-
-use crate::{
-    alerts::{AlertsActor, History},
-    file_watcher::{watch_file, FileUpdated},
-};
-
-#[allow(clippy::module_name_repetitions)]
-pub use actor::ServerActor;
-
-use git_next_core::git::RepositoryFactory;
-
-use color_eyre::{eyre::Context, Result};
-use kxio::{fs::FileSystem, network::Network};
-use tracing::info;
-
-use std::{
-    path::PathBuf,
-    sync::{atomic::Ordering, mpsc::channel, Arc, RwLock},
-    time::Duration,
-};
-
-const A_DAY: Duration = Duration::from_secs(24 * 60 * 60);
-
-pub fn init(fs: &FileSystem) -> Result<()> {
-    let file_name = "git-next-server.toml";
-    let pathbuf = PathBuf::from(file_name);
-    if fs
-        .path_exists(&pathbuf)
-        .with_context(|| format!("Checking for existing file: {pathbuf:?}"))?
-    {
-        eprintln!("The configuration file already exists at {pathbuf:?} - not overwritting it.",);
-    } else {
-        fs.file_write(&pathbuf, include_str!("server-default.toml"))
-            .with_context(|| format!("Writing file: {pathbuf:?}"))?;
-        println!("Created a default configuration file at {pathbuf:?}",);
-    }
-    Ok(())
-}
-
-#[allow(clippy::too_many_lines)]
-pub fn start(
-    ui: bool,
-    fs: FileSystem,
-    net: Network,
-    repo: Box<dyn RepositoryFactory>,
-    sleep_duration: std::time::Duration,
-) -> Result<()> {
-    if ui {
-        #[cfg(feature = "tui")]
-        {
-            crate::tui::logging::initialize_logging()?;
-        }
-    } else {
-        init_logging();
-    }
-
-    let shutdown_message_holder: Arc<RwLock<Option<String>>> = Arc::new(RwLock::new(None));
-    let shutdown_message_holder_exec = shutdown_message_holder.clone();
-    let file_watcher_err_holder: Arc<RwLock<Option<anyhow::Error>>> = Arc::new(RwLock::new(None));
-    let file_watcher_err_holder_exec = file_watcher_err_holder.clone();
-    let execution = async move {
-        info!("Starting Alert Dispatcher...");
-        let alerts_addr = AlertsActor::new(None, History::new(A_DAY), net.clone()).start();
-
-        info!("Starting Server...");
-        let server =
-            ServerActor::new(fs.clone(), net.clone(), alerts_addr, repo, sleep_duration).start();
-
-        info!("Starting File Watcher...");
-        let watch_file = watch_file("git-next-server.toml".into(), server.clone().recipient());
-        let fw_shutdown = match watch_file {
-            Ok(fw_shutdown) => fw_shutdown,
-            Err(err) => {
-                // shutdown now
-                server.do_send(crate::server::actor::messages::Shutdown);
-                actix_rt::time::sleep(std::time::Duration::from_millis(10)).await;
-                System::current().stop();
-                let _ = file_watcher_err_holder_exec
-                    .write()
-                    .map(|mut o| o.replace(err));
-                return;
-            }
-        };
-
-        let (tx_shutdown, rx_shutdown) = channel::<String>();
-        if ui {
-            #[cfg(feature = "tui")]
-            {
-                use crate::server::actor::messages::SubscribeToUpdates;
-                use crate::tui;
-
-                let tui_addr = tui::Tui::new(tx_shutdown.clone()).start();
-                server.do_send(SubscribeToUpdates::new(tui_addr.clone().recipient()));
-                server.do_send(ShutdownTrigger::new(tx_shutdown));
-                server.do_send(FileUpdated); // update file after ui subscription in place
-                loop {
-                    let _ = tui_addr.send(tui::Tick).await;
-                    if let Ok(message) = rx_shutdown.try_recv() {
-                        let _ = shutdown_message_holder_exec
-                            .write()
-                            .map(|mut o| o.replace(message));
-                        break;
-                    }
-                    actix_rt::time::sleep(Duration::from_millis(16)).await;
-                }
-            }
-        } else {
-            server.do_send(ShutdownTrigger::new(tx_shutdown.clone()));
-            server.do_send(FileUpdated);
-
-            info!("Server running - Press Ctrl-C to stop...");
-            tokio::select! {
-                _r = signal::ctrl_c() => {
-                    info!("Ctrl-C received, shutting down...");
-                }
-                _x = async move {
-                    loop{
-                        if let Ok(message) = rx_shutdown.try_recv() {
-                            let _ = shutdown_message_holder_exec
-                                .write()
-                                .map(|mut o| o.replace(message));
-                            break;
-                        }
-                        actix_rt::task::yield_now().await;
-                    }
-                } => {
-                    info!("signaled shutdown");
-                }
-            };
-        }
-
-        // shutdown
-        fw_shutdown.store(true, Ordering::Relaxed);
-        server.do_send(crate::server::actor::messages::Shutdown);
-        actix_rt::time::sleep(std::time::Duration::from_millis(10)).await;
-        System::current().stop();
-    };
-
-    let system = System::new();
-    Arbiter::current().spawn(execution);
-    system.run()?;
-
-    // check for error from server thread
-    #[allow(clippy::unwrap_used)]
-    if let Some(err) = &*shutdown_message_holder.read().unwrap() {
-        #[cfg(feature = "tui")]
-        if ui {
-            ratatui::restore();
-        }
-        if !err.is_empty() {
-            return Err(color_eyre::eyre::eyre!(format!("{err}")));
-        }
-    }
-
-    // check for error from file watcher thread
-    #[allow(clippy::unwrap_used)]
-    if let Some(err) = &*file_watcher_err_holder.read().unwrap() {
-        #[cfg(feature = "tui")]
-        if ui {
-            ratatui::restore();
-        }
-        return Err(color_eyre::eyre::eyre!(format!("{err}")));
-    }
-
-    Ok(())
-}
-
-pub fn init_logging() {
-    use tracing::Level;
-    use tracing_subscriber::FmtSubscriber;
-
-    let subscriber = FmtSubscriber::builder()
-        .with_target(false)
-        .with_file(true)
-        .with_line_number(true)
-        .with_max_level(Level::INFO)
-        .finish();
-
-    #[allow(clippy::expect_used)]
-    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
-}

crates/cli/src/server/server-default.toml

@@ -1,35 +0,0 @@
-[listen]
-# The address and port to listen to for incoming webhooks from forges.
-http = { addr = "0.0.0.0", port = 8080 }
-
-# The URL where forge should send updates to.
-# This should be route to 'http.addr:http.port' above (e.g. using a reverse proxy)
-url = "https://localhost:8080" # don't include any query path or a trailing slash
-
-[shout] # where updates from git-next should be sent to alert the user
-# webhook = { url = "https//localhost:9090", secret = "secret-password" }
-# desktop = true # enable desktop notifications
-
-# [shout.email]
-# from = "git-next@example.com"
-# to = "developer@example.com"
-#
-# [shout.email.smtp]
-# hostname = "smtp.example.com"
-# username = "git-next@example.com"
-# password = "MySecretEmailPassword42"
-
-[storage] # where local copies of repositories will be cloned (bare) into
-path = "./data"
-
-[forge] # the forges to connect to
-
-# [forge.default]
-# forge_type = "ForgeJo"
-# hostname = "git.example.net"
-# user = "bob"            # the user to perform actions as
-# token = "API-Token"
-#
-# [forge.default.repos] # the repos at the forge to manage
-# hello = { repo = "bob/hello", branch = "main", gitdir = "/opt/git/projects/bob/hello.git" }
-# world = { repo = "bob/world", branch = "master", main = "master", next = "upcoming", "dev" = "develop" }

crates/cli/src/server/tests.rs

@@ -1,151 +0,0 @@
-//
-use assert2::let_assert;
-use git_next_core::{
-    self as core,
-    git::{self, repository::Direction, validation::remotes::validate_default_remotes},
-    ApiToken, ForgeType, GitDir, Hostname, RepoBranches, RepoConfig, RepoConfigSource, RepoPath,
-    StoragePathType, User,
-};
-use secrecy::SecretString;
-
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
-#[test]
-fn test_repo_config_load() -> Result<()> {
-    let toml = r#"[branches]
-            main = "main"
-            next = "next"
-            dev = "dev"
-
-            [options]
-        "#;
-    let config = RepoConfig::parse(toml)?;
-
-    assert_eq!(
-        config,
-        RepoConfig::new(
-            RepoBranches::new("main".to_string(), "next".to_string(), "dev".to_string(),),
-            RepoConfigSource::Repo
-        )
-    );
-
-    Ok(())
-}
-
-#[test]
-fn gitdir_should_display_as_pathbuf() {
-    //given
-    let gitdir = GitDir::new("foo/dir".into(), StoragePathType::External);
-    //when
-    let result = format!("{gitdir}");
-    //then
-    assert_eq!(result, "foo/dir");
-}
-
-#[test]
-// NOTE: this test assumes it is being run in a cloned worktree from the project's home repo:
-// git.kemitix.net:kemitix/git-next
-// If the default push remote is something else, then this test will fail
-fn repo_details_find_default_push_remote_finds_correct_remote() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?;
-    let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
-    let mut repo_details = git::repo_details(
-        1,
-        git::Generation::default(),
-        core::common::forge_details(1, ForgeType::MockForge),
-        None,
-        GitDir::new(root.to_path_buf(), StoragePathType::External), // Server GitDir - should be ignored
-    );
-    repo_details.forge = repo_details
-        .forge
-        .with_user(User::new("git".to_string()))
-        .with_token(ApiToken::new(SecretString::from(String::new())))
-        .with_hostname(Hostname::new("git.kemitix.net"));
-    repo_details.repo_path = RepoPath::new("kemitix/git-next".to_string());
-    let Ok(open_repository) = git::repository::factory::real().open(&repo_details) else {
-        // .git directory may not be present on dev environment
-        return Ok(());
-    };
-    let_assert!(
-        Some(found_git_remote) = open_repository.find_default_remote(Direction::Push),
-        "Default Push Remote not found"
-    );
-    let_assert!(Some(config_git_remote) = repo_details.remote_url());
-
-    assert!(
-        found_git_remote.matches(&config_git_remote),
-        "Default Push Remote must match config"
-    );
-
-    Ok(())
-}
-
-#[test_log::test]
-fn gitdir_validate_should_pass_a_valid_git_repo() -> Result<()> {
-    let cli_crate_dir = std::env::current_dir().map_err(git::validation::remotes::Error::Io)?;
-    let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
-    let mut repo_details = git::repo_details(
-        1,
-        git::Generation::default(),
-        core::common::forge_details(1, ForgeType::MockForge),
-        None,
-        GitDir::new(root.to_path_buf(), StoragePathType::External), // Server GitDir - should be ignored
-    )
-    .with_repo_path(RepoPath::new("kemitix/git-next".to_string()));
-    repo_details.forge = repo_details
-        .forge
-        .with_user(User::new("git".to_string()))
-        .with_token(ApiToken::new(SecretString::from(String::new())))
-        .with_hostname(Hostname::new("git.kemitix.net"));
-    tracing::debug!("opening...");
-    let Ok(repository) = git::repository::factory::real().open(&repo_details) else {
-        // .git directory may not be present on dev environment
-        return Ok(());
-    };
-    tracing::debug!("open okay");
-    tracing::info!(?repository, "FOO");
-    tracing::info!(?repo_details, "BAR");
-    validate_default_remotes(&*repository, &repo_details)?;
-
-    Ok(())
-}
-
-#[test]
-fn gitdir_validate_should_fail_a_git_repo_with_wrong_remote() {
-    let_assert!(
-        Ok(cli_crate_dir) = std::env::current_dir().map_err(git::validation::remotes::Error::Io)
-    );
-    eprintln!("cli_crate_dir: {cli_crate_dir:?}");
-    let_assert!(Some(Some(root)) = cli_crate_dir.parent().map(|p| p.parent()));
-    eprintln!("root: {root:?}");
-    let mut repo_details = git::repo_details(
-        1,
-        git::Generation::default(),
-        core::common::forge_details(1, ForgeType::MockForge),
-        None,
-        GitDir::new(root.to_path_buf(), StoragePathType::External), // Server GitDir - should be ignored
-    )
-    .with_repo_path(RepoPath::new("kemitix/git-next".to_string()));
-    repo_details.forge = repo_details
-        .forge
-        .with_user(User::new("git".to_string()))
-        .with_token(ApiToken::new(SecretString::from(String::new())))
-        .with_hostname(Hostname::new("git.kemitix.net"));
-    let Ok(repository) = git::repository::factory::real().open(&repo_details) else {
-        // .git directory may not be present on dev environment
-        return;
-    };
-    let mut repo_details = repo_details.clone();
-    repo_details.forge = repo_details
-        .forge
-        .with_hostname(Hostname::new("code.kemitix.net"));
-    let_assert!(Err(_) = validate_default_remotes(&*repository, &repo_details));
-}
-
-#[test]
-fn git_remote_to_string_is_as_expected() {
-    let git_remote = git::GitRemote::new(Hostname::new("foo"), RepoPath::new("bar".to_string()));
-    let as_string = git_remote.to_string();
-
-    assert_eq!(as_string, "foo:bar");
-}

crates/cli/src/tests.rs

@@ -8,7 +8,7 @@ mod init {
         let file = fs.base().join(".git-next.toml");
         fs.file_write(&file, "contents")?;
 
-        crate::init::run(&fs)?;
+        crate::init::run(fs.clone());
 
         assert_eq!(
             fs.file_read_to_string(&file)?,
@@ -23,7 +23,7 @@ mod init {
     fn should_create_default_file_if_not_exists() -> TestResult {
         let fs = kxio::fs::temp()?;
 
-        crate::init::run(&fs)?;
+        crate::init::run(fs.clone());
 
         let file = fs.base().join(".git-next.toml");
 
@@ -31,51 +31,10 @@ mod init {
 
         assert_eq!(
             fs.file_read_to_string(&file)?,
-            include_str!("../default.toml"),
+            include_str!("../../../default.toml"),
             "The file does not match the default template"
         );
 
         Ok(())
     }
 }
-mod file_watcher {
-    use std::{sync::atomic::Ordering, time::Duration};
-
-    use actix::{Actor, Context, Handler};
-    use rstest::*;
-
-    use crate::file_watcher::{self, FileUpdated};
-
-    use super::TestResult;
-
-    #[rstest]
-    #[actix::test]
-    #[timeout(Duration::from_millis(80))]
-    async fn should_not_block_calling_thread() -> TestResult {
-        let fs = kxio::fs::temp()?;
-        let path = fs.base().join("file");
-        fs.file_write(&path, "foo")?;
-
-        let listener = Listener;
-        let l_addr = listener.start();
-        let recipient = l_addr.recipient();
-
-        let fw_shutdown = file_watcher::watch_file(path, recipient)?;
-        std::thread::sleep(Duration::from_millis(10));
-        fw_shutdown.store(true, Ordering::Relaxed);
-
-        Ok(()) // was not blocked
-    }
-
-    struct Listener;
-    impl Actor for Listener {
-        type Context = Context<Self>;
-    }
-    impl Handler<FileUpdated> for Listener {
-        type Result = ();
-
-        fn handle(&mut self, _msg: FileUpdated, _ctx: &mut Self::Context) -> Self::Result {
-            // todo!()
-        }
-    }
-}

crates/cli/src/tui/README.md

@@ -1,40 +0,0 @@
-# Terminal UI
-
-Currently the Terminal UI is an experimental feature, controlled by the feature flag `tui`.
-
-## Build & Run
-
-The build `git-next` with the Terminal UI use: `cargo install git-next --features tui`
-
-To run `git-next` with the Terminal UI use: `git-next server start --ui`
-
-### Docker
-
-If using the docker image you will need to create a directory to mount that contains the
-`git-next-server.toml` file. Mount this directory as `/app`. In the example below we use
-the current directory for this.
-
-If you want to persist the clones of your monitored repos then point `storage.path` in
-`git-next-server.toml` to the the directory `/app`, (e.g. `path = "/app/data"`).
-
-Map the port your webhook notifications are arriving on to the port specified in `listen.http.port`.
-
-`docker run -it -p "8080:8092" -v .:/app/ git.kemitix.net/kemitix/git-next:latest server start --ui`
-
-## logs
-
-When the Terminal UI is enabled via the `--ui` parameter, logs are written to the file:
-
-- `???` on Linux
-- `~/Library/Application Support/net.kemitix.git-next/git-next.log` on MacOS
-- `???` on Windows
-
-## Keys
-
-- `q` - Quit
-- `j` - Down
-- `k` - Up
-- `f` - Page Down
-- `b` - Page Up
-- `g` - Top/Home
-- `G` - Bottom/End

crates/cli/src/tui/actor/handlers/mod.rs

@@ -1,3 +0,0 @@
-//
-mod server_update;
-mod tick;

crates/cli/src/tui/actor/handlers/server_update.rs

@@ -1,104 +0,0 @@
-//
-use actix::Handler;
-use ratatui::style::Color;
-
-use crate::{
-    server::actor::messages::{RepoUpdate, ServerUpdate},
-    tui::{actor::ServerState, Tui},
-};
-
-static OKAY: Color = Color::Green;
-static PREP: Color = Color::Gray;
-static ACTING: Color = Color::LightBlue;
-static WARN: Color = Color::Red;
-
-impl Handler<ServerUpdate> for Tui {
-    type Result = ();
-
-    fn handle(&mut self, msg: ServerUpdate, _ctx: &mut Self::Context) -> Self::Result {
-        self.state.tap();
-        match msg {
-            ServerUpdate::AppConfigLoaded { app_config } => {
-                self.state.mode = ServerState::from(app_config);
-            }
-
-            ServerUpdate::RepoUpdate {
-                forge_alias,
-                repo_alias,
-                repo_update,
-            } => {
-                if let ServerState::Configured { forges } = &mut self.state.mode {
-                    let Some(forge_state) = forges.get_mut(&forge_alias) else {
-                        return;
-                    };
-                    let Some(repo_state) = forge_state.repos.get_mut(&repo_alias) else {
-                        return;
-                    };
-                    repo_state.clear_alert();
-                    match repo_update {
-                        RepoUpdate::Branches { branches } => {
-                            repo_state.update_branches(branches);
-                        }
-                        RepoUpdate::Log { log } => {
-                            repo_state.update_log(log);
-                        }
-                        RepoUpdate::ValidateRepo => repo_state.update_message("polling...", ACTING),
-                        RepoUpdate::Okay { main, next, dev } => {
-                            repo_state.clear_alert();
-                            repo_state.update_message("okay", OKAY);
-                            *repo_state = repo_state.clone().ready(main, next, dev);
-                        }
-                        RepoUpdate::Alert { alert } => {
-                            repo_state.alert(alert);
-                        }
-                        RepoUpdate::CheckingCI => {
-                            repo_state.update_message("Checking CI status", ACTING);
-                        }
-                        RepoUpdate::AdvancingNext { commit, force: _ } => {
-                            repo_state
-                                .update_message(format!("advancing next to {commit}"), ACTING);
-                        }
-                        RepoUpdate::NextUpdated => {
-                            repo_state.update_message("next updated - pause while CI starts", OKAY);
-                        }
-                        RepoUpdate::AdvancingMain { commit } => {
-                            repo_state
-                                .update_message(format!("advancing main to {commit}"), ACTING);
-                        }
-                        RepoUpdate::MainUpdated => {
-                            repo_state.update_message("main updated", OKAY);
-                        }
-                        RepoUpdate::Opening => {
-                            repo_state.update_message("opening...", PREP);
-                        }
-                        RepoUpdate::Opened => {
-                            repo_state.update_message("opened", PREP);
-                        }
-                        RepoUpdate::LoadingConfigFromRepo => {
-                            repo_state.update_message("loading config from repo...", PREP);
-                        }
-                        RepoUpdate::ReceiveCIStatus { status } => {
-                            repo_state.update_message(format!("ci status: {status:?}"), WARN);
-                        }
-                        RepoUpdate::ReceiveRepoConfig { repo_config: _ } => {
-                            repo_state.update_message("loaded config from repo", PREP);
-                        }
-                        RepoUpdate::RegisteringWebhook => {
-                            repo_state.update_message("registering webhook...", PREP);
-                        }
-                        RepoUpdate::UnregisteringWebhook => {
-                            repo_state.update_message("unregistering webhook...", PREP);
-                        }
-                        RepoUpdate::WebhookReceived { branch, push: _ } => {
-                            repo_state
-                                .update_message(format!("webhook update: {branch:?}"), ACTING);
-                        }
-                        RepoUpdate::RegisteredWebhook => {
-                            repo_state.update_message("registered webhook", PREP);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

crates/cli/src/tui/actor/handlers/tick.rs

@@ -1,15 +0,0 @@
-//
-use actix::Handler;
-
-use crate::tui::actor::{messages::Tick, Tui};
-
-impl Handler<Tick> for Tui {
-    type Result = std::io::Result<()>;
-
-    fn handle(&mut self, _msg: Tick, ctx: &mut Self::Context) -> Self::Result {
-        self.state.tap();
-        self.draw()?;
-        self.handle_input(ctx)?;
-        Ok(())
-    }
-}

crates/cli/src/tui/actor/messages.rs

@@ -1,4 +0,0 @@
-//
-use git_next_core::message;
-
-message!(Tick => std::io::Result<()>, "Update the TUI");

crates/cli/src/tui/actor/mod.rs

@@ -1,97 +0,0 @@
-//
-mod handlers;
-pub mod messages;
-mod model;
-
-#[cfg(test)]
-mod tests;
-
-use std::sync::mpsc::Sender;
-
-use actix::{Actor, ActorContext as _, Context};
-
-pub use model::*;
-
-use ratatui::{
-    crossterm::event::{self, KeyCode, KeyEventKind},
-    DefaultTerminal,
-};
-use tui_scrollview::ScrollViewState;
-
-#[derive(Debug)]
-pub struct Tui {
-    terminal: Option<DefaultTerminal>,
-    signal_shutdown: Sender<String>,
-    pub state: State,
-    scroll_view_state: ScrollViewState,
-}
-impl Actor for Tui {
-    type Context = Context<Self>;
-    fn started(&mut self, _ctx: &mut Self::Context) {
-        self.terminal.replace(ratatui::init());
-    }
-    fn stopped(&mut self, _ctx: &mut Self::Context) {
-        self.terminal.take();
-        ratatui::restore();
-    }
-}
-impl Tui {
-    pub fn new(signal_shutdown: Sender<String>) -> Self {
-        Self {
-            terminal: None,
-            signal_shutdown,
-            state: State::initial(),
-            scroll_view_state: ScrollViewState::default(),
-        }
-    }
-
-    fn draw(&mut self) -> std::io::Result<()> {
-        let t = self.terminal.take();
-        let scroll_view_state = &mut self.scroll_view_state;
-        let state = &self.state;
-        if let Some(mut terminal) = t {
-            terminal.draw(|frame| {
-                frame.render_stateful_widget(state, frame.area(), scroll_view_state);
-            })?;
-            self.terminal = Some(terminal);
-        } else {
-            eprintln!("No terminal setup");
-        }
-        Ok(())
-    }
-
-    fn handle_input(&mut self, ctx: &mut <Self as actix::Actor>::Context) -> std::io::Result<()> {
-        if event::poll(std::time::Duration::from_millis(16))? {
-            let event::Event::Key(key) = event::read()? else {
-                return Ok(());
-            };
-            if key.kind != KeyEventKind::Press {
-                return Ok(());
-            }
-            match key.code {
-                KeyCode::Char('q') => {
-                    ctx.stop();
-                    if let Err(err) = self.signal_shutdown.send(String::new()) {
-                        tracing::error!(?err, "Failed to signal shutdown");
-                    }
-                }
-                KeyCode::Char('j') | KeyCode::Down => self.scroll_view_state.scroll_down(),
-                KeyCode::Char('k') | KeyCode::Up => self.scroll_view_state.scroll_up(),
-                KeyCode::Char('f') | KeyCode::PageDown => {
-                    self.scroll_view_state.scroll_page_down();
-                }
-                KeyCode::Char('b') | KeyCode::PageUp => {
-                    self.scroll_view_state.scroll_page_up();
-                }
-                KeyCode::Char('g') | KeyCode::Home => {
-                    self.scroll_view_state.scroll_to_top();
-                }
-                KeyCode::Char('G') | KeyCode::End => {
-                    self.scroll_view_state.scroll_to_bottom();
-                }
-                _ => (),
-            }
-        }
-        Ok(())
-    }
-}

crates/cli/src/tui/actor/model.rs

@@ -1,388 +0,0 @@
-//
-use ratatui::{
-    layout::Alignment,
-    prelude::{Buffer, Rect},
-    style::{Color, Style, Stylize as _},
-    symbols::border,
-    text::{Line, Span},
-    widgets::{Block, Paragraph, StatefulWidget, Widget},
-};
-
-use git_next_core::{
-    git::{self, graph::Log, Commit},
-    ForgeAlias, RepoAlias, RepoBranches,
-};
-use tracing::info;
-use tui_scrollview::ScrollViewState;
-
-use std::{collections::BTreeMap, fmt::Display, time::Instant};
-
-use crate::{server::actor::messages::ValidAppConfig, tui::components::ConfiguredAppWidget};
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct State {
-    last_update: Instant,
-    started: Instant,
-    pub mode: ServerState,
-}
-impl State {
-    pub fn initial() -> Self {
-        Self {
-            last_update: Instant::now(),
-            started: Instant::now(),
-            mode: ServerState::Initial { tick: 0 },
-        }
-    }
-
-    pub fn tap(&mut self) {
-        self.last_update = Instant::now();
-        if let ServerState::Initial { tick } = &mut self.mode {
-            *tick += 1;
-        }
-    }
-
-    fn beating_heart(&self) -> String {
-        if self.last_update.duration_since(self.started).as_secs() % 2 == 0 {
-            "💚 "
-        } else {
-            " 💚"
-        }
-        .to_string()
-    }
-}
-
-fn time() -> String {
-    chrono::Local::now().format("%H:%M").to_string()
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum ServerState {
-    /// UI has started but has no information on the state of the server
-    Initial { tick: usize }, // NOTE: for use with throbber-widgets-tui ?
-
-    /// The application configuration has been loaded, individual forges and repos have their own
-    /// states
-    Configured {
-        forges: BTreeMap<ForgeAlias, ForgeState>,
-    },
-}
-impl ServerState {
-    pub fn update_branches(
-        &mut self,
-        forge_alias: &ForgeAlias,
-        repo_alias: &RepoAlias,
-        branches: RepoBranches,
-    ) {
-        if let Self::Configured { forges } = self {
-            let Some(forge_state) = forges.get_mut(forge_alias) else {
-                return;
-            };
-            let Some(repo_state) = forge_state.repos.get_mut(repo_alias) else {
-                return;
-            };
-            match repo_state {
-                RepoState::Configured {
-                    branches: state_branches,
-                    ..
-                }
-                | RepoState::Ready {
-                    branches: state_branches,
-                    ..
-                } => *state_branches = branches,
-
-                RepoState::Identified { .. } => (),
-            }
-        }
-    }
-
-    pub fn update_log(&mut self, forge_alias: &ForgeAlias, repo_alias: &RepoAlias, log: Log) {
-        if let Self::Configured { forges } = self {
-            let Some(forge_state) = forges.get_mut(forge_alias) else {
-                return;
-            };
-            let Some(repo_state) = forge_state.repos.get_mut(repo_alias) else {
-                return;
-            };
-            match repo_state {
-                RepoState::Ready { log: state_log, .. } => *state_log = log,
-
-                RepoState::Identified { .. } | RepoState::Configured { .. } => (),
-            }
-        }
-    }
-}
-impl From<ValidAppConfig> for ServerState {
-    fn from(app_config: ValidAppConfig) -> Self {
-        Self::Configured {
-            forges: app_config
-                .app_config
-                .forges()
-                .map(|(forge_alias, config)| {
-                    (
-                        forge_alias,
-                        config
-                            .repos()
-                            .map(|(repo_alias, server_repo_config)| {
-                                (repo_alias, server_repo_config.repo_config())
-                            })
-                            .map(
-                                |(repo_alias, option_repo_config)| match option_repo_config {
-                                    Some(rc) => (
-                                        repo_alias.clone(),
-                                        RepoState::Configured {
-                                            repo_alias,
-                                            message: RepoMessage::builder()
-                                                .text("configured".into())
-                                                .style(Style::default().fg(Color::LightGreen))
-                                                .build(),
-                                            alert: None,
-                                            branches: rc.branches().clone(),
-                                            log: git::graph::Log::default(),
-                                        },
-                                    ),
-                                    None => (
-                                        repo_alias.clone(),
-                                        RepoState::Identified {
-                                            repo_alias,
-                                            message: RepoMessage::builder()
-                                                .text("identified".into())
-                                                .style(Style::default().fg(Color::Gray))
-                                                .build(),
-                                            alert: None,
-                                        },
-                                    ),
-                                },
-                            )
-                            .collect::<Vec<_>>(),
-                    )
-                })
-                .map(|(forge_alias, vec_repo_alias_state)| {
-                    let forge_state: ForgeState = ForgeState {
-                        alias: forge_alias.clone(),
-                        view_state: ViewState::default(),
-                        repos: vec_repo_alias_state.into_iter().collect::<BTreeMap<_, _>>(),
-                    };
-                    (forge_alias, forge_state)
-                })
-                .collect::<BTreeMap<_, _>>(),
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
-pub enum ViewState {
-    Collapsed,
-    #[default]
-    Expanded,
-}
-impl Display for ViewState {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let view_state = match self {
-            Self::Collapsed => "+",
-            Self::Expanded => "-",
-        };
-        write!(f, "{view_state}")
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub struct ForgeState {
-    pub alias: ForgeAlias,
-    pub view_state: ViewState,
-    pub repos: BTreeMap<RepoAlias, RepoState>,
-}
-
-#[bon::builder]
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct RepoMessage {
-    text: String,
-    style: Style,
-}
-impl From<&RepoMessage> for Span<'_> {
-    fn from(value: &RepoMessage) -> Self {
-        Self::default()
-            .content(value.text.clone())
-            .style(value.style)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum RepoState {
-    Identified {
-        repo_alias: RepoAlias,
-        message: RepoMessage,
-        alert: Option<String>,
-    },
-    Configured {
-        repo_alias: RepoAlias,
-        message: RepoMessage,
-        alert: Option<String>,
-        branches: RepoBranches,
-        log: Log,
-    },
-    Ready {
-        repo_alias: RepoAlias,
-        message: RepoMessage,
-        alert: Option<String>,
-        branches: RepoBranches,
-        view_state: ViewState,
-        main: Commit,
-        next: Commit,
-        dev: Commit,
-        log: Log,
-    },
-}
-impl RepoState {
-    #[tracing::instrument]
-    pub fn update_branches(&mut self, branches: RepoBranches) {
-        match self {
-            Self::Configured {
-                branches: state_branches,
-                ..
-            }
-            | Self::Ready {
-                branches: state_branches,
-                ..
-            } => {
-                *state_branches = branches;
-            }
-
-            Self::Identified { .. } => (),
-        }
-    }
-
-    #[tracing::instrument]
-    pub fn update_log(&mut self, log: Log) {
-        match self {
-            Self::Configured { log: state_log, .. } | Self::Ready { log: state_log, .. } => {
-                *state_log = log;
-            }
-
-            Self::Identified { .. } => {
-                info!("git graph log ignored by ui");
-            }
-        }
-    }
-
-    #[tracing::instrument]
-    pub fn update_message(&mut self, msg: impl Into<String> + std::fmt::Debug, colour: Color) {
-        match self {
-            Self::Identified { message, .. }
-            | Self::Configured { message, .. }
-            | Self::Ready { message, .. } => {
-                info!(?msg, "updating ui");
-                *message = RepoMessage::builder()
-                    .text(msg.into())
-                    .style(Style::default().fg(colour))
-                    .build();
-            }
-        }
-    }
-
-    #[tracing::instrument]
-    pub fn clear_alert(&mut self) {
-        match self {
-            Self::Identified { alert, .. }
-            | Self::Configured { alert, .. }
-            | Self::Ready { alert, .. } => {
-                *alert = None;
-            }
-        }
-    }
-
-    #[tracing::instrument]
-    pub fn alert(&mut self, msg: impl Into<String> + std::fmt::Debug) {
-        let msg: String = msg.into();
-        tracing::info!(%msg, "new tui alert");
-        self.update_message("ALERT", Color::Red);
-        match self {
-            Self::Identified { alert, .. }
-            | Self::Configured { alert, .. }
-            | Self::Ready { alert, .. } => *alert = Some(msg),
-        }
-    }
-
-    pub fn ready(self, main: Commit, next: Commit, dev: Commit) -> Self {
-        match self {
-            Self::Identified {
-                repo_alias,
-                message,
-                alert,
-            } => Self::Identified {
-                repo_alias,
-                message,
-                alert,
-            },
-            Self::Configured {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                log,
-            } => Self::Ready {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                view_state: ViewState::Expanded,
-                main,
-                next,
-                dev,
-                log,
-            },
-            Self::Ready {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                view_state,
-                log,
-                .. // drop existing main, next and dev to use parameters
-            } => Self::Ready {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                view_state,
-                main,
-                next,
-                dev,
-                log,
-            },
-        }
-    }
-}
-
-impl StatefulWidget for &State {
-    type State = ScrollViewState;
-    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)
-    where
-        Self: Sized,
-    {
-        let block = Block::bordered()
-            .title_top(
-                Line::from(format!(" Git-Next v{} ", clap::crate_version!()).bold())
-                    .alignment(Alignment::Center),
-            )
-            .title_bottom(
-                Line::from(vec![
-                    " [q]uit ".into(),
-                    self.beating_heart().into(),
-                    " ".into(),
-                ])
-                .alignment(Alignment::Center),
-            )
-            .title_bottom(Line::from(format!(" {} ", time())).alignment(Alignment::Right))
-            .border_set(border::THICK);
-        let interior = block.inner(area);
-        block.render(area, buf);
-        match &self.mode {
-            ServerState::Initial { tick } => Paragraph::new(format!("Loading...{tick}"))
-                .centered()
-                .render(interior, buf),
-            ServerState::Configured { forges } => {
-                ConfiguredAppWidget { forges }.render(interior, buf, state);
-            }
-        }
-    }
-}

crates/cli/src/tui/actor/tests.rs

@@ -1,99 +0,0 @@
-//
-mod model {
-    mod repo_state {
-        use git_next_core::{git::graph::Log, RepoBranches};
-        use ratatui::style::Style;
-
-        use crate::{
-            repo::tests::given,
-            tui::actor::{RepoMessage, RepoState, ViewState},
-        };
-        type Alert = Option<String>;
-
-        fn identified_with_alert(alert: Alert) -> RepoState {
-            RepoState::Identified {
-                repo_alias: given::a_repo_alias(),
-                message: RepoMessage::builder()
-                    .text(given::a_name())
-                    .style(Style::default())
-                    .build(),
-                alert,
-            }
-        }
-
-        fn configured_with_alert(alert: Alert) -> RepoState {
-            RepoState::Configured {
-                repo_alias: given::a_repo_alias(),
-                message: RepoMessage::builder()
-                    .text(given::a_name())
-                    .style(Style::default())
-                    .build(),
-                alert,
-                branches: RepoBranches::new(String::new(), String::new(), String::new()),
-                log: Log::default(),
-            }
-        }
-        fn ready_with_alert(alert: Alert) -> RepoState {
-            RepoState::Ready {
-                repo_alias: given::a_repo_alias(),
-                message: RepoMessage::builder()
-                    .text(given::a_name())
-                    .style(Style::default())
-                    .build(),
-                alert,
-                branches: RepoBranches::new(String::new(), String::new(), String::new()),
-                log: Log::default(),
-                view_state: ViewState::default(),
-                main: given::a_commit(),
-                next: given::a_commit(),
-                dev: given::a_commit(),
-            }
-        }
-
-        #[rstest::rstest]
-        #[case(identified_with_alert(None))]
-        #[case(configured_with_alert(None))]
-        #[case(ready_with_alert(None))]
-        fn none_alert_remains_none(#[case] mut repo_state: RepoState) {
-            // given
-            match &repo_state {
-                RepoState::Identified { alert, .. }
-                | RepoState::Configured { alert, .. }
-                | RepoState::Ready { alert, .. } => {
-                    assert!(alert.is_none(), "should be none at start");
-                }
-            }
-            // when
-            repo_state.clear_alert();
-            // then
-            match &repo_state {
-                RepoState::Identified { alert, .. }
-                | RepoState::Configured { alert, .. }
-                | RepoState::Ready { alert, .. } => assert!(alert.is_none(), "should remain none"),
-            }
-        }
-
-        #[rstest::rstest]
-        #[case(identified_with_alert(Some(String::new())))]
-        #[case(configured_with_alert(Some(String::new())))]
-        #[case(ready_with_alert(Some(String::new())))]
-        fn some_alert_becomes_none(#[case] mut repo_state: RepoState) {
-            // given
-            match &repo_state {
-                RepoState::Identified { alert, .. }
-                | RepoState::Configured { alert, .. }
-                | RepoState::Ready { alert, .. } => {
-                    assert!(alert.is_some(), "should be some at start");
-                }
-            }
-            // when
-            repo_state.clear_alert();
-            // then
-            match &repo_state {
-                RepoState::Identified { alert, .. }
-                | RepoState::Configured { alert, .. }
-                | RepoState::Ready { alert, .. } => assert!(alert.is_none(), "should become none"),
-            }
-        }
-    }
-}

crates/cli/src/tui/components/configured_app.rs

@@ -1,68 +0,0 @@
-use std::collections::BTreeMap;
-
-use git_next_core::ForgeAlias;
-use ratatui::{
-    buffer::Buffer,
-    layout::{Direction, Layout, Rect, Size},
-    widgets::StatefulWidget,
-};
-use tui_scrollview::{ScrollView, ScrollViewState};
-
-use crate::tui::actor::ForgeState;
-
-use super::{forge::ForgeWidget, HeightContraintLength};
-
-pub struct ConfiguredAppWidget<'a> {
-    pub forges: &'a BTreeMap<ForgeAlias, ForgeState>,
-}
-impl<'a> HeightContraintLength for ConfiguredAppWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        self.children()
-            .iter()
-            .map(HeightContraintLength::height_constraint_length)
-            .sum::<u16>()
-            + 2 // top + bottom borders
-    }
-}
-impl<'a> StatefulWidget for ConfiguredAppWidget<'a> {
-    type State = ScrollViewState;
-
-    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State)
-    where
-        Self: Sized,
-    {
-        let height = self
-            .children()
-            .iter()
-            .map(HeightContraintLength::height_constraint_length)
-            .sum::<u16>();
-        let mut scroll = ScrollView::new(Size::new(area.width - 1, height));
-        let layout_forge_list = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints(
-                self.children()
-                    .iter()
-                    .map(HeightContraintLength::height_constraint_length),
-            )
-            .split(scroll.area());
-
-        self.children()
-            .into_iter()
-            .enumerate()
-            .for_each(|(i, w)| scroll.render_widget(w, layout_forge_list[i]));
-
-        scroll.render(area, buf, state);
-    }
-}
-impl<'a> ConfiguredAppWidget<'a> {
-    fn children(&self) -> Vec<ForgeWidget<'a>> {
-        self.forges
-            .iter()
-            .map(|(forge_alias, state)| ForgeWidget {
-                forge_alias,
-                repos: &state.repos,
-                view_state: state.view_state,
-            })
-            .collect::<Vec<_>>()
-    }
-}

crates/cli/src/tui/components/forge/collapsed.rs

@@ -1,22 +0,0 @@
-//
-use git_next_core::ForgeAlias;
-use ratatui::{buffer::Buffer, layout::Rect, text::Text, widgets::Widget};
-
-use crate::tui::components::HeightContraintLength;
-
-pub struct CollapsedForgeWidget<'a> {
-    pub forge_alias: &'a ForgeAlias,
-}
-impl<'a> HeightContraintLength for CollapsedForgeWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        1
-    }
-}
-impl<'a> Widget for CollapsedForgeWidget<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized,
-    {
-        Text::from(format!("- {}", self.forge_alias)).render(area, buf);
-    }
-}

crates/cli/src/tui/components/forge/expanded.rs

@@ -1,61 +0,0 @@
-//
-use std::collections::BTreeMap;
-
-use git_next_core::{ForgeAlias, RepoAlias};
-use ratatui::{
-    buffer::Buffer,
-    layout::{Alignment, Direction, Layout, Rect},
-    text::Line,
-    widgets::{Block, Widget},
-};
-
-use crate::tui::{
-    actor::RepoState,
-    components::{repo::RepoWidget, HeightContraintLength},
-};
-
-pub struct ExpandedForgeWidget<'a> {
-    pub forge_alias: &'a ForgeAlias,
-    pub repos: &'a BTreeMap<RepoAlias, RepoState>,
-}
-impl<'a> HeightContraintLength for ExpandedForgeWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        self.children()
-            .iter()
-            .map(HeightContraintLength::height_constraint_length)
-            .sum::<u16>()
-            + 2 // top title + bottom padding
-    }
-}
-impl<'a> Widget for ExpandedForgeWidget<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized,
-    {
-        let block = Block::default().title_top(
-            Line::from(format!(" forge: {} ", self.forge_alias)).alignment(Alignment::Left),
-        );
-        let children = self.children();
-        let layout = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints(
-                children
-                    .iter()
-                    .map(HeightContraintLength::height_constraint_length),
-            )
-            .split(block.inner(area));
-        block.render(area, buf);
-        children
-            .into_iter()
-            .enumerate()
-            .for_each(|(i, w)| w.render(layout[i], buf));
-    }
-}
-impl<'a> ExpandedForgeWidget<'a> {
-    fn children(&self) -> Vec<RepoWidget<'a>> {
-        self.repos
-            .values()
-            .map(|repo_state| RepoWidget { repo_state })
-            .collect::<Vec<_>>()
-    }
-}

crates/cli/src/tui/components/forge/mod.rs

@@ -1,53 +0,0 @@
-//
-mod collapsed;
-mod expanded;
-
-use std::collections::BTreeMap;
-
-use collapsed::CollapsedForgeWidget;
-use expanded::ExpandedForgeWidget;
-use git_next_core::{ForgeAlias, RepoAlias};
-use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
-
-use crate::tui::actor::{RepoState, ViewState};
-
-use super::HeightContraintLength;
-
-pub struct ForgeWidget<'a> {
-    pub forge_alias: &'a ForgeAlias,
-    pub repos: &'a BTreeMap<RepoAlias, RepoState>,
-    pub view_state: ViewState,
-}
-impl<'a> HeightContraintLength for ForgeWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        match self.view_state {
-            ViewState::Collapsed => CollapsedForgeWidget {
-                forge_alias: self.forge_alias,
-            }
-            .height_constraint_length(),
-            ViewState::Expanded => ExpandedForgeWidget {
-                forge_alias: self.forge_alias,
-                repos: self.repos,
-            }
-            .height_constraint_length(),
-        }
-    }
-}
-impl<'a> Widget for ForgeWidget<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized,
-    {
-        match self.view_state {
-            ViewState::Collapsed => CollapsedForgeWidget {
-                forge_alias: self.forge_alias,
-            }
-            .render(area, buf),
-            ViewState::Expanded => ExpandedForgeWidget {
-                forge_alias: self.forge_alias,
-                repos: self.repos,
-            }
-            .render(area, buf),
-        }
-    }
-}

crates/cli/src/tui/components/history.rs

@@ -1,128 +0,0 @@
-//
-use git_next_core::git::graph::Log;
-use ratatui::{
-    style::{Color, Style},
-    text::{Line, Span, Text},
-    widgets::{Paragraph, Widget},
-};
-use regex::Regex;
-
-use super::HeightContraintLength;
-
-pub struct CommitLog<'a> {
-    pub log: &'a Log,
-}
-impl<'a> HeightContraintLength for CommitLog<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        u16::try_from(self.log.len()).unwrap_or(u16::MAX)
-    }
-}
-impl<'a> Widget for CommitLog<'a> {
-    fn render(self, area: ratatui::prelude::Rect, buf: &mut ratatui::prelude::Buffer)
-    where
-        Self: Sized,
-    {
-        Paragraph::new(Text::from(
-            self.log
-                .iter()
-                .map(LogLine::new)
-                .map(Line::from)
-                .collect::<Vec<_>>(),
-        ))
-        .render(area, buf);
-    }
-}
-
-struct LogLine {
-    raw: String,
-}
-impl LogLine {
-    fn new(raw: impl Into<String>) -> Self {
-        Self { raw: raw.into() }
-    }
-}
-lazy_static::lazy_static! {
-    static ref RE: Regex =
-    #[allow(clippy::unwrap_used)]
-        Regex::new(
-            r"^(?<pre>.*)\s(?<hash>[0-9a-f]{7})\s\((?<branches>.*?)\)\s(?<message>.*)",
-        ).unwrap();
-
-    static ref BRANCHES: Regex =
-    #[allow(clippy::unwrap_used)]
-        Regex::new(
-            r"origin\/(?<branch>[^,]+)",
-        ).unwrap();
-}
-impl From<LogLine> for Line<'_> {
-    fn from(value: LogLine) -> Self {
-        match RE.captures(&value.raw) {
-            Some(caps) => {
-                let pre = caps["pre"].to_owned();
-                let hash = caps["hash"].to_owned();
-                let message = caps["message"].to_owned();
-                let mut branches = BRANCHES
-                    .captures_iter(&caps["branches"])
-                    .map(|captures| captures["branch"].to_owned())
-                    .filter(|branch| branch != "HEAD")
-                    .collect::<Vec<_>>();
-                if branches.is_empty() {
-                    // line without branches
-                    Line::from(vec![
-                        pre.into(),
-                        " ".into(),
-                        hash.into(),
-                        " ".into(),
-                        message.into(),
-                    ])
-                } else {
-                    // line withbranches
-                    let mut spans = vec![pre.into(), " ".into(), hash.into(), " ".into()];
-                    branches.sort();
-                    branches
-                        .into_iter()
-                        .map(|branch| format!("({branch})"))
-                        .map(Span::from)
-                        .map(|span| span.style(Style::default().fg(Color::White).bg(Color::Blue)))
-                        .for_each(|span| spans.push(span));
-                    spans.push(" ".into());
-                    spans.push(message.into());
-                    Line::from(spans)
-                }
-            }
-            None => {
-                // non-commit line
-                Line::from(value.raw.clone())
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use tracing::info;
-
-    use super::RE;
-
-    #[test_log::test]
-    fn parse_log_line() -> Result<(), Box<dyn std::error::Error>> {
-        let line = "* 97b6853 (origin/next, origin/main, origin/dev, origin/HEAD) refactor(tui): simplify repo identity widget";
-        RE.captures(line).map_or_else(
-            || Err("Failed to capture".into()),
-            |caps| {
-                info!(?caps, "");
-                assert_eq!(&caps["pre"], "*");
-                assert_eq!(&caps["hash"], "97b6853");
-                assert_eq!(
-                    &caps["branches"],
-                    "origin/next, origin/main, origin/dev, origin/HEAD"
-                );
-                assert_eq!(
-                    &caps["message"],
-                    "refactor(tui): simplify repo identity widget"
-                );
-                Ok(())
-            },
-        )
-    }
-}

crates/cli/src/tui/components/mod.rs

@@ -1,12 +0,0 @@
-//
-mod configured_app;
-mod forge;
-mod history;
-mod repo;
-
-pub use configured_app::ConfiguredAppWidget;
-pub use history::CommitLog;
-
-pub trait HeightContraintLength {
-    fn height_constraint_length(&self) -> u16;
-}

crates/cli/src/tui/components/repo/identity.rs

@@ -1,87 +0,0 @@
-use std::string::ToString;
-
-//
-use git_next_core::{RepoAlias, RepoBranches};
-use ratatui::{
-    layout::Alignment,
-    style::{Color, Style, Stylize as _},
-    text::{Line, Span},
-    widgets::block::Title,
-};
-
-use crate::tui::actor::RepoMessage;
-
-pub struct Identity<'a> {
-    pub repo_alias: &'a RepoAlias,
-    pub alert: Option<&'a str>,
-    pub message: &'a RepoMessage,
-    pub repo_branches: Option<&'a RepoBranches>,
-}
-impl<'a> Identity<'a> {
-    pub const fn new(
-        repo_alias: &'a RepoAlias,
-        alert: Option<&'a str>,
-        message: &'a RepoMessage,
-        repo_branches: Option<&'a RepoBranches>,
-    ) -> Self {
-        Self {
-            repo_alias,
-            alert,
-            message,
-            repo_branches,
-        }
-    }
-}
-impl<'a> Identity<'a> {
-    fn spans(self) -> Vec<Span<'a>> {
-        let alert = self
-            .alert
-            .map(ToString::to_string)
-            .map(|alert| alert.fg(Color::White).bg(Color::Red));
-        let message = self.message;
-        let main = self
-            .repo_branches
-            .map(RepoBranches::main)
-            .map_or_else(|| "_".to_string(), |b| b.to_string());
-        let next = self
-            .repo_branches
-            .map(RepoBranches::next)
-            .map_or_else(|| "_".to_string(), |b| b.to_string());
-        let dev = self
-            .repo_branches
-            .map(RepoBranches::dev)
-            .map_or_else(|| "_".to_string(), |b| b.to_string());
-        let mut spans = vec![" ".into()];
-        match alert {
-            None => spans.push(
-                Span::from(self.repo_alias.to_string()).style(Style::default().fg(Color::Cyan)),
-            ),
-            Some(alert) => {
-                spans.push(
-                    Span::from(self.repo_alias.to_string())
-                        .style(Style::default().fg(Color::White).bg(Color::Red)),
-                );
-                spans.push(" ".into());
-                spans.push(alert);
-            }
-        }
-        spans.push(" ".into());
-        spans.push(format!("({main} -> {next} -> {dev}) ").into());
-        spans.push(message.into());
-        spans.push(" ".into());
-        spans
-    }
-}
-impl<'a> From<Identity<'a>> for Title<'a> {
-    fn from(identity: Identity<'a>) -> Self {
-        Self {
-            content: Line {
-                spans: identity.spans(),
-                style: Style::reset(),
-                alignment: None,
-            },
-            alignment: Some(Alignment::Left),
-            position: None,
-        }
-    }
-}

crates/cli/src/tui/components/repo/mod.rs

@@ -1,114 +0,0 @@
-//
-mod identity;
-
-use std::string::String;
-
-use git_next_core::{RepoAlias, RepoBranches};
-
-use crate::{
-    git,
-    tui::{
-        actor::{RepoMessage, RepoState},
-        components::CommitLog,
-    },
-};
-
-use identity::Identity;
-
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    widgets::{Block, Borders, Widget},
-};
-
-use super::HeightContraintLength;
-
-pub struct RepoWidget<'a> {
-    pub repo_state: &'a RepoState,
-}
-impl<'a> HeightContraintLength for RepoWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        self.inner().height_constraint_length() + 2 // top + bottom borders
-    }
-}
-impl<'a> RepoWidget<'a> {
-    fn inner(&self) -> InnerRepoWidget {
-        match self.repo_state {
-            RepoState::Identified {
-                repo_alias,
-                message,
-                alert,
-            } => InnerRepoWidget {
-                repo_alias,
-                message,
-                alert: alert.as_ref().map(String::as_str),
-                branches: None,
-                log: None,
-            },
-
-            RepoState::Configured {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                log,
-            }
-            | RepoState::Ready {
-                repo_alias,
-                message,
-                alert,
-                branches,
-                log,
-                ..
-            } => InnerRepoWidget {
-                repo_alias,
-                message,
-                alert: alert.as_ref().map(String::as_str),
-                branches: Some(branches),
-                log: Some(log),
-            },
-        }
-    }
-}
-impl<'a> Widget for RepoWidget<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized,
-    {
-        self.inner().render(area, buf);
-    }
-}
-
-struct InnerRepoWidget<'a> {
-    pub repo_alias: &'a RepoAlias,
-    pub message: &'a RepoMessage,
-    pub alert: Option<&'a str>,
-    pub branches: Option<&'a RepoBranches>,
-    pub log: Option<&'a git::graph::Log>,
-}
-impl<'a> HeightContraintLength for InnerRepoWidget<'a> {
-    fn height_constraint_length(&self) -> u16 {
-        self.log
-            .map(|log| CommitLog { log })
-            .map_or(0, |w| w.height_constraint_length())
-    }
-}
-impl<'a> Widget for InnerRepoWidget<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer)
-    where
-        Self: Sized,
-    {
-        let block = Block::default()
-            .title(Identity::new(
-                self.repo_alias,
-                self.alert,
-                self.message,
-                self.branches,
-            ))
-            .borders(Borders::TOP);
-        if let Some(log) = self.log {
-            CommitLog { log }.render(block.inner(area), buf);
-        }
-        block.render(area, buf);
-    }
-}

crates/cli/src/tui/logging.rs

@@ -1,86 +0,0 @@
-//
-use std::path::PathBuf;
-
-use color_eyre::eyre::Result;
-use directories::ProjectDirs;
-use lazy_static::lazy_static;
-use tracing_error::ErrorLayer;
-use tracing_subscriber::{self, layer::SubscriberExt, util::SubscriberInitExt, Layer};
-
-lazy_static! {
-    pub static ref PROJECT_NAME: String = env!("CARGO_CRATE_NAME").to_uppercase();
-    pub static ref DATA_FOLDER: Option<PathBuf> =
-        std::env::var(format!("{}_DATA", PROJECT_NAME.clone()))
-            .ok()
-            .map(PathBuf::from);
-    pub static ref LOG_ENV: String = format!("{}_LOGLEVEL", PROJECT_NAME.clone());
-    pub static ref LOG_FILE: String = format!("{}.log", env!("CARGO_PKG_NAME"));
-}
-
-fn project_directory() -> Option<ProjectDirs> {
-    ProjectDirs::from("net", "kemitix", env!("CARGO_PKG_NAME"))
-}
-
-pub fn get_data_dir() -> PathBuf {
-    let directory = DATA_FOLDER.clone().map_or_else(
-        || {
-            project_directory().map_or_else(
-                || PathBuf::from(".").join(".data"),
-                |proj_dirs| proj_dirs.data_local_dir().to_path_buf(),
-            )
-        },
-        |data_folder| data_folder,
-    );
-    directory
-}
-
-pub fn initialize_logging() -> Result<()> {
-    let directory = get_data_dir();
-    std::fs::create_dir_all(directory.clone())?;
-    let log_path = directory.join(LOG_FILE.clone());
-    let log_file = std::fs::File::create(log_path)?;
-    std::env::set_var(
-        "RUST_LOG",
-        std::env::var("RUST_LOG")
-            .or_else(|_| std::env::var(LOG_ENV.clone()))
-            .unwrap_or_else(|_| format!("{}=info", env!("CARGO_CRATE_NAME"))),
-    );
-    let file_subscriber = tracing_subscriber::fmt::layer()
-        .with_file(true)
-        .with_line_number(true)
-        .with_writer(log_file)
-        .with_target(false)
-        .with_ansi(false)
-        .with_filter(tracing_subscriber::filter::EnvFilter::from_default_env());
-    tracing_subscriber::registry()
-        .with(file_subscriber)
-        .with(ErrorLayer::default())
-        .init();
-    Ok(())
-}
-
-/// Similar to the `std::dbg!` macro, but generates `tracing` events rather
-/// than printing to stdout.
-///
-/// By default, the verbosity level for the generated events is `DEBUG`, but
-/// this can be customized.
-#[macro_export]
-macro_rules! trace_dbg {
-    (target: $target:expr, level: $level:expr, $ex:expr) => {{
-        match $ex {
-            value => {
-                tracing::event!(target: $target, $level, ?value, stringify!($ex));
-                value
-            }
-        }
-    }};
-    (level: $level:expr, $ex:expr) => {
-        trace_dbg!(target: module_path!(), level: $level, $ex)
-    };
-    (target: $target:expr, $ex:expr) => {
-        trace_dbg!(target: $target, level: tracing::Level::DEBUG, $ex)
-    };
-    ($ex:expr) => {
-        trace_dbg!(level: tracing::Level::DEBUG, $ex)
-    };
-}

crates/cli/src/tui/mod.rs

@@ -1,7 +0,0 @@
-//
-mod actor;
-pub mod components;
-pub mod logging;
-
-pub use actor::messages::Tick;
-pub use actor::Tui;

crates/cli/src/webhook/handlers/mod.rs

@@ -1 +0,0 @@
-mod shutdown_webhook;

crates/cli/src/webhook/handlers/shutdown_webhook.rs

@@ -1,13 +0,0 @@
-//
-use actix::prelude::*;
-
-use crate::webhook::{messages::ShutdownWebhook, WebhookActor};
-
-impl Handler<ShutdownWebhook> for WebhookActor {
-    type Result = ();
-
-    fn handle(&mut self, _msg: ShutdownWebhook, ctx: &mut Self::Context) -> Self::Result {
-        self.spawn_handle.take();
-        ctx.stop();
-    }
-}

crates/cli/src/webhook/messages.rs

@@ -1,4 +0,0 @@
-//
-use git_next_core::message;
-
-message!(ShutdownWebhook, "Request to shutdown the Webhook actor");

crates/config/Cargo.toml

@@ -1,19 +1,10 @@
 [package]
-name = "git-next-core"
+name = "git-next-config"
 version = { workspace = true }
 edition = { workspace = true }
 license = { workspace = true }
 repository = { workspace = true }
-description = "core for git-next, the trunk-based development manager"
+description = "Base types for git-next, the trunk-based development manager"
-
-[lints.clippy]
-nursery = { level = "warn", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
-unwrap_used = "warn"
-expect_used = "warn"
-
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
 
 [features]
 default = ["forgejo", "github"]
@@ -27,11 +18,9 @@ tracing = { workspace = true }
 # fs/network
 kxio = { workspace = true }
 
-# Actors
-actix = { workspace = true }
-
 # TOML parsing
 serde = { workspace = true }
+# serde_json = { workspace = true }
 toml = { workspace = true }
 
 # Secrets and Password
@@ -40,11 +29,9 @@ secrecy = { workspace = true }
 # Git
 gix = { workspace = true }
 git-url-parse = { workspace = true }
-async-trait = { workspace = true }
 
 # Webhooks
 ulid = { workspace = true }
-time = { workspace = true }
 
 # boilerplate
 derive_more = { workspace = true }
@@ -52,17 +39,15 @@ derive-with = { workspace = true }
 thiserror = { workspace = true }
 pike = { workspace = true }
 
-# TOML parsing
-serde_json = { workspace = true }
-
-mockall = { workspace = true }
-
-#iters
-take-until = { workspace = true }
-
 [dev-dependencies]
-# Testing
+# # Testing
 assert2 = { workspace = true }
 rand = { workspace = true }
-test-log = { workspace = true }
 pretty_assertions = { workspace = true }
+test-log = { workspace = true }
+
+[lints.clippy]
+nursery = { level = "warn", priority = -1 }
+# pedantic = "warn"
+unwrap_used = "warn"
+expect_used = "warn"

crates/config/src/api_token.rs

@@ -1,16 +1,16 @@
 /// The API Token for the [user]
-/// `ForgeJo`: <https://{hostname}/user/settings/applications>
+/// ForgeJo: https://{hostname}/user/settings/applications
-/// `Github`:  <https://github.com/settings/tokens>
+/// Github:  https://github.com/settings/tokens
 #[derive(Clone, Debug, derive_more::Constructor)]
-pub struct ApiToken(secrecy::SecretString);
+pub struct ApiToken(secrecy::Secret<String>);
 /// The API Token is in effect a password, so it must be explicitly exposed to access its value
-impl secrecy::ExposeSecret<str> for ApiToken {
+impl secrecy::ExposeSecret<String> for ApiToken {
-    fn expose_secret(&self) -> &str {
+    fn expose_secret(&self) -> &String {
         self.0.expose_secret()
     }
 }
 impl Default for ApiToken {
     fn default() -> Self {
-        Self(String::new().into())
+        Self("".to_string().into())
     }
 }

crates/config/src/branch_name.rs

@@ -0,0 +1 @@
+crate::newtype!(BranchName: String, derive_more::Display, Default: "The name of a Git branch");

crates/config/src/common.rs

@@ -0,0 +1,49 @@
+use crate::{
+    ApiToken, BranchName, ForgeAlias, ForgeDetails, ForgeType, Hostname, RepoAlias, RepoBranches,
+    RepoConfig, RepoConfigSource, RepoPath, User,
+};
+
+pub fn forge_details(n: u32, forge_type: ForgeType) -> ForgeDetails {
+    ForgeDetails::new(
+        forge_name(n),
+        forge_type,
+        hostname(n),
+        user(n),
+        api_token(n),
+    )
+}
+
+pub fn api_token(n: u32) -> ApiToken {
+    ApiToken::new(format!("api-{}", n).into())
+}
+
+pub fn user(n: u32) -> User {
+    User::new(format!("user-{}", n))
+}
+
+pub fn hostname(n: u32) -> Hostname {
+    Hostname::new(format!("hostname-{}", n))
+}
+
+pub fn forge_name(n: u32) -> ForgeAlias {
+    ForgeAlias::new(format!("forge-name-{}", n))
+}
+
+pub fn branch_name(n: u32) -> BranchName {
+    BranchName::new(format!("branch-name-{}", n))
+}
+
+pub fn repo_path(n: u32) -> RepoPath {
+    RepoPath::new(format!("repo-path-{}", n))
+}
+
+pub fn repo_alias(n: u32) -> RepoAlias {
+    RepoAlias::new(format!("repo-alias-{}", n))
+}
+
+pub fn repo_config(n: u32, source: RepoConfigSource) -> RepoConfig {
+    RepoConfig::new(
+        RepoBranches::new(format!("main-{n}"), format!("next-{n}"), format!("dev-{n}")),
+        source,
+    )
+}

crates/config/src/forge_alias.rs

@@ -0,0 +1,6 @@
+crate::newtype!(ForgeAlias: String, Hash, PartialOrd, Ord, derive_more::Display, Default: "The name of a Forge to connect to");
+impl From<&ForgeAlias> for std::path::PathBuf {
+    fn from(value: &ForgeAlias) -> Self {
+        Self::from(&value.0)
+    }
+}

crates/config/src/forge_config.rs

@@ -1,8 +1,6 @@
 use std::collections::BTreeMap;
 
-use crate::config::{ApiToken, ForgeType, Hostname, RepoAlias, ServerRepoConfig, User};
+use crate::{ApiToken, ForgeType, Hostname, RepoAlias, ServerRepoConfig, User};
-
-use super::CommitCount;
 
 /// Defines a Forge to connect to
 /// Maps from `git-next-server.toml` at `forge.{forge}`
@@ -24,38 +22,31 @@ pub struct ForgeConfig {
     hostname: String,
     user: String,
     token: String,
-    max_dev_commits: Option<u32>,
     repos: BTreeMap<String, ServerRepoConfig>,
 }
 impl ForgeConfig {
-    pub(crate) const fn forge_type(&self) -> ForgeType {
+    pub const fn forge_type(&self) -> ForgeType {
         self.forge_type
     }
 
-    pub(crate) fn hostname(&self) -> Hostname {
+    pub fn hostname(&self) -> Hostname {
         Hostname::new(&self.hostname)
     }
 
-    pub(crate) fn user(&self) -> User {
+    pub fn user(&self) -> User {
         User::new(self.user.clone())
     }
 
-    pub(crate) fn token(&self) -> ApiToken {
+    pub fn token(&self) -> ApiToken {
         ApiToken::new(self.token.clone().into())
     }
 
-    pub(crate) fn max_dev_commits(&self) -> Option<CommitCount> {
-        self.max_dev_commits.map(CommitCount::from)
-    }
-
     pub fn repos(&self) -> impl Iterator<Item = (RepoAlias, &ServerRepoConfig)> {
         self.repos
             .iter()
             .map(|(name, repo)| (RepoAlias::new(name), repo))
     }
 
-    #[cfg(test)]
-    #[must_use]
     pub fn get_repo(&self, arg: &str) -> Option<&ServerRepoConfig> {
         self.repos.get(arg)
     }

crates/config/src/forge_details.rs

@@ -0,0 +1,41 @@
+use crate::{ApiToken, ForgeAlias, ForgeConfig, ForgeType, Hostname, User};
+
+/// The derived information about a Forge, used to create interactions with it
+#[derive(Clone, Default, Debug, derive_more::Constructor, derive_with::With)]
+pub struct ForgeDetails {
+    forge_alias: ForgeAlias,
+    forge_type: ForgeType,
+    hostname: Hostname,
+    user: User,
+    token: ApiToken,
+    // API Token
+    // Private SSH Key Path
+}
+impl ForgeDetails {
+    pub const fn forge_alias(&self) -> &ForgeAlias {
+        &self.forge_alias
+    }
+    pub const fn forge_type(&self) -> ForgeType {
+        self.forge_type
+    }
+    pub const fn hostname(&self) -> &Hostname {
+        &self.hostname
+    }
+    pub const fn user(&self) -> &User {
+        &self.user
+    }
+    pub const fn token(&self) -> &ApiToken {
+        &self.token
+    }
+}
+impl From<(&ForgeAlias, &ForgeConfig)> for ForgeDetails {
+    fn from(forge: (&ForgeAlias, &ForgeConfig)) -> Self {
+        Self {
+            forge_alias: forge.0.clone(),
+            forge_type: forge.1.forge_type(),
+            hostname: forge.1.hostname(),
+            user: forge.1.user(),
+            token: forge.1.token(),
+        }
+    }
+}

crates/config/src/forge_type.rs

@@ -24,6 +24,6 @@ pub enum ForgeType {
 }
 impl std::fmt::Display for ForgeType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{self:?}")
+        write!(f, "{:?}", self)
     }
 }

crates/config/src/git_dir.rs

@@ -22,15 +22,13 @@ pub struct GitDir {
     storage_path_type: StoragePathType,
 }
 impl GitDir {
-    pub(crate) const fn pathbuf(&self) -> &PathBuf {
+    pub const fn pathbuf(&self) -> &PathBuf {
         &self.pathbuf
     }
-
+    pub const fn storage_path_type(&self) -> StoragePathType {
-    pub(crate) const fn storage_path_type(&self) -> StoragePathType {
         self.storage_path_type
     }
-
+    pub fn as_fs(&self) -> kxio::fs::FileSystem {
-    pub(crate) fn as_fs(&self) -> kxio::fs::FileSystem {
         pike! {
             self
             |> Self::pathbuf

crates/config/src/host_name.rs

@@ -0,0 +1,2 @@
+// The hostname of a forge
+crate::newtype!(Hostname: String, derive_more::Display, Default: "The hostname for the forge");