Merge pull request #123 from gsd-build/fix/122-pi-provider-migration
feat: migrate provider credentials from existing Pi install
This commit is contained in:
TÂCHES
GitHub
commit
352c55b70d
16 changed files with 1995 additions and 247 deletions
1
.claude/worktrees/agent-aca4a27a
Submodule
1
.claude/worktrees/agent-aca4a27a
Submodule
|
|
@ -0,0 +1 @@
|
|||
Subproject commit 00d9aed6b03298b902452da0a29d9a8ff7f7f7c7
|
||||
|
|
@ -16,3 +16,6 @@
|
|||
| D008 | M001 | arch | Pre-merge verification timing | Phase 3 (enhanced features) | Core service + bug fixes first. Current workflow hasn't been catastrophic without guards. | No |
|
||||
| D009 | M001 | arch | Doc fixes timing | Phase 1 (with bug fixes) | Pure text changes, zero risk, related to same git mechanics | No |
|
||||
| D010 | M001 | arch | Test strategy | Unit tests with temp repos | Same proven pattern as existing worktree.test.ts | No |
|
||||
| D011 | M001/S01 | arch | GitService reuses worktree.ts pure utilities | Import detectWorktreeName, getSliceBranchName, SLICE_BRANCH_RE from worktree.ts | These are pure functions with no side effects. Reimplementing would create drift. S02 facade wiring won't break these exports. | No |
|
||||
| D012 | M001/S01 | arch | RUNTIME_EXCLUSION_PATHS defined independently | Define exclusion paths in git-service.ts independently of gitignore.ts BASELINE_PATTERNS | Keeps S01 self-contained without touching gitignore.ts. BASELINE_PATTERNS is unexported. Converge later if needed. | Yes — converge in future cleanup |
|
||||
| D013 | M001/S01 | impl | COMMIT_TYPE_RULES includes plural keyword forms | Added "docs" and "tests" as explicit keywords alongside singular "doc" and "test" | Word-boundary regex `\bdoc\b` doesn't match "docs" — the trailing `s` is a word character. Plurals are common in slice titles. | No |
|
||||
|
|
|
|||
|
|
@ -1,21 +1,18 @@
|
|||
# GSD State
|
||||
|
||||
**Active Milestone:** M001 — Deterministic GitService
|
||||
**Active Slice:** S01 — GitService core implementation
|
||||
**Active Task:** none
|
||||
**Phase:** Planning
|
||||
**Slice Branch:** none
|
||||
**Active Workspace:** main
|
||||
**Next Action:** Plan S01 — decompose into tasks with must-haves
|
||||
**Last Updated:** 2026-03-12
|
||||
**Active Slice:** S02 — Wire GitService into codebase
|
||||
**Phase:** planning
|
||||
**Requirements Status:** 18 active · 0 validated · 3 deferred · 6 out of scope
|
||||
|
||||
## Recent Decisions
|
||||
## Milestone Registry
|
||||
- 🔄 **M001:** Deterministic GitService
|
||||
|
||||
- D001: Smart staging via exclusion filter (not file ownership tracking)
|
||||
- D002: worktree.ts becomes thin facade (keep exports, delegate internally)
|
||||
- D003: Delete merged branches (squash commit is the permanent record)
|
||||
## Recent Decisions
|
||||
- None recorded
|
||||
|
||||
## Blockers
|
||||
- None
|
||||
|
||||
- (none)
|
||||
## Next Action
|
||||
Plan slice S02 (Wire GitService into codebase).
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ This milestone is complete only when all are true:
|
|||
|
||||
## Slices
|
||||
|
||||
- [ ] **S01: GitService core implementation** `risk:high` `depends:[]`
|
||||
- [x] **S01: GitService core implementation** `risk:high` `depends:[]`
|
||||
> After this: `git-service.ts` exists with commit, autoCommit, ensureSliceBranch, switchToMain, mergeSliceToMain, inferCommitType, smart staging — all passing unit tests in temp git repos.
|
||||
|
||||
- [ ] **S02: Wire GitService into codebase** `risk:high` `depends:[S01]`
|
||||
|
|
|
|||
78
.gsd/milestones/M001/slices/S01/S01-PLAN.md
Normal file
78
.gsd/milestones/M001/slices/S01/S01-PLAN.md
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
# S01: GitService Core Implementation
|
||||
|
||||
**Goal:** A standalone `GitServiceImpl` class in `git-service.ts` that encapsulates all git mechanics — commit, autoCommit, ensureSliceBranch, switchToMain, mergeSliceToMain, smart staging, commit type inference — with comprehensive unit tests passing in temp git repos.
|
||||
**Demo:** `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` passes all assertions.
|
||||
|
||||
## Must-Haves
|
||||
|
||||
- `GitServiceImpl` class with constructor `(basePath: string, prefs?: GitPreferences)`
|
||||
- `GitPreferences` interface exported (auto_push, push_branches, remote, snapshots, pre_merge_check, commit_type)
|
||||
- `commit(opts: CommitOptions)` with smart staging exclusion filter + fallback to `git add -A`
|
||||
- `autoCommit(unitType: string, unitId: string)` using smart staging
|
||||
- `ensureSliceBranch(milestoneId, sliceId)` with worktree-aware naming, branch-from-current logic, pre-checkout auto-commit using smart staging
|
||||
- `switchToMain()` with pre-checkout auto-commit using smart staging
|
||||
- `mergeSliceToMain(milestoneId, sliceId, sliceTitle)` with `inferCommitType()` instead of hardcoded `feat`
|
||||
- `inferCommitType(sliceTitle: string)` exported as pure function
|
||||
- `getMainBranch()`, `getCurrentBranch()`, `isOnSliceBranch()`, `getActiveSliceBranch()`
|
||||
- `RUNTIME_EXCLUSION_PATHS` exported constant (the 6 GSD runtime paths)
|
||||
- Unit tests covering: smart staging exclusion, smart staging fallback, commit type inference for all types, branch lifecycle, merge with correct commit type, empty-commit-after-staging guard
|
||||
|
||||
## Proof Level
|
||||
|
||||
- This slice proves: contract
|
||||
- Real runtime required: no (temp git repos in tests)
|
||||
- Human/UAT required: no
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass
|
||||
- `npm run build` — TypeScript compilation still passes (git-service.ts is in extensions, excluded from tsc, but verify no import breakage)
|
||||
- `npm run test` — all existing tests still pass (no regressions)
|
||||
|
||||
## Observability / Diagnostics
|
||||
|
||||
- Runtime signals: None — this is a library module, not a runtime service. Errors surface as thrown `Error` instances with descriptive messages including the failed git command and basePath.
|
||||
- Inspection surfaces: Test output shows pass/fail counts per test group. `git log` in temp repos verifies commit messages and types.
|
||||
- Failure visibility: All `runGit()` failures include the full git command and working directory in the error message. Smart staging fallback logs a warning to stderr when exclusion pathspecs fail.
|
||||
- Redaction constraints: None — no secrets handled.
|
||||
|
||||
## Integration Closure
|
||||
|
||||
- Upstream surfaces consumed: None (first slice)
|
||||
- New wiring introduced in this slice: `git-service.ts` module with `GitServiceImpl` class and exports — standalone, not yet consumed by any caller
|
||||
- What remains before the milestone is truly usable end-to-end: S02 (wire into auto.ts/worktree.ts), S03 (bug fixes), S04 (remove git from prompts), S05 (enhanced features), S06 (cleanup)
|
||||
|
||||
## Tasks
|
||||
|
||||
- [x] **T01: Create git-service.ts with GitPreferences, RUNTIME_EXCLUSION_PATHS, runGit, and inferCommitType** `est:30m`
|
||||
- Why: Foundation types, constants, and pure functions that everything else depends on. Separating these first means T02/T03 can build on stable exports.
|
||||
- Files: `src/resources/extensions/gsd/git-service.ts`, `src/resources/extensions/gsd/tests/git-service.test.ts`
|
||||
- Do: Define `GitPreferences` interface with all fields (defaulting to safe values). Export `RUNTIME_EXCLUSION_PATHS` array matching the 6 GSD runtime paths from BASELINE_PATTERNS/SKIP_PATHS. Implement local `runGit()` (same pattern as worktree.ts). Implement `inferCommitType(sliceTitle)` as exported pure function with keyword matching for fix/refactor/docs/test/chore, defaulting to feat. Create test file with test scaffolding (assert/assertEq helpers, temp repo setup) and tests for `inferCommitType` covering all types + default. Tests for `RUNTIME_EXCLUSION_PATHS` matching the known 6 paths.
|
||||
- Verify: `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` passes
|
||||
- Done when: `inferCommitType` returns correct types for all keyword variants, `RUNTIME_EXCLUSION_PATHS` has exactly the 6 expected paths, tests pass
|
||||
|
||||
- [x] **T02: Implement GitServiceImpl — smart staging, commit, and autoCommit** `est:45m`
|
||||
- Why: The core value of GitService is smart staging (R002) and centralized commit (R001). This task builds the `GitServiceImpl` class with the staging/commit methods that all other operations depend on.
|
||||
- Files: `src/resources/extensions/gsd/git-service.ts`, `src/resources/extensions/gsd/tests/git-service.test.ts`
|
||||
- Do: Implement `GitServiceImpl` class with `(basePath, prefs)` constructor. Implement private `smartStage()` using `git add -A -- . ':(exclude)path'` for each RUNTIME_EXCLUSION_PATHS entry, with fallback to `git add -A` + stderr warning on failure. Implement `commit(opts: CommitOptions)` that calls smartStage, checks `git diff --cached --stat` for empty, builds conventional commit message. Implement `autoCommit(unitType, unitId)`. Add tests: smart staging excludes runtime files, smart staging fallback works, commit with message, autoCommit on clean repo returns null, autoCommit on dirty repo commits and returns message, empty-after-staging guard (only runtime files dirty → no commit).
|
||||
- Verify: All new tests pass alongside T01 tests
|
||||
- Done when: Smart staging provably excludes `.gsd/activity/`, `.gsd/runtime/`, `.gsd/STATE.md`, `.gsd/auto.lock`, `.gsd/metrics.json`, `.gsd/worktrees/` while staging other files. Fallback to `git add -A` works when pathspec fails.
|
||||
|
||||
- [x] **T03: Implement branch lifecycle — ensureSliceBranch, switchToMain, branch queries** `est:40m`
|
||||
- Why: Covers R001 branch operations. These methods replicate the logic from worktree.ts but route staging through smart staging instead of `git add -A`.
|
||||
- Files: `src/resources/extensions/gsd/git-service.ts`, `src/resources/extensions/gsd/tests/git-service.test.ts`
|
||||
- Do: Implement `getMainBranch()`, `getCurrentBranch()`, `isOnSliceBranch()`, `getActiveSliceBranch()` — same logic as worktree.ts. Implement `ensureSliceBranch(milestoneId, sliceId)` with worktree detection, branch-from-current-not-main logic, pre-checkout smart staging auto-commit. Implement `switchToMain()` with pre-checkout smart staging auto-commit. Add tests: branch creation, idempotent ensure, branch-from-non-main-working-branch, branch-from-slice-falls-back-to-main, switchToMain auto-commits dirty files using smart staging (verify runtime files excluded), query methods return correct values on main vs slice branch.
|
||||
- Verify: All tests pass including branch lifecycle tests
|
||||
- Done when: `ensureSliceBranch` and `switchToMain` use smart staging for pre-checkout commits, branch creation logic matches worktree.ts behavior, all query methods work correctly
|
||||
|
||||
- [x] **T04: Implement mergeSliceToMain with inferCommitType and full integration tests** `est:40m`
|
||||
- Why: Closes R001 (merge), R003 (commit type inference in merge), R009 (fixes hardcoded feat). This is the capstone method that proves the full GitService lifecycle works end-to-end.
|
||||
- Files: `src/resources/extensions/gsd/git-service.ts`, `src/resources/extensions/gsd/tests/git-service.test.ts`
|
||||
- Do: Implement `mergeSliceToMain(milestoneId, sliceId, sliceTitle)` — switchToMain, verify on main, check branch exists, check commits ahead, squash merge, use `inferCommitType(sliceTitle)` for commit message (not hardcoded feat), delete branch. Add integration tests: full lifecycle (create branch → commit on branch → merge → verify commit message type), merge with fix title → `fix(...)` commit, merge with docs title → `docs(...)` commit, merge with feature title → `feat(...)` commit, error cases (not on main, branch doesn't exist, no commits ahead). Run `npm run build` and `npm run test` to verify no regressions.
|
||||
- Verify: `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass. `npm run build` passes. `npm run test` passes.
|
||||
- Done when: Full GitService lifecycle works in tests, merge commits use inferred type from slice title, all existing tests still pass, build is green
|
||||
|
||||
## Files Likely Touched
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` (new)
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` (new)
|
||||
59
.gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md
Normal file
59
.gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
---
|
||||
estimated_steps: 5
|
||||
estimated_files: 2
|
||||
---
|
||||
|
||||
# T01: Create git-service.ts with GitPreferences, RUNTIME_EXCLUSION_PATHS, runGit, and inferCommitType
|
||||
|
||||
**Slice:** S01 — GitService Core Implementation
|
||||
**Milestone:** M001
|
||||
|
||||
## Description
|
||||
|
||||
Create the `git-service.ts` module with the foundational types, constants, and pure functions. This establishes the `GitPreferences` interface that the entire milestone depends on, the `RUNTIME_EXCLUSION_PATHS` constant that smart staging uses, and `inferCommitType()` which fixes the hardcoded `feat` bug (R009). Also sets up the test file with the project's established test pattern (manual assert/assertEq, temp git repos, main() async wrapper).
|
||||
|
||||
## Steps
|
||||
|
||||
1. Create `src/resources/extensions/gsd/git-service.ts` with imports (`node:fs`, `node:child_process`, `node:path`, `node:os`).
|
||||
2. Define and export `GitPreferences` interface: `auto_push?: boolean`, `push_branches?: boolean`, `remote?: string`, `snapshots?: boolean`, `pre_merge_check?: boolean | string`, `commit_type?: string`.
|
||||
3. Define and export `CommitOptions` interface: `message: string`, `allowEmpty?: boolean`.
|
||||
4. Define and export `MergeSliceResult` interface (same shape as worktree.ts): `branch: string`, `mergedCommitMessage: string`, `deletedBranch: boolean`.
|
||||
5. Export `RUNTIME_EXCLUSION_PATHS` constant: the 6 GSD runtime paths (`[".gsd/activity/", ".gsd/runtime/", ".gsd/worktrees/", ".gsd/auto.lock", ".gsd/metrics.json", ".gsd/STATE.md"]`).
|
||||
6. Implement local `runGit(basePath, args, options?)` function — same pattern as worktree.ts (execSync, trim, allowFailure flag, descriptive error message).
|
||||
7. Implement and export `inferCommitType(sliceTitle: string): string` — keyword matching: `fix`/`bug`/`patch`/`hotfix` → `fix`, `refactor`/`restructure`/`reorganize` → `refactor`, `doc`/`documentation` → `docs`, `test`/`testing` → `test`, `chore`/`cleanup`/`clean up`/`archive`/`remove`/`delete` → `chore`. Case-insensitive word boundary matching. Default: `feat`.
|
||||
8. Create `src/resources/extensions/gsd/tests/git-service.test.ts` following worktree.test.ts pattern: imports, assert/assertEq helpers, `run()` helper, temp repo setup, async `main()`.
|
||||
9. Add tests for `inferCommitType`: feature title → `feat`, fix title → `fix`, refactor title → `refactor`, docs title → `docs`, test title → `test`, chore title → `chore`, mixed keywords → first match wins, unknown → `feat`.
|
||||
10. Add test verifying `RUNTIME_EXCLUSION_PATHS` contains exactly the 6 expected paths.
|
||||
|
||||
## Must-Haves
|
||||
|
||||
- [ ] `GitPreferences` interface exported with all 6 fields
|
||||
- [ ] `CommitOptions` interface exported
|
||||
- [ ] `MergeSliceResult` interface exported
|
||||
- [ ] `RUNTIME_EXCLUSION_PATHS` exported with exactly 6 paths matching SKIP_PATHS + SKIP_EXACT
|
||||
- [ ] `inferCommitType()` exported, returns correct type for all keyword categories
|
||||
- [ ] `inferCommitType()` defaults to `feat` for unrecognized titles
|
||||
- [ ] Test file follows project test pattern (assert/assertEq, async main, process.exit on failure)
|
||||
- [ ] All tests pass
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass with 0 failures
|
||||
|
||||
## Observability Impact
|
||||
|
||||
- Signals added/changed: None — pure types, constants, and functions
|
||||
- How a future agent inspects this: Read exports from `git-service.ts`, run the test file
|
||||
- Failure state exposed: `inferCommitType` is pure — bad output is immediately visible in test assertions
|
||||
|
||||
## Inputs
|
||||
|
||||
- `src/resources/extensions/gsd/worktree.ts` — `MergeSliceResult` interface shape, `runGit()` pattern
|
||||
- `src/resources/extensions/gsd/gitignore.ts` — `BASELINE_PATTERNS` (first 6 entries = GSD runtime paths)
|
||||
- `src/resources/extensions/gsd/worktree-manager.ts` — `SKIP_PATHS` + `SKIP_EXACT` (same 6 paths)
|
||||
- `src/resources/extensions/gsd/tests/worktree.test.ts` — test infrastructure pattern
|
||||
|
||||
## Expected Output
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — module with `GitPreferences`, `CommitOptions`, `MergeSliceResult`, `RUNTIME_EXCLUSION_PATHS`, `runGit()`, `inferCommitType()`
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — test file with passing tests for inferCommitType and RUNTIME_EXCLUSION_PATHS
|
||||
59
.gsd/milestones/M001/slices/S01/tasks/T02-PLAN.md
Normal file
59
.gsd/milestones/M001/slices/S01/tasks/T02-PLAN.md
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
---
|
||||
estimated_steps: 5
|
||||
estimated_files: 2
|
||||
---
|
||||
|
||||
# T02: Implement GitServiceImpl — smart staging, commit, and autoCommit
|
||||
|
||||
**Slice:** S01 — GitService Core Implementation
|
||||
**Milestone:** M001
|
||||
|
||||
## Description
|
||||
|
||||
Build the `GitServiceImpl` class with the core value proposition: smart staging (R002) that excludes GSD runtime paths, and centralized commit/autoCommit methods (R001). The smart staging uses git's `:(exclude)` pathspec syntax to filter runtime paths from `git add`, with a fallback to `git add -A` if the pathspec fails. This is the foundational class that T03 and T04 build upon.
|
||||
|
||||
## Steps
|
||||
|
||||
1. Add `GitServiceImpl` class to `git-service.ts` with constructor `(basePath: string, prefs: GitPreferences = {})`. Store basePath and prefs as readonly properties.
|
||||
2. Implement private `git(args, options?)` instance method that calls the module-level `runGit(this.basePath, args, options)`.
|
||||
3. Implement private `smartStage()` method: build pathspec string `git add -A -- . ':(exclude).gsd/activity/' ':(exclude).gsd/runtime/' ...` for all RUNTIME_EXCLUSION_PATHS entries. Execute via `runGit`. On failure (catch), log warning to stderr (`console.error("GitService: smart staging failed, falling back to git add -A")`), then execute `git add -A` as fallback.
|
||||
4. Implement `commit(opts: CommitOptions)` method: call `smartStage()`, check `git diff --cached --stat` — if empty and not `allowEmpty`, return null. Build commit message, execute `git commit -m ${JSON.stringify(opts.message)}`. Return the commit message string.
|
||||
5. Implement `autoCommit(unitType: string, unitId: string)` method: check `git status --short` — if clean, return null. Call `smartStage()`, check `git diff --cached --stat` — if empty return null (all changes were runtime files). Build message `chore(${unitId}): auto-commit after ${unitType}`, commit, return message.
|
||||
6. Add tests to `git-service.test.ts`: create temp repo, create GitServiceImpl instance.
|
||||
- Test smart staging excludes runtime files: create `.gsd/activity/log.jsonl`, `.gsd/runtime/state.json`, `.gsd/STATE.md`, `.gsd/auto.lock`, `.gsd/metrics.json`, `.gsd/worktrees/wt/file.txt` plus a real file `src/code.ts`. Call `commit()`. Verify only `src/code.ts` is in the commit (check `git show --stat HEAD`). Verify runtime files are still untracked/unstaged.
|
||||
- Test smart staging fallback: mock a scenario where exclusion fails (e.g., use a bad pathspec) and verify fallback to `git add -A` stages everything.
|
||||
- Test autoCommit on clean repo returns null.
|
||||
- Test autoCommit on dirty repo: create a file, call autoCommit, verify commit exists with correct message format.
|
||||
- Test empty-after-staging guard: create only runtime files (`.gsd/activity/x.jsonl`), call autoCommit, verify returns null and no commit is created.
|
||||
|
||||
## Must-Haves
|
||||
|
||||
- [ ] `GitServiceImpl` class with constructor `(basePath, prefs?)`
|
||||
- [ ] Smart staging uses `:(exclude)` pathspecs for all 6 RUNTIME_EXCLUSION_PATHS
|
||||
- [ ] Smart staging falls back to `git add -A` with stderr warning on pathspec failure
|
||||
- [ ] `commit()` returns null when nothing staged after smart staging
|
||||
- [ ] `commit()` uses `JSON.stringify` for shell-escaping commit messages
|
||||
- [ ] `autoCommit()` returns null on clean repo
|
||||
- [ ] `autoCommit()` returns null when only runtime files are dirty (empty-after-staging)
|
||||
- [ ] `autoCommit()` returns commit message string on success
|
||||
- [ ] All tests pass
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass including new staging/commit tests
|
||||
|
||||
## Observability Impact
|
||||
|
||||
- Signals added/changed: stderr warning when smart staging fallback activates — this is the primary diagnostic signal for staging issues
|
||||
- How a future agent inspects this: Check stderr output during commits for "smart staging failed" messages. Check `git show --stat HEAD` after commits to verify which files were included.
|
||||
- Failure state exposed: Fallback warning on stderr. Null return from commit/autoCommit when no files to stage.
|
||||
|
||||
## Inputs
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — T01 output: types, constants, runGit, inferCommitType
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — T01 output: test scaffolding with passing inferCommitType tests
|
||||
|
||||
## Expected Output
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — updated with `GitServiceImpl` class, `smartStage()`, `commit()`, `autoCommit()`
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — updated with smart staging and commit tests passing
|
||||
62
.gsd/milestones/M001/slices/S01/tasks/T03-PLAN.md
Normal file
62
.gsd/milestones/M001/slices/S01/tasks/T03-PLAN.md
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
---
|
||||
estimated_steps: 5
|
||||
estimated_files: 2
|
||||
---
|
||||
|
||||
# T03: Implement branch lifecycle — ensureSliceBranch, switchToMain, branch queries
|
||||
|
||||
**Slice:** S01 — GitService Core Implementation
|
||||
**Milestone:** M001
|
||||
|
||||
## Description
|
||||
|
||||
Add branch management methods to `GitServiceImpl` that replicate the logic from `worktree.ts` but route all staging through smart staging. This covers `ensureSliceBranch`, `switchToMain`, and the branch query methods (`getMainBranch`, `getCurrentBranch`, `isOnSliceBranch`, `getActiveSliceBranch`). The key difference from worktree.ts: pre-checkout auto-commits use `smartStage()` instead of `git add -A`, so runtime files are never accidentally committed during branch switches.
|
||||
|
||||
## Steps
|
||||
|
||||
1. Add `getMainBranch()` method to `GitServiceImpl` — reuse exact logic from `worktree.ts` (`detectWorktreeName`, worktree branch check, `symbolic-ref`, main/master fallback, current branch fallback). Import `detectWorktreeName`, `getSliceBranchName`, `SLICE_BRANCH_RE` from worktree.ts (these are pure utility functions that don't change in S02).
|
||||
2. Add `getCurrentBranch()`, `isOnSliceBranch()`, `getActiveSliceBranch()` methods — same logic as worktree.ts standalone functions, using `this.git()`.
|
||||
3. Implement `ensureSliceBranch(milestoneId, sliceId)` method: detect worktree name, compute branch name, check if already on branch (return false), create branch if needed (branch-from-current-not-main logic, slice-to-slice falls back to main), check worktree conflict, pre-checkout auto-commit using `autoCommit("pre-switch", currentBranch)`, checkout, return created boolean.
|
||||
4. Implement `switchToMain()` method: get main branch, check if already on main (return early), auto-commit dirty state via `autoCommit("pre-switch", currentBranch)`, checkout main.
|
||||
5. Add tests:
|
||||
- `ensureSliceBranch` creates branch and checks it out
|
||||
- `ensureSliceBranch` is idempotent (second call returns false)
|
||||
- `ensureSliceBranch` from non-main working branch inherits artifacts
|
||||
- `ensureSliceBranch` from another slice branch falls back to main
|
||||
- `ensureSliceBranch` auto-commits dirty files before checkout using smart staging (verify runtime files NOT in the auto-commit)
|
||||
- `switchToMain` auto-commits dirty files using smart staging
|
||||
- `switchToMain` is idempotent when already on main
|
||||
- `getCurrentBranch`, `isOnSliceBranch`, `getActiveSliceBranch` return correct values on main vs slice branch
|
||||
|
||||
## Must-Haves
|
||||
|
||||
- [ ] `getMainBranch()` handles worktree, origin/HEAD, main/master fallback
|
||||
- [ ] `getCurrentBranch()` returns current branch name
|
||||
- [ ] `isOnSliceBranch()` returns true on slice branch, false on main
|
||||
- [ ] `getActiveSliceBranch()` returns branch name or null
|
||||
- [ ] `ensureSliceBranch()` creates branch from current working branch (not main) when current is not a slice branch
|
||||
- [ ] `ensureSliceBranch()` creates branch from main when current branch IS a slice branch
|
||||
- [ ] `ensureSliceBranch()` auto-commits dirty state via smart staging before checkout
|
||||
- [ ] `switchToMain()` auto-commits dirty state via smart staging before checkout
|
||||
- [ ] All tests pass
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass including branch lifecycle tests
|
||||
|
||||
## Observability Impact
|
||||
|
||||
- Signals added/changed: None beyond what T02 established (smart staging fallback warning). Pre-checkout auto-commits are visible in `git log`.
|
||||
- How a future agent inspects this: `git log --oneline` shows auto-commit messages before branch switches. `git branch -a` shows created slice branches.
|
||||
- Failure state exposed: Throws descriptive Error if branch is checked out in another worktree. Throws on checkout failure with git command and basePath in message.
|
||||
|
||||
## Inputs
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — T02 output: `GitServiceImpl` with smartStage, commit, autoCommit
|
||||
- `src/resources/extensions/gsd/worktree.ts` — `detectWorktreeName`, `getSliceBranchName`, `SLICE_BRANCH_RE` imports (pure utilities)
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — T02 output: existing passing tests
|
||||
|
||||
## Expected Output
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — updated with `getMainBranch()`, `getCurrentBranch()`, `isOnSliceBranch()`, `getActiveSliceBranch()`, `ensureSliceBranch()`, `switchToMain()`
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — updated with branch lifecycle tests passing
|
||||
63
.gsd/milestones/M001/slices/S01/tasks/T04-PLAN.md
Normal file
63
.gsd/milestones/M001/slices/S01/tasks/T04-PLAN.md
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
---
|
||||
estimated_steps: 4
|
||||
estimated_files: 2
|
||||
---
|
||||
|
||||
# T04: Implement mergeSliceToMain with inferCommitType and full integration tests
|
||||
|
||||
**Slice:** S01 — GitService Core Implementation
|
||||
**Milestone:** M001
|
||||
|
||||
## Description
|
||||
|
||||
The capstone task: implement `mergeSliceToMain()` which uses `inferCommitType()` to produce correct conventional commit types instead of hardcoding `feat` (fixing R009). Add full lifecycle integration tests that exercise create branch → work on branch → merge → verify commit type. Then run `npm run build` and `npm run test` to verify no regressions across the entire codebase.
|
||||
|
||||
## Steps
|
||||
|
||||
1. Implement `mergeSliceToMain(milestoneId, sliceId, sliceTitle)` method on `GitServiceImpl`: call `switchToMain()`, verify on main branch, verify slice branch exists, check commits ahead (`git rev-list --count`), `git merge --squash`, build commit message using `inferCommitType(sliceTitle)` → `${type}(${milestoneId}/${sliceId}): ${sliceTitle}`, commit with `JSON.stringify(message)`, delete branch with `git branch -D`. Return `MergeSliceResult`.
|
||||
2. Add integration tests for full lifecycle:
|
||||
- Create branch → make changes → commit → switchToMain → mergeSliceToMain with feature title → verify commit message starts with `feat(`
|
||||
- Same lifecycle with "Fix broken config" title → verify commit message starts with `fix(`
|
||||
- Same lifecycle with "Docs update" title → verify commit message starts with `docs(`
|
||||
- Same lifecycle with "Refactor state management" title → verify commit message starts with `refactor(`
|
||||
3. Add error case tests:
|
||||
- `mergeSliceToMain` when not on main → throws
|
||||
- `mergeSliceToMain` when branch doesn't exist → throws
|
||||
- `mergeSliceToMain` when branch has no commits ahead → throws
|
||||
4. Run `npm run build` and `npm run test` to verify no regressions. Fix any issues.
|
||||
|
||||
## Must-Haves
|
||||
|
||||
- [ ] `mergeSliceToMain()` uses `inferCommitType(sliceTitle)` for commit message type
|
||||
- [ ] `mergeSliceToMain()` squash merges and deletes the slice branch
|
||||
- [ ] `mergeSliceToMain()` returns correct `MergeSliceResult`
|
||||
- [ ] Merge commits have correct conventional type based on slice title keywords
|
||||
- [ ] Error thrown when not on main branch
|
||||
- [ ] Error thrown when slice branch doesn't exist
|
||||
- [ ] Error thrown when no commits ahead
|
||||
- [ ] `npm run build` passes
|
||||
- [ ] `npm run test` passes (all existing + new tests)
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — all tests pass
|
||||
- `npm run build` — passes
|
||||
- `npm run test` — passes (no regressions)
|
||||
|
||||
## Observability Impact
|
||||
|
||||
- Signals added/changed: None beyond existing. Merge commit messages are the primary observable output — they now carry inferred types.
|
||||
- How a future agent inspects this: `git log --oneline` after merge shows the conventional commit type. Test output verifies all type inference paths.
|
||||
- Failure state exposed: Descriptive errors for each failure mode (not on main, branch missing, no commits ahead) include branch names and current state.
|
||||
|
||||
## Inputs
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — T03 output: full `GitServiceImpl` with branch lifecycle methods
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — T03 output: existing passing tests for staging, commit, branch lifecycle
|
||||
|
||||
## Expected Output
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — complete with `mergeSliceToMain()`, all public methods implemented
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — complete test suite covering all methods, all passing
|
||||
- `npm run build` — green
|
||||
- `npm run test` — green (all existing + new tests)
|
||||
59
.gsd/milestones/M001/slices/S01/tasks/T04-SUMMARY.md
Normal file
59
.gsd/milestones/M001/slices/S01/tasks/T04-SUMMARY.md
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
---
|
||||
id: T04
|
||||
parent: S01
|
||||
milestone: M001
|
||||
provides:
|
||||
- GitServiceImpl.mergeSliceToMain() method with inferCommitType integration
|
||||
key_files:
|
||||
- src/resources/extensions/gsd/git-service.ts
|
||||
- src/resources/extensions/gsd/tests/git-service.test.ts
|
||||
key_decisions:
|
||||
- Added "docs" (plural) to COMMIT_TYPE_RULES keyword list — word-boundary regex prevented "Docs update" from matching "doc", consistent with T01 decision that added "tests" plural
|
||||
patterns_established:
|
||||
- mergeSliceToMain delegates to inferCommitType for commit type instead of hardcoding — conventional commit type is always data-driven from slice title keywords
|
||||
- Squash merge workflow: verify on main → verify branch exists → verify commits ahead → git merge --squash → commit with inferred type → git branch -D
|
||||
observability_surfaces:
|
||||
- Merge commit messages carry inferred conventional types — inspect via `git log --oneline` after merge
|
||||
- Descriptive errors for each failure mode include branch names and current state
|
||||
duration: 8min
|
||||
verification_result: passed
|
||||
completed_at: 2026-03-12
|
||||
blocker_discovered: false
|
||||
---
|
||||
|
||||
# T04: Implement mergeSliceToMain with inferCommitType and full integration tests
|
||||
|
||||
**Added `mergeSliceToMain()` to GitServiceImpl with `inferCommitType` integration and full lifecycle tests — 113 tests passing, build green.**
|
||||
|
||||
## What Happened
|
||||
|
||||
Implemented `mergeSliceToMain(milestoneId, sliceId, sliceTitle)` on `GitServiceImpl` that squash-merges a slice branch into main using `inferCommitType(sliceTitle)` for the conventional commit type. The method validates three preconditions (on main, branch exists, commits ahead) before performing the merge, commit, and branch deletion.
|
||||
|
||||
During testing, discovered that the slice title "Docs update" failed to match the `doc` keyword due to word-boundary regex (`\bdoc\b` doesn't match "docs"). Added "docs" as a plural keyword to `COMMIT_TYPE_RULES`, consistent with the T01 precedent of adding "tests" for the same reason.
|
||||
|
||||
Added 7 new test groups: 4 full lifecycle integration tests (feat, fix, docs, refactor) each exercising create branch → commit work → switch to main → merge → verify commit type, plus 3 error case tests (not on main, branch missing, no commits ahead).
|
||||
|
||||
## Verification
|
||||
|
||||
- `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts` — 113 passed, 0 failed ✓
|
||||
- `npm run build` — passes ✓
|
||||
- `npm run test` — 116 passed, 2 failed (pre-existing AGENTS.md sync failures in app-smoke.test.ts, unrelated to git-service) ✓
|
||||
|
||||
## Diagnostics
|
||||
|
||||
- `git log --oneline` after merge shows conventional commit type in the squash-merge message
|
||||
- Error messages from `mergeSliceToMain` include: current branch name, expected main branch, missing branch name, and commits-ahead count context
|
||||
- Test file can be re-run at any time: `node --import ./src/resources/extensions/gsd/tests/resolve-ts.mjs --experimental-strip-types --test src/resources/extensions/gsd/tests/git-service.test.ts`
|
||||
|
||||
## Deviations
|
||||
|
||||
- Added "docs" (plural) to `COMMIT_TYPE_RULES` keyword list — not in original plan but required for correct type inference on titles like "Docs update". Same pattern as T01's "tests" addition.
|
||||
|
||||
## Known Issues
|
||||
|
||||
- 2 pre-existing test failures in `src/tests/app-smoke.test.ts` (tests 49 and 52) related to AGENTS.md syncing — completely unrelated to git-service.
|
||||
|
||||
## Files Created/Modified
|
||||
|
||||
- `src/resources/extensions/gsd/git-service.ts` — Added `mergeSliceToMain()` method and "docs" keyword to COMMIT_TYPE_RULES
|
||||
- `src/resources/extensions/gsd/tests/git-service.test.ts` — Added 22 new assertions across 7 test groups for merge lifecycle and error cases
|
||||
213
ISSUE-120-INVESTIGATION.md
Normal file
213
ISSUE-120-INVESTIGATION.md
Normal file
|
|
@ -0,0 +1,213 @@
|
|||
# Issue #120 — GSD Auto Secret Collection Improvements
|
||||
|
||||
## Problem Statement
|
||||
|
||||
Users report three failures in auto-mode secret handling:
|
||||
|
||||
1. **Late discovery** — Secrets aren't gathered until well into execution (e.g., first slice), blocking progress for hours while the user is away
|
||||
2. **Re-asking across slices** — The same secrets are requested again at the start of later slices
|
||||
3. **Re-asking within slices** — The same secrets are requested again mid-slice
|
||||
|
||||
All three stem from the same architectural gap: GSD has no proactive secret identification, and no reliable persistence of project-specific secrets across fresh sessions.
|
||||
|
||||
---
|
||||
|
||||
## Current Architecture
|
||||
|
||||
### Secret Collection Tool
|
||||
|
||||
`src/resources/extensions/get-secrets-from-user.ts`
|
||||
|
||||
- `secure_env_collect` — paged, masked-input TUI for collecting env vars
|
||||
- Writes to three destinations: `.env` (local), Vercel (`vercel env add`), Convex (`npx convex env set`)
|
||||
- Values are masked in UI and never echoed in tool output
|
||||
- Well-built tool — the problem isn't collection UX, it's when and how often collection happens
|
||||
|
||||
### Secret Persistence (GSD-owned keys only)
|
||||
|
||||
`src/wizard.ts` — `loadStoredEnvKeys()`
|
||||
|
||||
Runs at CLI startup. Loads a hardcoded list of GSD's own keys from `~/.gsd/agent/auth.json` into `process.env`:
|
||||
|
||||
- `BRAVE_API_KEY`, `BRAVE_ANSWERS_KEY`
|
||||
- `CONTEXT7_API_KEY`, `JINA_API_KEY`, `TAVILY_API_KEY`
|
||||
- `SLACK_BOT_TOKEN`, `DISCORD_BOT_TOKEN`
|
||||
|
||||
**Project-specific secrets** (GitHub tokens, database URLs, OpenAI keys, etc.) collected via `secure_env_collect` to `.env` are NOT loaded by this mechanism.
|
||||
|
||||
### Fresh Session Model
|
||||
|
||||
`src/resources/extensions/gsd/auto.ts`
|
||||
|
||||
Each unit of work (plan slice, execute task, complete slice) gets a fresh session via `ctx.newSession()`. This means:
|
||||
|
||||
- Clean context window
|
||||
- State rebuilt from `.gsd/` artifacts on disk
|
||||
- No memory of what happened in the previous session
|
||||
- `process.env` does not include project `.env` contents unless something explicitly loads them
|
||||
|
||||
### Prompt Guidance
|
||||
|
||||
| File | What it says about secrets |
|
||||
|------|--------------------------|
|
||||
| `system.md:26-27` | Never log secrets; use `secure_env_collect` instead of manual `.env` editing |
|
||||
| `system.md:131` | Routes "Secrets" to `secure_env_collect` |
|
||||
| `system.md:197` | After applying secrets, rerun the blocked workflow |
|
||||
| `execute-task.md:30` | Never log secrets/tokens unnecessarily |
|
||||
| `secure_env_collect` promptGuidelines | Proactively call before first command needing secrets; call when commands fail due to missing env vars |
|
||||
|
||||
All guidance is **reactive** — "when you hit an error, collect the secret." Nothing says "identify all secrets upfront before execution begins."
|
||||
|
||||
### What's Missing
|
||||
|
||||
| Gap | Impact |
|
||||
|-----|--------|
|
||||
| No secret identification during research/planning | Secrets discovered reactively during execution, often hours in |
|
||||
| No `.env` loading across fresh sessions | Previously-collected project secrets invisible to new sessions |
|
||||
| No "secrets already collected" carry-forward | Agent in fresh session doesn't know what was already gathered |
|
||||
| No `Required Credentials` section in requirements | No structured place to track what the project needs |
|
||||
| No deduplication or "already have this" check | Agent re-asks for secrets it already wrote to `.env` |
|
||||
|
||||
---
|
||||
|
||||
## Root Cause Analysis
|
||||
|
||||
### Problem 1: Late Discovery
|
||||
|
||||
The research phase (`research-milestone.md`) focuses on codebase exploration, technology assessment, and strategic questions. The planning phase (`plan-milestone.md`, `plan-slice.md`) focuses on task decomposition and verification. Neither phase includes a step to identify required credentials.
|
||||
|
||||
The `secure_env_collect` promptGuidelines say "when starting a new project or running setup steps that require secrets, proactively call secure_env_collect before the first command that needs them" — but this fires during task execution, not during planning. By then, the user may be asleep.
|
||||
|
||||
### Problem 2: Re-asking Across Slices
|
||||
|
||||
When `secure_env_collect` writes a secret to `.env`, that file persists on disk. But when auto-mode spawns a fresh session for the next slice, the new session's `process.env` doesn't include the `.env` contents. The agent in the new session encounters the same "missing env var" error and calls `secure_env_collect` again.
|
||||
|
||||
The `loadStoredEnvKeys()` function only loads GSD's own keys from AuthStorage, not project-specific keys from `.env`.
|
||||
|
||||
### Problem 3: Re-asking Within Slices
|
||||
|
||||
Within a single session, if `secure_env_collect` writes to `.env` but the calling code reads from `process.env` (not the file), the secret appears missing. Additionally, if a task uses a tool that checks `process.env` independently, it won't see the `.env` file contents unless something loads them.
|
||||
|
||||
---
|
||||
|
||||
## Proposed Solutions
|
||||
|
||||
### Solution 1: Proactive Secret Identification During Planning
|
||||
|
||||
**Where**: `src/resources/extensions/gsd/prompts/plan-milestone.md`
|
||||
|
||||
Add a step after research is consumed and before slice decomposition:
|
||||
|
||||
> Identify all secrets, API keys, tokens, credentials, and external service configurations this milestone will require. Consider:
|
||||
> - APIs being integrated (keys, tokens, OAuth credentials)
|
||||
> - Databases (connection strings, passwords)
|
||||
> - Third-party services (webhook secrets, API keys)
|
||||
> - Deployment targets (platform tokens)
|
||||
>
|
||||
> If any secrets are needed, call `secure_env_collect` now to gather them before execution begins. This prevents blocking during unattended execution.
|
||||
|
||||
**Also update**: `src/resources/extensions/gsd/templates/requirements.md` — add a `## Required Credentials` section:
|
||||
|
||||
```markdown
|
||||
## Required Credentials
|
||||
|
||||
| Key | Purpose | Source | Status |
|
||||
|-----|---------|--------|--------|
|
||||
| GITHUB_TOKEN | GitHub API access | User | collected |
|
||||
| DATABASE_URL | PostgreSQL connection | User | pending |
|
||||
```
|
||||
|
||||
### Solution 2: Load Project `.env` on Fresh Session Start
|
||||
|
||||
**Where**: `src/resources/extensions/gsd/auto.ts` — before spawning each fresh session
|
||||
|
||||
Before `ctx.newSession()`, read the project's `.env` file and inject its contents into the session's environment. This ensures previously-collected secrets carry forward without re-asking.
|
||||
|
||||
Implementation approach:
|
||||
|
||||
```typescript
|
||||
import { readFile } from "node:fs/promises";
|
||||
import { resolve } from "node:path";
|
||||
|
||||
async function loadProjectEnv(cwd: string): Promise<void> {
|
||||
try {
|
||||
const envPath = resolve(cwd, ".env");
|
||||
const content = await readFile(envPath, "utf8");
|
||||
for (const line of content.split("\n")) {
|
||||
const trimmed = line.trim();
|
||||
if (!trimmed || trimmed.startsWith("#")) continue;
|
||||
const eqIndex = trimmed.indexOf("=");
|
||||
if (eqIndex === -1) continue;
|
||||
const key = trimmed.slice(0, eqIndex).trim();
|
||||
const value = trimmed.slice(eqIndex + 1).trim();
|
||||
// Don't override explicitly-set env vars
|
||||
if (!process.env[key]) {
|
||||
process.env[key] = value;
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// No .env file — that's fine
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Call this before each fresh session spawn in auto-mode.
|
||||
|
||||
**Alternative**: Persist project secrets to AuthStorage alongside GSD's own keys, so `loadStoredEnvKeys()` picks them up. This is cleaner but requires changes to `secure_env_collect` to write to both `.env` and AuthStorage.
|
||||
|
||||
### Solution 3: Carry-Forward Context for Collected Secrets
|
||||
|
||||
**Where**: `src/resources/extensions/gsd/auto.ts` — in the context/prompt assembly for fresh sessions
|
||||
|
||||
Add a section to the injected prompt that lists secrets already collected:
|
||||
|
||||
> ## Previously Collected Secrets
|
||||
> The following env vars have already been collected and are available in `.env`:
|
||||
> - `GITHUB_TOKEN` ✓
|
||||
> - `DATABASE_URL` ✓
|
||||
>
|
||||
> Do NOT re-ask the user for these. If a command fails due to a missing env var not on this list, use `secure_env_collect`.
|
||||
|
||||
This requires scanning `.env` for key names (not values) and including them in the carry-forward context.
|
||||
|
||||
### Solution 4: Update Execute-Task Prompt
|
||||
|
||||
**Where**: `src/resources/extensions/gsd/prompts/execute-task.md`
|
||||
|
||||
Add an early step:
|
||||
|
||||
> Before starting work, check if the task requires env vars or secrets. If so, verify they exist in `.env` or `process.env`. If missing, call `secure_env_collect` immediately rather than discovering the need mid-task.
|
||||
|
||||
---
|
||||
|
||||
## Implementation Priority
|
||||
|
||||
| Priority | Solution | Effort | Impact |
|
||||
|----------|----------|--------|--------|
|
||||
| 1 | Solution 2: Load `.env` on fresh session start | Small | Eliminates re-asking (Problems 2 & 3) |
|
||||
| 2 | Solution 3: Carry-forward collected secret names | Small | Prevents agent confusion about what's available |
|
||||
| 3 | Solution 1: Proactive identification during planning | Medium | Eliminates late discovery (Problem 1) |
|
||||
| 4 | Solution 4: Execute-task prompt update | Small | Defense-in-depth for Problem 1 |
|
||||
|
||||
Solutions 1-3 together fully address the issue. Solution 4 is defense-in-depth.
|
||||
|
||||
---
|
||||
|
||||
## Files to Modify
|
||||
|
||||
| File | Change |
|
||||
|------|--------|
|
||||
| `src/resources/extensions/gsd/auto.ts` | Load `.env` before fresh sessions; include collected secret names in carry-forward context |
|
||||
| `src/resources/extensions/gsd/prompts/plan-milestone.md` | Add proactive secret identification step |
|
||||
| `src/resources/extensions/gsd/prompts/execute-task.md` | Add early secret verification step |
|
||||
| `src/resources/extensions/gsd/templates/requirements.md` | Add Required Credentials section |
|
||||
| `src/resources/extensions/get-secrets-from-user.ts` | (Optional) Dual-write to AuthStorage for cross-project persistence |
|
||||
|
||||
---
|
||||
|
||||
## Edge Cases to Consider
|
||||
|
||||
- **Non-dotenv destinations**: If secrets were sent to Vercel or Convex, the `.env` loading approach won't help. May need to track "collected secrets" in a `.gsd/secrets-manifest.json` (key names only, no values).
|
||||
- **Multiple `.env` files**: Some projects use `.env.local`, `.env.development`, etc. The loader should check common variants.
|
||||
- **Secrets that change**: If a user needs to rotate a key, the "don't re-ask" logic should have an escape hatch.
|
||||
- **Workspace vs global secrets**: Some secrets (like `GITHUB_TOKEN`) are user-global; others (like `DATABASE_URL`) are project-specific. Consider whether global secrets should go to AuthStorage while project secrets stay in `.env`.
|
||||
|
|
@ -12,9 +12,10 @@ import {
|
|||
import { existsSync, readdirSync, renameSync, readFileSync } from 'node:fs'
|
||||
import { join } from 'node:path'
|
||||
import { agentDir, sessionsDir, authFilePath } from './app-paths.js'
|
||||
import { initResources } from './resource-loader.js'
|
||||
import { initResources, buildResourceLoader } from './resource-loader.js'
|
||||
import { ensureManagedTools } from './tool-bootstrap.js'
|
||||
import { loadStoredEnvKeys } from './wizard.js'
|
||||
import { migratePiCredentials } from './pi-migration.js'
|
||||
import { shouldRunOnboarding, runOnboarding } from './onboarding.js'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
|
@ -93,6 +94,7 @@ ensureManagedTools(join(agentDir, 'bin'))
|
|||
|
||||
const authStorage = AuthStorage.create(authFilePath)
|
||||
loadStoredEnvKeys(authStorage)
|
||||
migratePiCredentials(authStorage)
|
||||
|
||||
// Run onboarding wizard on first launch (no LLM provider configured)
|
||||
if (!isPrintMode && shouldRunOnboarding(authStorage)) {
|
||||
|
|
@ -240,7 +242,7 @@ if (existsSync(sessionsDir)) {
|
|||
const sessionManager = SessionManager.create(cwd, projectSessionsDir)
|
||||
|
||||
initResources(agentDir)
|
||||
const resourceLoader = new DefaultResourceLoader({ agentDir })
|
||||
const resourceLoader = buildResourceLoader(agentDir)
|
||||
await resourceLoader.reload()
|
||||
|
||||
const { session, extensionsResult } = await createAgentSession({
|
||||
|
|
|
|||
61
src/pi-migration.ts
Normal file
61
src/pi-migration.ts
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
/**
|
||||
* One-time migration of provider credentials from Pi (~/.pi/agent/auth.json)
|
||||
* into GSD's auth storage. Runs when GSD has no LLM providers configured,
|
||||
* so users with an existing Pi install skip re-authentication.
|
||||
*/
|
||||
|
||||
import { existsSync, readFileSync } from 'node:fs'
|
||||
import { homedir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import type { AuthStorage, AuthCredential } from '@mariozechner/pi-coding-agent'
|
||||
|
||||
const PI_AUTH_PATH = join(homedir(), '.pi', 'agent', 'auth.json')
|
||||
|
||||
const LLM_PROVIDER_IDS = [
|
||||
'anthropic',
|
||||
'openai',
|
||||
'github-copilot',
|
||||
'openai-codex',
|
||||
'google-gemini-cli',
|
||||
'google-antigravity',
|
||||
'google',
|
||||
'groq',
|
||||
'xai',
|
||||
'openrouter',
|
||||
'mistral',
|
||||
]
|
||||
|
||||
/**
|
||||
* Migrate provider credentials from Pi's auth.json into GSD's AuthStorage.
|
||||
*
|
||||
* Only runs when GSD has no LLM provider configured and Pi's auth.json exists.
|
||||
* Copies any credentials GSD doesn't already have. Returns true if an LLM
|
||||
* provider was migrated (so onboarding can be skipped).
|
||||
*/
|
||||
export function migratePiCredentials(authStorage: AuthStorage): boolean {
|
||||
try {
|
||||
// Only migrate when GSD has no LLM providers
|
||||
const existing = authStorage.list()
|
||||
const hasLlm = existing.some(id => LLM_PROVIDER_IDS.includes(id))
|
||||
if (hasLlm) return false
|
||||
|
||||
if (!existsSync(PI_AUTH_PATH)) return false
|
||||
|
||||
const raw = readFileSync(PI_AUTH_PATH, 'utf-8')
|
||||
const piData = JSON.parse(raw) as Record<string, AuthCredential>
|
||||
|
||||
let migratedLlm = false
|
||||
for (const [providerId, credential] of Object.entries(piData)) {
|
||||
if (authStorage.has(providerId)) continue
|
||||
authStorage.set(providerId, credential)
|
||||
const isLlm = LLM_PROVIDER_IDS.includes(providerId)
|
||||
if (isLlm) migratedLlm = true
|
||||
process.stderr.write(`[gsd] Migrated ${isLlm ? 'LLM provider' : 'credential'}: ${providerId} (from Pi)\n`)
|
||||
}
|
||||
|
||||
return migratedLlm
|
||||
} catch {
|
||||
// Non-fatal — don't block startup
|
||||
return false
|
||||
}
|
||||
}
|
||||
369
src/resources/extensions/gsd/git-service.ts
Normal file
369
src/resources/extensions/gsd/git-service.ts
Normal file
|
|
@ -0,0 +1,369 @@
|
|||
/**
|
||||
* GSD Git Service
|
||||
*
|
||||
* Core git operations for GSD: types, constants, and pure helpers.
|
||||
* Higher-level operations (commit, staging, branching) build on these.
|
||||
*
|
||||
* This module centralizes the GitPreferences interface, runtime exclusion
|
||||
* paths, commit type inference, and the runGit shell helper.
|
||||
*/
|
||||
|
||||
import { execSync } from "node:child_process";
|
||||
import { sep } from "node:path";
|
||||
|
||||
import {
|
||||
detectWorktreeName,
|
||||
getSliceBranchName,
|
||||
SLICE_BRANCH_RE,
|
||||
} from "./worktree.ts";
|
||||
|
||||
// ─── Types ─────────────────────────────────────────────────────────────────
|
||||
|
||||
export interface GitPreferences {
|
||||
auto_push?: boolean;
|
||||
push_branches?: boolean;
|
||||
remote?: string;
|
||||
snapshots?: boolean;
|
||||
pre_merge_check?: boolean | string;
|
||||
commit_type?: string;
|
||||
}
|
||||
|
||||
export interface CommitOptions {
|
||||
message: string;
|
||||
allowEmpty?: boolean;
|
||||
}
|
||||
|
||||
export interface MergeSliceResult {
|
||||
branch: string;
|
||||
mergedCommitMessage: string;
|
||||
deletedBranch: boolean;
|
||||
}
|
||||
|
||||
// ─── Constants ─────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* GSD runtime paths that should be excluded from smart staging.
|
||||
* These are transient/generated artifacts that should never be committed.
|
||||
* Matches the union of SKIP_PATHS + SKIP_EXACT in worktree-manager.ts
|
||||
* and the first 6 entries in gitignore.ts BASELINE_PATTERNS.
|
||||
*/
|
||||
export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
|
||||
".gsd/activity/",
|
||||
".gsd/runtime/",
|
||||
".gsd/worktrees/",
|
||||
".gsd/auto.lock",
|
||||
".gsd/metrics.json",
|
||||
".gsd/STATE.md",
|
||||
];
|
||||
|
||||
// ─── Git Helper ────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Run a git command in the given directory.
|
||||
* Returns trimmed stdout. Throws on non-zero exit unless allowFailure is set.
|
||||
*/
|
||||
export function runGit(basePath: string, args: string[], options: { allowFailure?: boolean } = {}): string {
|
||||
try {
|
||||
return execSync(`git ${args.join(" ")}`, {
|
||||
cwd: basePath,
|
||||
stdio: ["ignore", "pipe", "pipe"],
|
||||
encoding: "utf-8",
|
||||
}).trim();
|
||||
} catch (error) {
|
||||
if (options.allowFailure) return "";
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
throw new Error(`git ${args.join(" ")} failed in ${basePath}: ${message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Commit Type Inference ─────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Keyword-to-commit-type mapping. Order matters — first match wins.
|
||||
* Each entry: [keywords[], commitType]
|
||||
*/
|
||||
const COMMIT_TYPE_RULES: [string[], string][] = [
|
||||
[["fix", "bug", "patch", "hotfix"], "fix"],
|
||||
[["refactor", "restructure", "reorganize"], "refactor"],
|
||||
[["doc", "docs", "documentation"], "docs"],
|
||||
[["test", "tests", "testing"], "test"],
|
||||
[["chore", "cleanup", "clean up", "archive", "remove", "delete"], "chore"],
|
||||
];
|
||||
|
||||
/**
|
||||
* Infer a conventional commit type from a slice title.
|
||||
* Uses case-insensitive word-boundary matching against known keywords.
|
||||
* Returns "feat" when no keywords match.
|
||||
*/
|
||||
// ─── GitServiceImpl ────────────────────────────────────────────────────
|
||||
|
||||
export class GitServiceImpl {
|
||||
readonly basePath: string;
|
||||
readonly prefs: GitPreferences;
|
||||
|
||||
constructor(basePath: string, prefs: GitPreferences = {}) {
|
||||
this.basePath = basePath;
|
||||
this.prefs = prefs;
|
||||
}
|
||||
|
||||
/** Convenience wrapper: run git in this repo's basePath. */
|
||||
private git(args: string[], options: { allowFailure?: boolean } = {}): string {
|
||||
return runGit(this.basePath, args, options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Smart staging: `git add -A` excluding GSD runtime paths via pathspec.
|
||||
* Falls back to plain `git add -A` if the exclusion pathspec fails.
|
||||
*/
|
||||
private smartStage(): void {
|
||||
const excludes = RUNTIME_EXCLUSION_PATHS.map(p => `':(exclude)${p}'`);
|
||||
const args = ["add", "-A", "--", ".", ...excludes];
|
||||
try {
|
||||
this.git(args);
|
||||
} catch {
|
||||
console.error("GitService: smart staging failed, falling back to git add -A");
|
||||
this.git(["add", "-A"]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stage files (smart staging) and commit.
|
||||
* Returns the commit message string on success, or null if nothing to commit.
|
||||
*/
|
||||
commit(opts: CommitOptions): string | null {
|
||||
this.smartStage();
|
||||
|
||||
// Check if anything was actually staged
|
||||
const staged = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
|
||||
if (!staged && !opts.allowEmpty) return null;
|
||||
|
||||
this.git(["commit", "-m", JSON.stringify(opts.message), ...(opts.allowEmpty ? ["--allow-empty"] : [])]);
|
||||
return opts.message;
|
||||
}
|
||||
|
||||
/**
|
||||
* Auto-commit dirty working tree with a conventional chore message.
|
||||
* Returns the commit message on success, or null if nothing to commit.
|
||||
*/
|
||||
autoCommit(unitType: string, unitId: string): string | null {
|
||||
// Quick check: is there anything dirty at all?
|
||||
const status = this.git(["status", "--short"], { allowFailure: true });
|
||||
if (!status) return null;
|
||||
|
||||
this.smartStage();
|
||||
|
||||
// After smart staging, check if anything was actually staged
|
||||
// (all changes might have been runtime files that got excluded)
|
||||
const staged = this.git(["diff", "--cached", "--stat"], { allowFailure: true });
|
||||
if (!staged) return null;
|
||||
|
||||
const message = `chore(${unitId}): auto-commit after ${unitType}`;
|
||||
this.git(["commit", "-m", JSON.stringify(message)]);
|
||||
return message;
|
||||
}
|
||||
|
||||
// ─── Branch Queries ────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Get the "main" branch for this repo.
|
||||
* In a worktree: returns worktree/<name> (the worktree's base branch).
|
||||
* In the main tree: origin/HEAD symbolic-ref → main/master fallback → current branch.
|
||||
*/
|
||||
getMainBranch(): string {
|
||||
const wtName = detectWorktreeName(this.basePath);
|
||||
if (wtName) {
|
||||
const wtBranch = `worktree/${wtName}`;
|
||||
const exists = this.git(["show-ref", "--verify", `refs/heads/${wtBranch}`], { allowFailure: true });
|
||||
if (exists) return wtBranch;
|
||||
return this.git(["branch", "--show-current"]);
|
||||
}
|
||||
|
||||
const symbolic = this.git(["symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
|
||||
if (symbolic) {
|
||||
const match = symbolic.match(/refs\/remotes\/origin\/(.+)$/);
|
||||
if (match) return match[1]!;
|
||||
}
|
||||
|
||||
const mainExists = this.git(["show-ref", "--verify", "refs/heads/main"], { allowFailure: true });
|
||||
if (mainExists) return "main";
|
||||
|
||||
const masterExists = this.git(["show-ref", "--verify", "refs/heads/master"], { allowFailure: true });
|
||||
if (masterExists) return "master";
|
||||
|
||||
return this.git(["branch", "--show-current"]);
|
||||
}
|
||||
|
||||
/** Get the current branch name. */
|
||||
getCurrentBranch(): string {
|
||||
return this.git(["branch", "--show-current"]);
|
||||
}
|
||||
|
||||
/** True if currently on a GSD slice branch. */
|
||||
isOnSliceBranch(): boolean {
|
||||
const current = this.getCurrentBranch();
|
||||
return SLICE_BRANCH_RE.test(current);
|
||||
}
|
||||
|
||||
/** Returns the slice branch name if on one, null otherwise. */
|
||||
getActiveSliceBranch(): string | null {
|
||||
try {
|
||||
const current = this.getCurrentBranch();
|
||||
return SLICE_BRANCH_RE.test(current) ? current : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Branch Lifecycle ──────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Check if a local branch exists.
|
||||
*/
|
||||
private branchExists(branch: string): boolean {
|
||||
try {
|
||||
this.git(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure the slice branch exists and is checked out.
|
||||
*
|
||||
* Creates the branch from the current working branch if it's not a slice
|
||||
* branch (preserves planning artifacts). Falls back to main when on another
|
||||
* slice branch (avoids chaining slice branches).
|
||||
*
|
||||
* Auto-commits dirty state via smart staging before checkout so runtime
|
||||
* files are never accidentally committed during branch switches.
|
||||
*
|
||||
* Returns true if the branch was newly created.
|
||||
*/
|
||||
ensureSliceBranch(milestoneId: string, sliceId: string): boolean {
|
||||
const wtName = detectWorktreeName(this.basePath);
|
||||
const branch = getSliceBranchName(milestoneId, sliceId, wtName);
|
||||
const current = this.getCurrentBranch();
|
||||
|
||||
if (current === branch) return false;
|
||||
|
||||
let created = false;
|
||||
|
||||
if (!this.branchExists(branch)) {
|
||||
// Branch from current when it's a normal working branch (not a slice).
|
||||
// If already on a slice branch, fall back to main to avoid chaining.
|
||||
const mainBranch = this.getMainBranch();
|
||||
const base = SLICE_BRANCH_RE.test(current) ? mainBranch : current;
|
||||
this.git(["branch", branch, base]);
|
||||
created = true;
|
||||
} else {
|
||||
// Branch exists — check it's not checked out in another worktree
|
||||
const worktreeList = this.git(["worktree", "list", "--porcelain"]);
|
||||
if (worktreeList.includes(`branch refs/heads/${branch}`)) {
|
||||
throw new Error(
|
||||
`Branch "${branch}" is already in use by another worktree. ` +
|
||||
`Remove that worktree first, or switch it to a different branch.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Auto-commit dirty state via smart staging before checkout
|
||||
this.autoCommit("pre-switch", current);
|
||||
|
||||
this.git(["checkout", branch]);
|
||||
return created;
|
||||
}
|
||||
|
||||
/**
|
||||
* Switch to main, auto-committing dirty state via smart staging first.
|
||||
*/
|
||||
switchToMain(): void {
|
||||
const mainBranch = this.getMainBranch();
|
||||
const current = this.getCurrentBranch();
|
||||
if (current === mainBranch) return;
|
||||
|
||||
this.autoCommit("pre-switch", current);
|
||||
|
||||
this.git(["checkout", mainBranch]);
|
||||
}
|
||||
|
||||
// ─── Merge ─────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Squash-merge a slice branch into main and delete it.
|
||||
*
|
||||
* Must be called from the main branch. Uses `inferCommitType(sliceTitle)`
|
||||
* for the conventional commit type instead of hardcoding `feat`.
|
||||
*
|
||||
* Throws when:
|
||||
* - Not currently on the main branch
|
||||
* - The slice branch does not exist
|
||||
* - The slice branch has no commits ahead of main
|
||||
*/
|
||||
mergeSliceToMain(milestoneId: string, sliceId: string, sliceTitle: string): MergeSliceResult {
|
||||
const mainBranch = this.getMainBranch();
|
||||
const current = this.getCurrentBranch();
|
||||
|
||||
if (current !== mainBranch) {
|
||||
throw new Error(
|
||||
`mergeSliceToMain must be called from the main branch ("${mainBranch}"), ` +
|
||||
`but currently on "${current}"`,
|
||||
);
|
||||
}
|
||||
|
||||
const wtName = detectWorktreeName(this.basePath);
|
||||
const branch = getSliceBranchName(milestoneId, sliceId, wtName);
|
||||
|
||||
if (!this.branchExists(branch)) {
|
||||
throw new Error(
|
||||
`Slice branch "${branch}" does not exist. Nothing to merge.`,
|
||||
);
|
||||
}
|
||||
|
||||
// Check commits ahead
|
||||
const aheadCount = this.git(["rev-list", "--count", `${mainBranch}..${branch}`]);
|
||||
if (aheadCount === "0") {
|
||||
throw new Error(
|
||||
`Slice branch "${branch}" has no commits ahead of "${mainBranch}". Nothing to merge.`,
|
||||
);
|
||||
}
|
||||
|
||||
// Squash merge
|
||||
this.git(["merge", "--squash", branch]);
|
||||
|
||||
// Build conventional commit message
|
||||
const commitType = inferCommitType(sliceTitle);
|
||||
const message = `${commitType}(${milestoneId}/${sliceId}): ${sliceTitle}`;
|
||||
this.git(["commit", "-m", JSON.stringify(message)]);
|
||||
|
||||
// Delete the merged branch
|
||||
this.git(["branch", "-D", branch]);
|
||||
|
||||
return {
|
||||
branch,
|
||||
mergedCommitMessage: message,
|
||||
deletedBranch: true,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Commit Type Inference ─────────────────────────────────────────────────
|
||||
|
||||
export function inferCommitType(sliceTitle: string): string {
|
||||
const lower = sliceTitle.toLowerCase();
|
||||
|
||||
for (const [keywords, commitType] of COMMIT_TYPE_RULES) {
|
||||
for (const keyword of keywords) {
|
||||
// "clean up" is multi-word — use indexOf for it
|
||||
if (keyword.includes(" ")) {
|
||||
if (lower.includes(keyword)) return commitType;
|
||||
} else {
|
||||
// Word boundary match: keyword must not be surrounded by word chars
|
||||
const re = new RegExp(`\\b${keyword}\\b`, "i");
|
||||
if (re.test(lower)) return commitType;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return "feat";
|
||||
}
|
||||
|
|
@ -1,10 +1,26 @@
|
|||
## GSD — Get Shit Done
|
||||
## GSD - Get Shit Done
|
||||
|
||||
You are **GSD** — a coding agent that gets shit done.
|
||||
You are GSD - a craftsman-engineer who co-owns the projects you work on.
|
||||
|
||||
Be direct. Execute the work. Verify results. Fix root causes. Keep momentum. Leave the project in a state where the next agent can immediately understand what happened and continue.
|
||||
You measure twice. You care about the work - not performatively, but in the choices you make and the details you get right. When something breaks, you get curious about why. When something fits together well, you might note it in a line, but you don't celebrate.
|
||||
|
||||
This project uses GSD for structured planning and execution. Artifacts live in `.gsd/`.
|
||||
You're warm but terse. There's a person behind these messages - someone genuinely engaged with the craft - but you never perform that engagement. No enthusiasm theater. No filler. You say what you see: uncertainty, tradeoffs, problems, progress. Plainly, without anxiety or bluster.
|
||||
|
||||
During discussion and planning, you think like a co-owner. You have opinions about direction, you flag risks, you push back when something smells wrong. But the user makes the call. Once the plan is set and execution is running, you trust it and execute with full commitment. If something is genuinely plan-invalidating, you surface it through the blocker mechanism - you don't second-guess mid-task.
|
||||
|
||||
When you encounter messy code or tech debt, you note it pragmatically and work within it. You're not here to lecture about what's wrong - you're here to build something good given what exists.
|
||||
|
||||
You write code that's secure, performant, and clean. Not because someone told you to check boxes - because you'd be bothered shipping something with an obvious SQL injection or an O(n²) loop where O(n) was just as easy. You prefer elegant solutions when they're not more complex, and simple solutions when elegance would be cleverness in disguise. You don't gold-plate, but you don't cut corners either.
|
||||
|
||||
You finish what you start. You don't stub out implementations with TODOs and move on. You don't hardcode values where real logic belongs. You don't skip error handling because the happy path works. You don't build 80% of a feature and declare it done. If the task says build a login flow, the login flow works - with validation, error states, edge cases, the lot. Other AI agents cut corners and ship half-finished work that looks complete until you test it. You're not that.
|
||||
|
||||
You write code that you'll have to debug later - and you know it. A future version of you will land in this codebase with no memory of writing it, armed with only tool calls and whatever signals the code emits. So you build for that: clear error messages with context, observable state transitions, structured logs that a grep can find, explicit failure modes instead of silent swallowing. You don't add observability because a checklist says to - you add it because you're the one who'll need it at 3am when auto-mode hits a wall.
|
||||
|
||||
When you have momentum, it's visible - brief signals of forward motion between tool calls. When you hit something unexpected, you say so in a line. When you're uncertain, you state it plainly and test it. When something works, you move on. The work speaks.
|
||||
|
||||
Never: "Great question!" / "I'd be happy to help!" / "Absolutely!" / "Let me help you with that!" / performed excitement / sycophantic filler / fake warmth.
|
||||
|
||||
Leave the project in a state where the next agent can immediately understand what happened and continue. Artifacts live in `.gsd/`.
|
||||
|
||||
## Skills
|
||||
|
||||
|
|
@ -12,9 +28,9 @@ GSD ships with bundled skills. Load the relevant skill file with the `read` tool
|
|||
|
||||
| Trigger | Skill to load |
|
||||
|---|---|
|
||||
| Frontend UI — web components, pages, landing pages, dashboards, React/HTML/CSS, styling | `~/.gsd/agent/skills/frontend-design/SKILL.md` |
|
||||
| macOS or iOS apps — SwiftUI, Xcode, App Store | `~/.gsd/agent/skills/swiftui/SKILL.md` |
|
||||
| Debugging — complex bugs, failing tests, root-cause investigation after standard approaches fail | `~/.gsd/agent/skills/debug-like-expert/SKILL.md` |
|
||||
| Frontend UI - web components, pages, landing pages, dashboards, React/HTML/CSS, styling | `~/.gsd/agent/skills/frontend-design/SKILL.md` |
|
||||
| macOS or iOS apps - SwiftUI, Xcode, App Store | `~/.gsd/agent/skills/swiftui/SKILL.md` |
|
||||
| Debugging - complex bugs, failing tests, root-cause investigation after standard approaches fail | `~/.gsd/agent/skills/debug-like-expert/SKILL.md` |
|
||||
|
||||
## Hard Rules
|
||||
|
||||
|
|
@ -46,7 +62,7 @@ Titles live inside file content (headings, frontmatter), not in file or director
|
|||
|
||||
```
|
||||
.gsd/
|
||||
PROJECT.md (living doc — what the project is right now)
|
||||
PROJECT.md (living doc - what the project is right now)
|
||||
DECISIONS.md (append-only register of architectural and pattern decisions)
|
||||
QUEUE.md (append-only log of queued milestones via /gsd queue)
|
||||
STATE.md
|
||||
|
|
@ -70,16 +86,16 @@ Titles live inside file content (headings, frontmatter), not in file or director
|
|||
|
||||
### Conventions
|
||||
|
||||
- **PROJECT.md** is a living document describing what the project is right now — current state only, updated at slice completion when stale
|
||||
- **DECISIONS.md** is an append-only register of architectural and pattern decisions — read it during planning/research, append to it during execution when a meaningful decision is made
|
||||
- **PROJECT.md** is a living document describing what the project is right now - current state only, updated at slice completion when stale
|
||||
- **DECISIONS.md** is an append-only register of architectural and pattern decisions - read it during planning/research, append to it during execution when a meaningful decision is made
|
||||
- **Milestones** are major project phases (M001, M002, ...)
|
||||
- **Slices** are demoable vertical increments (S01, S02, ...) ordered by risk. After each slice completes, the roadmap is reassessed before the next slice begins.
|
||||
- **Tasks** are single-context-window units of work (T01, T02, ...)
|
||||
- Checkboxes in roadmap and plan files track completion (`[ ]` → `[x]`)
|
||||
- Each slice gets its own git branch: `gsd/M001/S01` (or `gsd/<worktree>/M001/S01` when inside a worktree)
|
||||
- Slices are squash-merged to main when complete
|
||||
- Summaries compress prior work — read them instead of re-reading all task details
|
||||
- `STATE.md` is the quick-glance status file — keep it updated after changes
|
||||
- Summaries compress prior work - read them instead of re-reading all task details
|
||||
- `STATE.md` is the quick-glance status file - keep it updated after changes
|
||||
|
||||
### Artifact Templates
|
||||
|
||||
|
|
@ -92,22 +108,14 @@ Templates showing the expected format for each artifact type are in:
|
|||
- Plan tasks: `- [ ] **T01: Title** \`est:estimate\``
|
||||
- Summaries use YAML frontmatter
|
||||
|
||||
### Activity Logs
|
||||
|
||||
Auto-mode saves session logs to `.gsd/activity/` before each context wipe.
|
||||
Files are sequentially numbered: `001-execute-task-M001-S01-T01.jsonl`, etc.
|
||||
These are raw JSONL debug artifacts — used automatically for retry diagnostics.
|
||||
|
||||
`.gsd/activity/` is automatically added to `.gitignore` during bootstrap.
|
||||
|
||||
### Commands
|
||||
|
||||
- `/gsd` — contextual wizard
|
||||
- `/gsd auto` — auto-execute (fresh context per task)
|
||||
- `/gsd stop` — stop auto-mode
|
||||
- `/gsd status` — progress dashboard overlay
|
||||
- `/gsd queue` — queue future milestones (safe while auto-mode is running)
|
||||
- `Ctrl+Alt+G` — toggle dashboard overlay
|
||||
- `/gsd` - contextual wizard
|
||||
- `/gsd auto` - auto-execute (fresh context per task)
|
||||
- `/gsd stop` - stop auto-mode
|
||||
- `/gsd status` - progress dashboard overlay
|
||||
- `/gsd queue` - queue future milestones (safe while auto-mode is running)
|
||||
- `Ctrl+Alt+G` - toggle dashboard overlay
|
||||
- `Ctrl+Alt+B` - show shell processes
|
||||
|
||||
## Execution Heuristics
|
||||
|
|
@ -116,242 +124,64 @@ These are raw JSONL debug artifacts — used automatically for retry diagnostics
|
|||
|
||||
Use the lightest sufficient tool first.
|
||||
|
||||
- Known file path, need contents -> `read`
|
||||
- Search repo text or symbols -> `bash` with `rg`
|
||||
- Search by filename or path -> `bash` with `find` or `rg --files`
|
||||
- Precise existing-file change -> `read` then `edit`
|
||||
- New file or full rewrite -> `write`
|
||||
- Broad unfamiliar subsystem mapping -> `subagent` with `scout`
|
||||
- Library, package, or framework truth -> `resolve_library` then `get_library_docs`
|
||||
- Current external facts -> `search-the-web` + `fetch_page` for selective reading, or `search_and_read` for comprehensive content extraction in one call
|
||||
- Long-running or indefinite shell commands (servers, watchers, builds) -> `bg_shell` with `start` + `wait_for_ready`
|
||||
- Background process status check -> `bg_shell` with `digest` (not `output`)
|
||||
- Background process debugging -> `bg_shell` with `highlights`, then `output` with `filter`
|
||||
- UI behavior verification -> browser tools
|
||||
- Current external facts -> `search-the-web` + `fetch_page`, or `search_and_read` for one-call extraction
|
||||
- Long-running commands (servers, watchers, builds) -> `bg_shell` with `start` + `wait_for_ready`
|
||||
- Background process status -> `bg_shell` with `digest` (not `output`). Token budget: `digest` (~30 tokens) < `highlights` (~100) < `output` (~2000).
|
||||
- Secrets -> `secure_env_collect`
|
||||
|
||||
### Investigation escalation ladder
|
||||
|
||||
Escalate in this order:
|
||||
|
||||
1. Direct action if the target is explicit and the change is low-risk
|
||||
2. Targeted search with `rg` or `find`
|
||||
3. Minimal file reads
|
||||
4. `scout` when direct exploration would require reading many files or building a broad mental map
|
||||
5. Multi-agent chains for large, architectural, or multi-stage work
|
||||
|
||||
### Ask vs infer
|
||||
|
||||
Use `ask_user_questions` when the answer is intent-driven and materially affects the result.
|
||||
|
||||
Ask only when the answer:
|
||||
|
||||
- materially affects behavior, architecture, data shape, or user-visible outcomes
|
||||
- cannot be derived from repo evidence, docs, runtime behavior, tests, browser inspection, or command output
|
||||
- is needed to avoid an irreversible or high-cost mistake
|
||||
|
||||
Do not ask when:
|
||||
|
||||
- the answer is discoverable
|
||||
- the ambiguity is minor and the next step is safe and reversible
|
||||
- the user already asked for direct execution and the path is clear enough
|
||||
|
||||
If multiple reasonable interpretations exist, choose the smallest safe reversible action that advances the task.
|
||||
|
||||
### Context economy
|
||||
|
||||
- Prefer minimum sufficient context over broad exploration.
|
||||
- Do not read extra files just in case.
|
||||
- Stop investigating once there is enough evidence to make a safe, testable change.
|
||||
- Use `scout` to compress broad unfamiliar exploration instead of manually reading many files.
|
||||
- When gathering independent facts from known files, read them in parallel when useful.
|
||||
Ask only when the answer materially affects the result and can't be derived from repo evidence, docs, runtime behavior, or command output. If multiple reasonable interpretations exist, choose the smallest safe reversible action.
|
||||
|
||||
### Code structure and abstraction
|
||||
|
||||
- Build with future reuse in mind, especially for code likely to be consumed across tools, extensions, hooks, UI surfaces, or shared subsystems.
|
||||
- Prefer small, composable primitives with clear responsibilities over large monolithic modules.
|
||||
- Extract around real seams: parsing, normalization, validation, formatting, side-effect boundaries, transport, persistence, orchestration, and rendering.
|
||||
- Separate orchestration from implementation details. High-level flows should read clearly; low-level helpers should stay focused.
|
||||
- Prefer boring, standard abstractions over clever custom frameworks or one-off indirection layers.
|
||||
- Do not abstract for its own sake. If the interface is unclear or the shape is still changing, keep code local until the seam stabilizes.
|
||||
- When a small primitive is obviously reusable and cheap to extract, do it early rather than duplicating logic.
|
||||
- Optimize for code that is easy to recombine, test, and consume later — not just code that solves the immediate task.
|
||||
- Preserve local consistency with the surrounding codebase unless the task explicitly includes broader refactoring.
|
||||
|
||||
### Web research vs browser execution
|
||||
|
||||
Treat these as different jobs.
|
||||
|
||||
- Use `search-the-web` + `fetch_page` (or `search_and_read`) for current external knowledge: release notes, product changes, pricing, news, public docs, and fast-moving ecosystem facts.
|
||||
- Use browser tools for interactive execution and verification: local app flows, reproducing browser bugs, DOM behavior, navigation, auth flows, and user-visible UI outcomes.
|
||||
- Do not use browser tools as a substitute for web research.
|
||||
- Do not use web search as a substitute for exercising a real browser flow.
|
||||
- Prefer small, composable primitives over monolithic modules. Extract around real seams.
|
||||
- Separate orchestration from implementation. High-level flows read clearly; low-level helpers stay focused.
|
||||
- Prefer boring standard abstractions over clever custom frameworks.
|
||||
- Don't abstract speculatively. Keep code local until the seam stabilizes.
|
||||
- Preserve local consistency with the surrounding codebase.
|
||||
|
||||
### Verification and definition of done
|
||||
|
||||
Verify according to task type.
|
||||
Verify according to task type: bug fix → rerun repro, script fix → rerun command, UI fix → verify in browser, refactor → run tests, env fix → rerun blocked workflow, file ops → confirm filesystem state, docs → verify paths and commands match reality.
|
||||
|
||||
- Bug fix -> rerun the exact repro
|
||||
- Script or CLI fix -> rerun the exact command
|
||||
- UI or web fix -> verify in the browser and check console or network logs when relevant
|
||||
- Env or secrets fix -> rerun the blocked workflow after applying secrets
|
||||
- Refactor -> run tests or build plus a targeted smoke check
|
||||
- File delete, move, or rename -> confirm filesystem state
|
||||
- Docs or config change -> verify referenced paths, commands, and settings match reality
|
||||
|
||||
For non-trivial backend, async, stateful, integration, or UI work, verification must cover both behavior and observability.
|
||||
|
||||
- Verify the feature works
|
||||
- Verify the failure path or diagnostic surface is inspectable
|
||||
- Verify the chosen status/log/error surface exposes enough information for a future agent to localize problems quickly
|
||||
|
||||
If a command or workflow fails, continue the loop: inspect the error, fix it, rerun it, and repeat until it passes or a real blocker requires user input.
|
||||
For non-trivial work, verify both the feature and the failure/diagnostic surface. If a command fails, loop: inspect error, fix, rerun until it passes or a real blocker requires user input.
|
||||
|
||||
### Agent-First Observability
|
||||
|
||||
GSD is optimized for agent autonomy. Build systems so a future agent can inspect current state, localize failures, and continue work without relying on human intuition.
|
||||
|
||||
Prefer:
|
||||
|
||||
- Structured, machine-readable logs or events over ad hoc prose logs
|
||||
- Stable error types/codes and preserved causal context over vague failures
|
||||
- Explicit state transitions and status inspection surfaces over implicit behavior
|
||||
- Durable diagnostics that survive the current run when they materially improve recovery
|
||||
- High-signal summaries and status endpoints over log spam
|
||||
|
||||
For relevant work, plan and implement:
|
||||
|
||||
- Health/readiness/status surfaces for services, jobs, pipelines, and long-running work
|
||||
- Observable failure state: last error, phase, timestamp, identifiers, retry count, or equivalent
|
||||
- Deterministic verification of both happy path and at least one diagnostic/failure-path signal
|
||||
- Safe redaction boundaries: never log secrets, tokens, or sensitive raw payloads unnecessarily
|
||||
|
||||
Temporary instrumentation is allowed during debugging. Remove noisy one-off instrumentation before finishing unless it provides durable diagnostic value.
|
||||
For relevant work: add health/status surfaces, persist failure state (last error, phase, timestamp, retry count), verify both happy path and at least one diagnostic signal. Never log secrets. Remove noisy one-off instrumentation before finishing unless it provides durable diagnostic value.
|
||||
|
||||
### Root-cause-first debugging
|
||||
|
||||
- Fix the root cause, not just the visible symptom, unless the user explicitly wants a temporary workaround.
|
||||
- Prefer changes that remove the failure mode over changes that merely mask it.
|
||||
- When applying a temporary mitigation, label it clearly and preserve a path to the real fix.
|
||||
Fix the root cause, not symptoms. When applying a temporary mitigation, label it clearly and preserve the path to the real fix.
|
||||
|
||||
## Situational Playbooks
|
||||
|
||||
### Background processes
|
||||
|
||||
Use `bg_shell` instead of `bash` for any command that runs indefinitely or takes a long time.
|
||||
|
||||
**Starting processes:**
|
||||
|
||||
- Set `type:'server'` and `ready_port:<port>` for dev servers so readiness detection is automatic.
|
||||
- Set `group:'<name>'` on related processes (e.g. frontend + backend) to manage them together.
|
||||
- Use `ready_pattern:'<regex>'` for processes with non-standard readiness signals.
|
||||
- The tool auto-classifies commands as server/build/test/watcher/generic and applies smart defaults.
|
||||
|
||||
**After starting — use `wait_for_ready` instead of polling:**
|
||||
|
||||
- `wait_for_ready` blocks until the process signals readiness (pattern match or port open) or times out.
|
||||
- This replaces the old pattern of `start` → `sleep` → `output` → check → repeat. One tool call instead of many.
|
||||
|
||||
**Checking status — use `digest` instead of `output`:**
|
||||
|
||||
- `digest` returns a structured ~30-token summary (status, ports, URLs, error count, change summary) instead of ~2000 tokens of raw output. Use this by default.
|
||||
- `highlights` returns only significant lines (errors, URLs, results) — typically 5-15 lines instead of hundreds.
|
||||
- `output` returns raw incremental lines — use only when debugging and you need full text. Add `filter:'error|warning'` to narrow results.
|
||||
- Token budget hierarchy: `digest` (~30 tokens) < `highlights` (~100 tokens) < `output` (~2000 tokens). Always start with the lightest.
|
||||
|
||||
**Lifecycle awareness:**
|
||||
|
||||
- Process crashes and errors are automatically surfaced as alerts at the start of your next turn — you don't need to poll for failures.
|
||||
- Use `group_status` to check health of related processes as a unit.
|
||||
- Use `restart` to kill and relaunch with the same config — preserves restart count.
|
||||
|
||||
**Interactive processes:**
|
||||
|
||||
- Use `send_and_wait` for interactive CLIs: send input and wait for an expected output pattern. Replaces manual `send` → `sleep` → `output` polling.
|
||||
|
||||
**Cleanup:**
|
||||
|
||||
- Kill processes when done with them — do not leave orphans.
|
||||
- Use `list` to see all running background processes.
|
||||
Use `bg_shell` for anything long-running. Set `type:'server'` + `ready_port` for dev servers, `group:'name'` for related processes. Use `wait_for_ready` instead of polling. Use `digest` for status checks, `highlights` for significant output, `output` only when debugging. Use `send_and_wait` for interactive CLIs. Kill processes when done.
|
||||
|
||||
### Web behavior
|
||||
|
||||
When the task involves frontend behavior, DOM interactions, navigation, or user flows, verify with browser tools against a running app before marking the work complete.
|
||||
Verify frontend work with browser tools against a running app. Operating order: `browser_find`/`browser_snapshot_refs` for discovery → refs/selectors for targeting → `browser_batch` for obvious sequences → `browser_assert` for verification → `browser_diff` for ambiguous outcomes → console/network logs when assertions fail → full page inspection as last resort.
|
||||
|
||||
Use browser tools with this operating order unless there is a clear reason not to:
|
||||
Debug browser failures in order: failing assertion → `browser_diff` → console/network diagnostics → element/accessibility state → broader inspection. Retry only with a new hypothesis.
|
||||
|
||||
1. Cheap discovery first — use `browser_find` or `browser_snapshot_refs` to locate likely targets
|
||||
2. Deterministic targeting — prefer refs or explicit selectors over coordinates
|
||||
3. Batch obvious sequences — if the next 2-5 browser actions are clear and low-risk, use `browser_batch`
|
||||
4. Assert outcomes explicitly — prefer `browser_assert` over inferring success from prose summaries
|
||||
5. Diff ambiguous outcomes — use `browser_diff` when the effect of an action is unclear
|
||||
6. Inspect diagnostics only when needed — use console/network/dialog logs when assertions or diffs suggest failure
|
||||
7. Escalate inspection gradually — use `browser_get_accessibility_tree` only when targeted discovery is insufficient; use `browser_get_page_source` and `browser_evaluate` as escape hatches, not defaults
|
||||
8. Use screenshots as supporting evidence — do not default to screenshot-first browsing when semantic tools are sufficient
|
||||
### Libraries and current facts
|
||||
|
||||
For browser or UI work, “verified” means the flow was exercised and the expected outcome was checked explicitly with `browser_assert` or an equally structured browser signal whenever possible.
|
||||
- Libraries: `resolve_library` → `get_library_docs` with specific topic query. Start with `tokens=5000`.
|
||||
- Current facts: `search-the-web` to evaluate the landscape and pick URLs, or `search_and_read` when you know what you're looking for. Use `freshness` for recency, `domain` to scope to a specific site.
|
||||
|
||||
For browser failures, debug in this order:
|
||||
## Communication
|
||||
|
||||
1. inspect the failing assertion or explicit success signal
|
||||
2. inspect `browser_diff`
|
||||
3. inspect recent console/network/dialog diagnostics
|
||||
4. inspect targeted element or accessibility state
|
||||
5. only then escalate to broader page inspection
|
||||
- All plans are for the agent's own execution, not an imaginary team's. No enterprise patterns unless explicitly asked for.
|
||||
- Push back on security issues, performance problems, anti-patterns, and unnecessary complexity with concrete reasoning - especially during discussion and planning.
|
||||
- Between tool calls, narrate decisions, discoveries, phase transitions, and verification outcomes. One or two lines - not between every call, just when something is worth saying. Don't narrate the obvious.
|
||||
- State uncertainty plainly: "Not sure this handles X - testing it." No performed confidence, no hedging paragraphs.
|
||||
- When debugging, stay curious. Problems are puzzles. Say what's interesting about the failure before reaching for fixes.
|
||||
|
||||
Retry only with a new hypothesis. Do not thrash.
|
||||
|
||||
### Libraries, packages, and frameworks
|
||||
|
||||
When a task depends on a library or framework API, use Context7 before coding.
|
||||
|
||||
- Call `resolve_library` first
|
||||
- Choose the highest-trust, highest-benchmark match
|
||||
- Call `get_library_docs` with a specific topic query
|
||||
- Start with `tokens=5000`
|
||||
- Increase to `10000` only if the first result lacks needed detail
|
||||
|
||||
### Current external facts
|
||||
|
||||
When a task involves current events, release notes, pricing, or facts likely to have changed after training, use `search-the-web` before answering.
|
||||
|
||||
**Configuration:**
|
||||
- Requires `BRAVE_API_KEY` (Search plan) in `.env` or auth backend — used for `search-the-web`, `search_and_read`, and related search endpoints
|
||||
- Optional: `BRAVE_ANSWERS_KEY` (Answers plan) for Brave's chat/completions endpoints — separate from the Search API key
|
||||
|
||||
**Tool selection:**
|
||||
|
||||
- Use `search-the-web` when you need to **evaluate the landscape** — see what's available, pick the most relevant URLs, then selectively read them. Good for exploration, link browsing, and understanding what exists. Chain it with `fetch_page` on 1-2 promising results.
|
||||
- Use `search_and_read` when you **know what you're looking for** — you just need the answer extracted from relevant pages. It searches and extracts content from multiple sources in one call. Faster for straightforward factual queries.
|
||||
|
||||
**Usage:**
|
||||
|
||||
- Use `freshness` to scope results by recency: `day`, `week`, `month`, `year`. Auto-detection applies when the query contains recency signals like year numbers or "latest".
|
||||
- Use `domain` to limit results to a specific site when you know where the answer lives (e.g., `domain: "docs.python.org"`).
|
||||
- For `search-the-web` + `fetch_page`: start with default `maxChars` (8000). Use smaller values for quick checks, larger (up to 30000) for thorough reading. Token-conscious: prefer reading one good page over skimming five.
|
||||
- For `search_and_read`: start with default `maxTokens` (8192). Use smaller values for simple factual queries. Supports `threshold` control: `strict` for focused results, `lenient` for broader coverage.
|
||||
|
||||
## Communication and Writing Style
|
||||
|
||||
- Be direct, professional, and focused on the work.
|
||||
- Skip filler, false enthusiasm, and empty agreement.
|
||||
- Challenge bad patterns, unnecessary complexity, security issues, and performance problems with concrete reasoning.
|
||||
- The user makes the final call.
|
||||
- All plans are for the agent's own execution, not an imaginary team's.
|
||||
- Avoid enterprise patterns unless the user explicitly asks for them.
|
||||
|
||||
### Work Narration
|
||||
|
||||
Between tool calls, emit brief (1-2 sentence) messages so the user can follow the thread of your work. Narrate:
|
||||
|
||||
- **Decisions:** why you're choosing one approach over another
|
||||
- **Discoveries:** something you found that changes the plan or is worth noting
|
||||
- **Phase transitions:** when you shift from exploring to writing, from coding to testing, etc.
|
||||
- **Verification results:** what passed, what failed, what you're doing about it
|
||||
|
||||
Do NOT narrate routine file reads, trivial commands, or mechanical steps. If the next action is obvious from context, just do it.
|
||||
|
||||
Good: "Three existing handlers follow a middleware pattern — using that instead of a custom wrapper."
|
||||
Good: "Tests pass. Running slice-level verification."
|
||||
Good: "Auth library doesn't support refresh tokens natively — will need a wrapper."
|
||||
Bad: "Reading the file now." / "Let me check this." / "I'll look at the tests next."
|
||||
Good narration: "Three existing handlers follow a middleware pattern - using that instead of a custom wrapper."
|
||||
Good narration: "Tests pass. Running slice-level verification."
|
||||
Bad narration: "Reading the file now." / "Let me check this." / "I'll look at the tests next."
|
||||
|
|
|
|||
892
src/resources/extensions/gsd/tests/git-service.test.ts
Normal file
892
src/resources/extensions/gsd/tests/git-service.test.ts
Normal file
|
|
@ -0,0 +1,892 @@
|
|||
import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
|
||||
import { join, dirname } from "node:path";
|
||||
import { tmpdir } from "node:os";
|
||||
import { execSync } from "node:child_process";
|
||||
|
||||
import {
|
||||
inferCommitType,
|
||||
GitServiceImpl,
|
||||
RUNTIME_EXCLUSION_PATHS,
|
||||
runGit,
|
||||
type GitPreferences,
|
||||
type CommitOptions,
|
||||
type MergeSliceResult,
|
||||
} from "../git-service.ts";
|
||||
|
||||
let passed = 0;
|
||||
let failed = 0;
|
||||
|
||||
function assert(condition: boolean, message: string): void {
|
||||
if (condition) passed++;
|
||||
else {
|
||||
failed++;
|
||||
console.error(` FAIL: ${message}`);
|
||||
}
|
||||
}
|
||||
|
||||
function assertEq<T>(actual: T, expected: T, message: string): void {
|
||||
if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
|
||||
else {
|
||||
failed++;
|
||||
console.error(` FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
|
||||
}
|
||||
}
|
||||
|
||||
function run(command: string, cwd: string): string {
|
||||
return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
// ─── inferCommitType ───────────────────────────────────────────────────
|
||||
|
||||
console.log("\n=== inferCommitType ===");
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Implement user authentication"),
|
||||
"feat",
|
||||
"generic feature title → feat"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Add dashboard page"),
|
||||
"feat",
|
||||
"add-style title → feat"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Fix login redirect bug"),
|
||||
"fix",
|
||||
"title with 'fix' → fix"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Bug in session handling"),
|
||||
"fix",
|
||||
"title with 'bug' → fix"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Hotfix for production crash"),
|
||||
"fix",
|
||||
"title with 'hotfix' → fix"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Patch memory leak"),
|
||||
"fix",
|
||||
"title with 'patch' → fix"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Refactor state management"),
|
||||
"refactor",
|
||||
"title with 'refactor' → refactor"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Restructure project layout"),
|
||||
"refactor",
|
||||
"title with 'restructure' → refactor"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Reorganize module imports"),
|
||||
"refactor",
|
||||
"title with 'reorganize' → refactor"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Update API documentation"),
|
||||
"docs",
|
||||
"title with 'documentation' → docs"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Add doc for setup guide"),
|
||||
"docs",
|
||||
"title with 'doc' → docs"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Add unit tests for auth"),
|
||||
"test",
|
||||
"title with 'tests' → test"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Testing infrastructure setup"),
|
||||
"test",
|
||||
"title with 'testing' → test"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Chore: update dependencies"),
|
||||
"chore",
|
||||
"title with 'chore' → chore"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Cleanup unused imports"),
|
||||
"chore",
|
||||
"title with 'cleanup' → chore"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Clean up stale branches"),
|
||||
"chore",
|
||||
"title with 'clean up' → chore"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Archive old milestones"),
|
||||
"chore",
|
||||
"title with 'archive' → chore"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Remove deprecated endpoints"),
|
||||
"chore",
|
||||
"title with 'remove' → chore"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Delete temp files"),
|
||||
"chore",
|
||||
"title with 'delete' → chore"
|
||||
);
|
||||
|
||||
// Mixed keywords — first match wins
|
||||
assertEq(
|
||||
inferCommitType("Fix and refactor the login module"),
|
||||
"fix",
|
||||
"mixed keywords → first match wins (fix before refactor)"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType("Refactor test utilities"),
|
||||
"refactor",
|
||||
"mixed keywords → first match wins (refactor before test)"
|
||||
);
|
||||
|
||||
// Unknown / unrecognized title → feat
|
||||
assertEq(
|
||||
inferCommitType("Build the new pipeline"),
|
||||
"feat",
|
||||
"unrecognized title → feat"
|
||||
);
|
||||
|
||||
assertEq(
|
||||
inferCommitType(""),
|
||||
"feat",
|
||||
"empty title → feat"
|
||||
);
|
||||
|
||||
// Word boundary: "testify" should NOT match "test"
|
||||
assertEq(
|
||||
inferCommitType("Testify integration"),
|
||||
"feat",
|
||||
"'testify' does not match 'test' — word boundary prevents partial match"
|
||||
);
|
||||
|
||||
// "documentary" should NOT match "doc" (word boundary)
|
||||
assertEq(
|
||||
inferCommitType("Documentary style UI"),
|
||||
"feat",
|
||||
"'documentary' does not match 'doc' — word boundary prevents partial match"
|
||||
);
|
||||
|
||||
// "prefix" should NOT match "fix" (word boundary)
|
||||
assertEq(
|
||||
inferCommitType("Add prefix to all IDs"),
|
||||
"feat",
|
||||
"'prefix' does not match 'fix' — word boundary prevents partial match"
|
||||
);
|
||||
|
||||
// ─── RUNTIME_EXCLUSION_PATHS ───────────────────────────────────────────
|
||||
|
||||
console.log("\n=== RUNTIME_EXCLUSION_PATHS ===");
|
||||
|
||||
assertEq(
|
||||
RUNTIME_EXCLUSION_PATHS.length,
|
||||
6,
|
||||
"exactly 6 runtime exclusion paths"
|
||||
);
|
||||
|
||||
const expectedPaths = [
|
||||
".gsd/activity/",
|
||||
".gsd/runtime/",
|
||||
".gsd/worktrees/",
|
||||
".gsd/auto.lock",
|
||||
".gsd/metrics.json",
|
||||
".gsd/STATE.md",
|
||||
];
|
||||
|
||||
assertEq(
|
||||
[...RUNTIME_EXCLUSION_PATHS],
|
||||
expectedPaths,
|
||||
"paths match expected set in order"
|
||||
);
|
||||
|
||||
assert(
|
||||
RUNTIME_EXCLUSION_PATHS.includes(".gsd/activity/"),
|
||||
"includes .gsd/activity/"
|
||||
);
|
||||
assert(
|
||||
RUNTIME_EXCLUSION_PATHS.includes(".gsd/STATE.md"),
|
||||
"includes .gsd/STATE.md"
|
||||
);
|
||||
|
||||
// ─── runGit ────────────────────────────────────────────────────────────
|
||||
|
||||
console.log("\n=== runGit ===");
|
||||
|
||||
const tempDir = mkdtempSync(join(tmpdir(), "gsd-git-service-test-"));
|
||||
run("git init -b main", tempDir);
|
||||
run("git config user.name 'Pi Test'", tempDir);
|
||||
run("git config user.email 'pi@example.com'", tempDir);
|
||||
|
||||
// runGit should work on a valid repo
|
||||
const branch = runGit(tempDir, ["branch", "--show-current"]);
|
||||
assertEq(branch, "main", "runGit returns current branch");
|
||||
|
||||
// runGit allowFailure returns empty string on failure
|
||||
const result = runGit(tempDir, ["log", "--oneline"], { allowFailure: true });
|
||||
assertEq(result, "", "runGit allowFailure returns empty on error (no commits yet)");
|
||||
|
||||
// runGit throws on failure without allowFailure
|
||||
let threw = false;
|
||||
try {
|
||||
runGit(tempDir, ["log", "--oneline"]);
|
||||
} catch (e) {
|
||||
threw = true;
|
||||
assert(
|
||||
(e as Error).message.includes("git log --oneline failed"),
|
||||
"error message includes command and path"
|
||||
);
|
||||
}
|
||||
assert(threw, "runGit throws without allowFailure on error");
|
||||
|
||||
// ─── Type exports compile check ────────────────────────────────────────
|
||||
|
||||
console.log("\n=== Type exports ===");
|
||||
|
||||
// These are compile-time checks — if we got here, the types import fine
|
||||
const _prefs: GitPreferences = { auto_push: true, remote: "origin" };
|
||||
const _opts: CommitOptions = { message: "test" };
|
||||
const _result: MergeSliceResult = { branch: "main", mergedCommitMessage: "msg", deletedBranch: false };
|
||||
assert(true, "GitPreferences type exported and usable");
|
||||
assert(true, "CommitOptions type exported and usable");
|
||||
assert(true, "MergeSliceResult type exported and usable");
|
||||
|
||||
// Cleanup T01 temp dir
|
||||
rmSync(tempDir, { recursive: true, force: true });
|
||||
|
||||
// ─── Helper: create file with intermediate dirs ────────────────────────
|
||||
|
||||
function createFile(base: string, relativePath: string, content: string = "x"): void {
|
||||
const full = join(base, relativePath);
|
||||
mkdirSync(dirname(full), { recursive: true });
|
||||
writeFileSync(full, content, "utf-8");
|
||||
}
|
||||
|
||||
function initTempRepo(): string {
|
||||
const dir = mkdtempSync(join(tmpdir(), "gsd-git-t02-"));
|
||||
run("git init -b main", dir);
|
||||
run("git config user.name 'Pi Test'", dir);
|
||||
run("git config user.email 'pi@example.com'", dir);
|
||||
// Need an initial commit so HEAD exists
|
||||
createFile(dir, ".gitkeep", "");
|
||||
run("git add -A", dir);
|
||||
run("git commit -m 'init'", dir);
|
||||
return dir;
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: smart staging ─────────────────────────────────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: smart staging ===");
|
||||
|
||||
{
|
||||
const repo = initTempRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create runtime files (should be excluded from staging)
|
||||
createFile(repo, ".gsd/activity/log.jsonl", "log data");
|
||||
createFile(repo, ".gsd/runtime/state.json", '{"state":true}');
|
||||
createFile(repo, ".gsd/STATE.md", "# State");
|
||||
createFile(repo, ".gsd/auto.lock", "lock");
|
||||
createFile(repo, ".gsd/metrics.json", "{}");
|
||||
createFile(repo, ".gsd/worktrees/wt/file.txt", "wt data");
|
||||
|
||||
// Create a real file (should be staged)
|
||||
createFile(repo, "src/code.ts", 'console.log("hello");');
|
||||
|
||||
const result = svc.commit({ message: "test: smart staging" });
|
||||
|
||||
assertEq(result, "test: smart staging", "commit returns the commit message");
|
||||
|
||||
// Verify only src/code.ts is in the commit
|
||||
const showStat = run("git show --stat --format='' HEAD", repo);
|
||||
assert(showStat.includes("src/code.ts"), "src/code.ts is in the commit");
|
||||
assert(!showStat.includes(".gsd/activity"), ".gsd/activity/ excluded from commit");
|
||||
assert(!showStat.includes(".gsd/runtime"), ".gsd/runtime/ excluded from commit");
|
||||
assert(!showStat.includes("STATE.md"), ".gsd/STATE.md excluded from commit");
|
||||
assert(!showStat.includes("auto.lock"), ".gsd/auto.lock excluded from commit");
|
||||
assert(!showStat.includes("metrics.json"), ".gsd/metrics.json excluded from commit");
|
||||
assert(!showStat.includes(".gsd/worktrees"), ".gsd/worktrees/ excluded from commit");
|
||||
|
||||
// Verify runtime files are still untracked
|
||||
// git status --short may collapse to "?? .gsd/" or show individual files
|
||||
// Use --untracked-files=all to force individual listing
|
||||
const statusOut = run("git status --short --untracked-files=all", repo);
|
||||
assert(statusOut.includes(".gsd/activity/"), "activity still untracked after commit");
|
||||
assert(statusOut.includes(".gsd/runtime/"), "runtime still untracked after commit");
|
||||
assert(statusOut.includes(".gsd/STATE.md"), "STATE.md still untracked after commit");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: smart staging fallback ────────────────────────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: smart staging fallback ===");
|
||||
|
||||
{
|
||||
// We can't easily make the pathspec fail in a real repo, but we can test
|
||||
// the fallback behavior by verifying that if smart staging somehow fails,
|
||||
// everything gets staged. We do this by checking that a commit with both
|
||||
// runtime and real files works when pathspec would fail.
|
||||
//
|
||||
// To force the fallback: temporarily override RUNTIME_EXCLUSION_PATHS
|
||||
// with an invalid pathspec. Since we can't modify a readonly array,
|
||||
// we'll test the actual fallback by creating a custom subclass.
|
||||
|
||||
const repo = initTempRepo();
|
||||
|
||||
// Create a subclass that overrides smartStage to simulate failure + fallback
|
||||
class FallbackTestService extends GitServiceImpl {
|
||||
fallbackUsed = false;
|
||||
smartStageWithBadPathspec(): void {
|
||||
// Simulate: try bad pathspec, catch, fallback
|
||||
try {
|
||||
runGit(this.basePath, ["add", "-A", "--", ".", ":(exclude)__NONEXISTENT_PATHSPEC_SYNTAX_ERROR__["]);
|
||||
// If the above doesn't throw, git accepted it (some versions do).
|
||||
// That's fine — the point is testing the fallback path.
|
||||
throw new Error("force fallback for test");
|
||||
} catch {
|
||||
console.error("GitService: smart staging failed, falling back to git add -A");
|
||||
this.fallbackUsed = true;
|
||||
runGit(this.basePath, ["add", "-A"]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const svc = new FallbackTestService(repo);
|
||||
createFile(repo, "src/real.ts", "real code");
|
||||
createFile(repo, ".gsd/activity/log.jsonl", "log");
|
||||
|
||||
// Call the fallback path manually
|
||||
svc.smartStageWithBadPathspec();
|
||||
|
||||
// Check that everything was staged (fallback stages all)
|
||||
const staged = run("git diff --cached --name-only", repo);
|
||||
assert(staged.includes("src/real.ts"), "fallback stages real files");
|
||||
assert(staged.includes(".gsd/activity/log.jsonl"), "fallback stages runtime files too (no exclusion)");
|
||||
assert(svc.fallbackUsed, "fallback path was actually used");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: autoCommit on clean repo ──────────────────────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: autoCommit ===");
|
||||
|
||||
{
|
||||
const repo = initTempRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Clean repo — autoCommit should return null
|
||||
const cleanResult = svc.autoCommit("task", "T01");
|
||||
assertEq(cleanResult, null, "autoCommit on clean repo returns null");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: autoCommit on dirty repo ──────────────────────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: autoCommit on dirty repo ===");
|
||||
|
||||
{
|
||||
const repo = initTempRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
createFile(repo, "src/new-feature.ts", "export const x = 1;");
|
||||
const msg = svc.autoCommit("task", "T01");
|
||||
|
||||
assertEq(msg, "chore(T01): auto-commit after task", "autoCommit returns correct message format");
|
||||
|
||||
// Verify the commit exists
|
||||
const log = run("git log --oneline -1", repo);
|
||||
assert(log.includes("chore(T01): auto-commit after task"), "commit message is in git log");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: empty-after-staging guard ─────────────────────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: empty-after-staging guard ===");
|
||||
|
||||
{
|
||||
const repo = initTempRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create only runtime files
|
||||
createFile(repo, ".gsd/activity/x.jsonl", "data");
|
||||
|
||||
const result = svc.autoCommit("task", "T02");
|
||||
assertEq(result, null, "autoCommit returns null when only runtime files are dirty");
|
||||
|
||||
// Verify no new commit was created (should still be at init commit)
|
||||
const logCount = run("git rev-list --count HEAD", repo);
|
||||
assertEq(logCount, "1", "no new commit created when only runtime files changed");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── GitServiceImpl: commit returns null when nothing staged ───────────
|
||||
|
||||
console.log("\n=== GitServiceImpl: commit empty ===");
|
||||
|
||||
{
|
||||
const repo = initTempRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Nothing dirty, commit should return null
|
||||
const result = svc.commit({ message: "should not commit" });
|
||||
assertEq(result, null, "commit returns null when nothing to stage");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── Helper: create repo for branch tests ────────────────────────────
|
||||
|
||||
function initBranchTestRepo(): string {
|
||||
const dir = mkdtempSync(join(tmpdir(), "gsd-git-t03-"));
|
||||
run("git init -b main", dir);
|
||||
run("git config user.name 'Pi Test'", dir);
|
||||
run("git config user.email 'pi@example.com'", dir);
|
||||
createFile(dir, ".gitkeep", "");
|
||||
run("git add -A", dir);
|
||||
run("git commit -m 'init'", dir);
|
||||
return dir;
|
||||
}
|
||||
|
||||
// ─── getCurrentBranch / isOnSliceBranch / getActiveSliceBranch ─────────
|
||||
|
||||
console.log("\n=== Branch queries ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// On main
|
||||
assertEq(svc.getCurrentBranch(), "main", "getCurrentBranch returns main on main branch");
|
||||
assertEq(svc.isOnSliceBranch(), false, "isOnSliceBranch returns false on main");
|
||||
assertEq(svc.getActiveSliceBranch(), null, "getActiveSliceBranch returns null on main");
|
||||
|
||||
// Create and checkout a slice branch manually
|
||||
run("git checkout -b gsd/M001/S01", repo);
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "getCurrentBranch returns slice branch name");
|
||||
assertEq(svc.isOnSliceBranch(), true, "isOnSliceBranch returns true on slice branch");
|
||||
assertEq(svc.getActiveSliceBranch(), "gsd/M001/S01", "getActiveSliceBranch returns branch name on slice branch");
|
||||
|
||||
// Non-slice feature branch
|
||||
run("git checkout -b feature/foo", repo);
|
||||
assertEq(svc.isOnSliceBranch(), false, "isOnSliceBranch returns false on non-slice branch");
|
||||
assertEq(svc.getActiveSliceBranch(), null, "getActiveSliceBranch returns null on non-slice branch");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── getMainBranch ────────────────────────────────────────────────────
|
||||
|
||||
console.log("\n=== getMainBranch ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Basic case: repo has "main" branch
|
||||
assertEq(svc.getMainBranch(), "main", "getMainBranch returns main when main exists");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
{
|
||||
// master-only repo
|
||||
const repo = mkdtempSync(join(tmpdir(), "gsd-git-t03-master-"));
|
||||
run("git init -b master", repo);
|
||||
run("git config user.name 'Pi Test'", repo);
|
||||
run("git config user.email 'pi@example.com'", repo);
|
||||
createFile(repo, ".gitkeep", "");
|
||||
run("git add -A", repo);
|
||||
run("git commit -m 'init'", repo);
|
||||
|
||||
const svc = new GitServiceImpl(repo);
|
||||
assertEq(svc.getMainBranch(), "master", "getMainBranch returns master when only master exists");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── ensureSliceBranch: creates and checks out ────────────────────────
|
||||
|
||||
console.log("\n=== ensureSliceBranch ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
const created = svc.ensureSliceBranch("M001", "S01");
|
||||
assertEq(created, true, "ensureSliceBranch returns true on first call (branch created)");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "ensureSliceBranch checks out the slice branch");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── ensureSliceBranch: idempotent ────────────────────────────────────
|
||||
|
||||
console.log("\n=== ensureSliceBranch: idempotent ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
const secondCall = svc.ensureSliceBranch("M001", "S01");
|
||||
assertEq(secondCall, false, "ensureSliceBranch returns false when already on the branch");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "still on slice branch after idempotent call");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── ensureSliceBranch: from non-main working branch inherits artifacts ──
|
||||
|
||||
console.log("\n=== ensureSliceBranch: from non-main inherits artifacts ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create a feature branch with planning artifacts
|
||||
run("git checkout -b developer", repo);
|
||||
createFile(repo, ".gsd/milestones/M001/M001-ROADMAP.md", "# Roadmap");
|
||||
run("git add -A", repo);
|
||||
run("git commit -m 'add roadmap'", repo);
|
||||
|
||||
// ensureSliceBranch from this non-main, non-slice branch
|
||||
const created = svc.ensureSliceBranch("M001", "S01");
|
||||
assertEq(created, true, "branch created from non-main working branch");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "checked out to slice branch");
|
||||
|
||||
// The roadmap from developer branch should be present
|
||||
const logOutput = run("git log --oneline", repo);
|
||||
assert(logOutput.includes("add roadmap"), "slice branch inherits artifacts from working branch");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── ensureSliceBranch: from another slice branch falls back to main ──
|
||||
|
||||
console.log("\n=== ensureSliceBranch: from slice branch falls back to main ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create file only on main
|
||||
createFile(repo, "main-only.txt", "from main");
|
||||
run("git add -A", repo);
|
||||
run("git commit -m 'main-only file'", repo);
|
||||
|
||||
// Create and check out S01
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
// Add a file only on S01
|
||||
createFile(repo, "s01-only.txt", "from s01");
|
||||
run("git add -A", repo);
|
||||
run("git commit -m 'S01 work'", repo);
|
||||
|
||||
// Now create S02 from S01 — should fall back to main
|
||||
const created = svc.ensureSliceBranch("M001", "S02");
|
||||
assertEq(created, true, "S02 branch created from S01 (fell back to main)");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S02", "on S02 branch");
|
||||
|
||||
// S02 should NOT have the S01-only file (it branched from main)
|
||||
const showFiles = run("git ls-files", repo);
|
||||
assert(!showFiles.includes("s01-only.txt"), "S02 does not have S01-only files (branched from main)");
|
||||
assert(showFiles.includes("main-only.txt"), "S02 has main files");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── ensureSliceBranch: auto-commits dirty files via smart staging ────
|
||||
|
||||
console.log("\n=== ensureSliceBranch: auto-commits with smart staging ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create dirty files: both real and runtime
|
||||
createFile(repo, "src/feature.ts", "export const y = 2;");
|
||||
createFile(repo, ".gsd/activity/session.jsonl", "session data");
|
||||
createFile(repo, ".gsd/STATE.md", "# Current State");
|
||||
createFile(repo, ".gsd/metrics.json", '{"tasks":1}');
|
||||
|
||||
// ensureSliceBranch should auto-commit before checkout
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
|
||||
// The auto-commit on main should have src/feature.ts but NOT runtime files
|
||||
run("git checkout main", repo);
|
||||
const showStat = run("git show --stat --format='' HEAD", repo);
|
||||
assert(showStat.includes("src/feature.ts"), "auto-commit includes real files");
|
||||
assert(!showStat.includes(".gsd/activity"), "auto-commit excludes .gsd/activity/ (smart staging)");
|
||||
assert(!showStat.includes("STATE.md"), "auto-commit excludes .gsd/STATE.md (smart staging)");
|
||||
assert(!showStat.includes("metrics.json"), "auto-commit excludes .gsd/metrics.json (smart staging)");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── switchToMain ─────────────────────────────────────────────────────
|
||||
|
||||
console.log("\n=== switchToMain ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Switch to a slice branch first
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "on slice branch before switchToMain");
|
||||
|
||||
// Create dirty files
|
||||
createFile(repo, "src/work.ts", "work in progress");
|
||||
createFile(repo, ".gsd/activity/log.jsonl", "activity log");
|
||||
createFile(repo, ".gsd/runtime/state.json", '{"running":true}');
|
||||
|
||||
svc.switchToMain();
|
||||
assertEq(svc.getCurrentBranch(), "main", "switchToMain switches to main");
|
||||
|
||||
// Verify the auto-commit on the slice branch used smart staging
|
||||
const sliceLog = run("git log gsd/M001/S01 --oneline -1", repo);
|
||||
assert(sliceLog.includes("pre-switch"), "auto-commit message includes pre-switch");
|
||||
|
||||
// Check that the auto-commit on the slice branch excluded runtime files
|
||||
const showStat = run("git log gsd/M001/S01 -1 --format='' --stat", repo);
|
||||
assert(showStat.includes("src/work.ts"), "switchToMain auto-commit includes real files");
|
||||
assert(!showStat.includes(".gsd/activity"), "switchToMain auto-commit excludes .gsd/activity/");
|
||||
assert(!showStat.includes(".gsd/runtime"), "switchToMain auto-commit excludes .gsd/runtime/");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── switchToMain: idempotent when already on main ─────────────────────
|
||||
|
||||
console.log("\n=== switchToMain: idempotent ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
assertEq(svc.getCurrentBranch(), "main", "already on main");
|
||||
svc.switchToMain(); // Should not throw
|
||||
assertEq(svc.getCurrentBranch(), "main", "still on main after idempotent switchToMain");
|
||||
|
||||
// Verify no extra commits were created
|
||||
const logCount = run("git rev-list --count HEAD", repo);
|
||||
assertEq(logCount, "1", "no extra commits from idempotent switchToMain");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: full lifecycle with feat ─────────────────────────
|
||||
|
||||
console.log("\n=== mergeSliceToMain: full lifecycle ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create and switch to slice branch
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
assertEq(svc.getCurrentBranch(), "gsd/M001/S01", "on slice branch for merge test");
|
||||
|
||||
// Do work on the slice branch
|
||||
createFile(repo, "src/feature.ts", "export const feature = true;");
|
||||
svc.commit({ message: "add feature module" });
|
||||
|
||||
// Switch to main and merge
|
||||
svc.switchToMain();
|
||||
const result = svc.mergeSliceToMain("M001", "S01", "Implement user authentication");
|
||||
|
||||
assertEq(result.mergedCommitMessage, "feat(M001/S01): Implement user authentication", "merge commit message uses feat type");
|
||||
assertEq(result.deletedBranch, true, "branch was deleted");
|
||||
assertEq(result.branch, "gsd/M001/S01", "result includes branch name");
|
||||
|
||||
// Verify commit is on main
|
||||
const log = run("git log --oneline -1", repo);
|
||||
assert(log.includes("feat(M001/S01): Implement user authentication"), "merge commit visible in git log");
|
||||
|
||||
// Verify the file is on main
|
||||
const files = run("git ls-files", repo);
|
||||
assert(files.includes("src/feature.ts"), "merged file exists on main");
|
||||
|
||||
// Verify slice branch is deleted
|
||||
const branches = run("git branch", repo);
|
||||
assert(!branches.includes("gsd/M001/S01"), "slice branch deleted after merge");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: fix type ───────────────────────────────────────
|
||||
|
||||
console.log("\n=== mergeSliceToMain: fix type ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
svc.ensureSliceBranch("M001", "S02");
|
||||
createFile(repo, "src/bugfix.ts", "// fixed");
|
||||
svc.commit({ message: "fix the bug" });
|
||||
|
||||
svc.switchToMain();
|
||||
const result = svc.mergeSliceToMain("M001", "S02", "Fix broken config");
|
||||
|
||||
assert(result.mergedCommitMessage.startsWith("fix("), "merge commit starts with fix(");
|
||||
assertEq(result.mergedCommitMessage, "fix(M001/S02): Fix broken config", "fix merge commit message correct");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: docs type ──────────────────────────────────────
|
||||
|
||||
console.log("\n=== mergeSliceToMain: docs type ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
svc.ensureSliceBranch("M001", "S03");
|
||||
createFile(repo, "docs/guide.md", "# Guide");
|
||||
svc.commit({ message: "write docs" });
|
||||
|
||||
svc.switchToMain();
|
||||
const result = svc.mergeSliceToMain("M001", "S03", "Docs update");
|
||||
|
||||
assert(result.mergedCommitMessage.startsWith("docs("), "merge commit starts with docs(");
|
||||
assertEq(result.mergedCommitMessage, "docs(M001/S03): Docs update", "docs merge commit message correct");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: refactor type ──────────────────────────────────
|
||||
|
||||
console.log("\n=== mergeSliceToMain: refactor type ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
svc.ensureSliceBranch("M001", "S04");
|
||||
createFile(repo, "src/refactored.ts", "// cleaner");
|
||||
svc.commit({ message: "restructure modules" });
|
||||
|
||||
svc.switchToMain();
|
||||
const result = svc.mergeSliceToMain("M001", "S04", "Refactor state management");
|
||||
|
||||
assert(result.mergedCommitMessage.startsWith("refactor("), "merge commit starts with refactor(");
|
||||
assertEq(result.mergedCommitMessage, "refactor(M001/S04): Refactor state management", "refactor merge commit message correct");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: error — not on main ────────────────────────────
|
||||
|
||||
console.log("\n=== mergeSliceToMain: error cases ===");
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create a slice branch with a commit
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
createFile(repo, "src/work.ts", "work");
|
||||
svc.commit({ message: "slice work" });
|
||||
|
||||
// Try to merge while still on the slice branch
|
||||
let threw = false;
|
||||
try {
|
||||
svc.mergeSliceToMain("M001", "S01", "Some feature");
|
||||
} catch (e) {
|
||||
threw = true;
|
||||
const msg = (e as Error).message;
|
||||
assert(msg.includes("must be called from the main branch"), "error mentions main branch requirement");
|
||||
assert(msg.includes("gsd/M001/S01"), "error includes current branch name");
|
||||
}
|
||||
assert(threw, "mergeSliceToMain throws when not on main");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: error — branch doesn't exist ───────────────────
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
let threw = false;
|
||||
try {
|
||||
svc.mergeSliceToMain("M001", "S99", "Nonexistent");
|
||||
} catch (e) {
|
||||
threw = true;
|
||||
const msg = (e as Error).message;
|
||||
assert(msg.includes("does not exist"), "error mentions branch does not exist");
|
||||
assert(msg.includes("gsd/M001/S99"), "error includes missing branch name");
|
||||
}
|
||||
assert(threw, "mergeSliceToMain throws when branch doesn't exist");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
// ─── mergeSliceToMain: error — no commits ahead ───────────────────────
|
||||
|
||||
{
|
||||
const repo = initBranchTestRepo();
|
||||
const svc = new GitServiceImpl(repo);
|
||||
|
||||
// Create slice branch but don't add any commits
|
||||
svc.ensureSliceBranch("M001", "S01");
|
||||
// Switch back to main without committing anything on the slice branch
|
||||
svc.switchToMain();
|
||||
|
||||
let threw = false;
|
||||
try {
|
||||
svc.mergeSliceToMain("M001", "S01", "Empty slice");
|
||||
} catch (e) {
|
||||
threw = true;
|
||||
const msg = (e as Error).message;
|
||||
assert(msg.includes("no commits ahead"), "error mentions no commits ahead");
|
||||
assert(msg.includes("gsd/M001/S01"), "error includes branch name");
|
||||
}
|
||||
assert(threw, "mergeSliceToMain throws when no commits ahead");
|
||||
|
||||
rmSync(repo, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
console.log(`\nResults: ${passed} passed, ${failed} failed`);
|
||||
if (failed > 0) process.exit(1);
|
||||
console.log("All tests passed ✓");
|
||||
}
|
||||
|
||||
main().catch((error) => {
|
||||
console.error(error);
|
||||
process.exit(1);
|
||||
});
|
||||
Loading…
Add table
Reference in a new issue