Merge branch 'main' of https://github.com/gsd-build/gsd-2
This commit is contained in:
Derek Pearson
commit
e7b18f9e08
70 changed files with 2627 additions and 328 deletions
48
CHANGELOG.md
48
CHANGELOG.md
|
|
@ -6,6 +6,51 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
|
|||
|
||||
## [Unreleased]
|
||||
|
||||
## [2.39.0] - 2026-03-20
|
||||
|
||||
### Added
|
||||
- **gsd**: activate matching skills in dispatched prompts (#1630)
|
||||
- **gsd**: add .gsd/RUNTIME.md template for declared runtime context (#1626)
|
||||
- **gsd**: create draft PR on milestone completion when git.auto_pr enabled (#1627)
|
||||
- **gsd**: add browser-executable and runtime-executable UAT types (#1620)
|
||||
- apply model preferences in guided flow for milestone planning (#1614)
|
||||
- **gsd**: GitHub sync extension — auto-sync to Issues, PRs, Milestones (#1603)
|
||||
- add GSD_PROJECT_ID env var to override project hash (#1600)
|
||||
- add GSD_HOME env var to override global ~/.gsd directory (#1566)
|
||||
- **gsd**: add 13 enhancements to /gsd doctor (#1583)
|
||||
- feat(ui): minimal GSD welcome screen on startup (#1584)
|
||||
|
||||
### Fixed
|
||||
- recover + prevent #1364 .gsd/ data-loss (v2.30.0–v2.38.0) (#1635)
|
||||
- treat summary as terminal artifact even when roadmap slices are unchecked (#1632)
|
||||
- **gsd**: close residual #1364 data-loss vectors on v2.36.0+ (#1637)
|
||||
- auto-resolve npm subpath exports in extension loader (#1624)
|
||||
- create node_modules symlink for dynamic import resolution in extensions (#1623)
|
||||
- filter cross-milestone errors from health tracker escalation (#1621)
|
||||
- move unit closeout to run immediately after completion (#1612)
|
||||
- use pathspec exclusions in smartStage to prevent hanging on large repos (#1613)
|
||||
- add auto-fix for premature slice completion deadlock in doctor (#1611)
|
||||
- resolve ${VAR} env references in MCP client .mcp.json configs (#1609)
|
||||
- return "dispatched" after doctor heal to prevent session race (#1580) (#1610)
|
||||
- update Anthropic OAuth endpoints to platform.claude.com (#1608)
|
||||
- lazy-open GSD database on first tool call in manual sessions (#1606)
|
||||
- **gsd**: detect anthropic-vertex in provider doctor (#1598)
|
||||
- **gsd**: tighten prompt automation contracts (#1556)
|
||||
- **gsd**: harden auto-mode agent loop — session teardown, unit correlation, sidecar perf (#1592)
|
||||
- break remaining shared/mod.js barrel imports in report generation chain (#1588)
|
||||
- apply pi manifest opt-out to extension-discovery.ts (#1545)
|
||||
- detect worktree paths resolved through .gsd symlinks (#1585)
|
||||
|
||||
### Changed
|
||||
- **gsd**: unify sidecar mini-loop into main dispatch path (#1617)
|
||||
- **auto-loop**: initial cleanup — hoist constant, cache prefs per iteration (#1616)
|
||||
- **gsd**: add 30K char hard cap on prompt preamble (#1619)
|
||||
- **gsd**: replace stuck counter with sliding-window detection (#1618)
|
||||
- **auto-loop**: 5 code smell fixes (#1602)
|
||||
- **gsd**: replace session-scoped promise bridge with per-unit one-shot (#1595)
|
||||
- **gsd**: remove prompt compression subsystem (~4,100 lines) (#1597)
|
||||
- **gsd**: crashproof stopAuto with independent try/catch per cleanup step (#1596)
|
||||
|
||||
## [2.38.0] - 2026-03-20
|
||||
|
||||
### Added
|
||||
|
|
@ -1430,7 +1475,8 @@ Format based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
|
|||
### Changed
|
||||
- License updated to MIT
|
||||
|
||||
[Unreleased]: https://github.com/gsd-build/gsd-2/compare/v2.38.0...HEAD
|
||||
[Unreleased]: https://github.com/gsd-build/gsd-2/compare/v2.39.0...HEAD
|
||||
[2.39.0]: https://github.com/gsd-build/gsd-2/compare/v2.38.0...v2.39.0
|
||||
[2.38.0]: https://github.com/gsd-build/gsd-2/compare/v2.37.1...v2.38.0
|
||||
[2.37.1]: https://github.com/gsd-build/gsd-2/compare/v2.37.0...v2.37.1
|
||||
[2.37.0]: https://github.com/gsd-build/gsd-2/compare/v2.36.0...v2.37.0
|
||||
|
|
|
|||
28
README.md
28
README.md
|
|
@ -24,22 +24,26 @@ One command. Walk away. Come back to a built project with clean git history.
|
|||
|
||||
---
|
||||
|
||||
## What's New in v2.37
|
||||
## What's New in v2.38
|
||||
|
||||
- **cmux integration** — sidebar status, progress bars, and notifications for [cmux](https://cmux.com) terminal multiplexer users
|
||||
- **Redesigned dashboard** — two-column layout with redesigned widget
|
||||
- **Search budget enforcement** — session-level search budget prevents unbounded native web search
|
||||
- **AGENTS.md support** — deprecated `agent-instructions.md` in favor of standard `AGENTS.md` / `CLAUDE.md`
|
||||
- **AI-powered triage** — automated issue and PR triage via Claude Haiku
|
||||
- **Auto-generated OpenRouter registry** — model registry built from OpenRouter API for always-current model support
|
||||
- **Extension manifest system** — user-managed enable/disable for bundled extensions
|
||||
- **Pipeline simplification (ADR-003)** — merged research into planning, mechanical completion
|
||||
- **Workflow templates** — right-sized workflows for every task type
|
||||
- **Health widget** — always-on environment health checks with progress scoring
|
||||
- **`/gsd changelog`** — LLM-summarized release notes for any version
|
||||
- **Reactive task execution (ADR-004)** — graph-derived parallel task dispatch within slices. When enabled, GSD derives a dependency graph from IO annotations in task plans and dispatches multiple non-conflicting tasks in parallel via subagents. Backward compatible — disabled by default. Enable with `reactive_execution: true` in preferences.
|
||||
- **Anthropic Vertex AI provider** — run Claude models (Opus 4.6, Sonnet 4.6, Haiku 4.5) through Google Vertex AI. Set `ANTHROPIC_VERTEX_PROJECT_ID` to activate.
|
||||
- **CI optimization** — GitHub Actions minutes reduced ~60-70% (~10k → ~3-4k/month)
|
||||
- **Reactive batch verification** — dependency-based carry-forward for verification results across parallel task batches
|
||||
- **Backtick file path enforcement** — task plan IO sections now require backtick-wrapped paths for reliable parsing
|
||||
|
||||
See the full [Changelog](./CHANGELOG.md) for details.
|
||||
|
||||
### Previous highlights (v2.34–v2.37)
|
||||
|
||||
- **cmux integration** — sidebar status, progress bars, and notifications for cmux terminal multiplexer users
|
||||
- **Redesigned dashboard** — two-column layout with 4 widget modes (full → small → min → off)
|
||||
- **AGENTS.md support** — deprecated `agent-instructions.md` in favor of standard `AGENTS.md` / `CLAUDE.md`
|
||||
- **AI-powered triage** — automated issue and PR triage via Claude Haiku
|
||||
- **Auto-generated OpenRouter registry** — model registry built from OpenRouter API
|
||||
- **`/gsd changelog`** — LLM-summarized release notes for any version
|
||||
- **Search budget enforcement** — session-level cap prevents unbounded web search
|
||||
|
||||
---
|
||||
|
||||
## Documentation
|
||||
|
|
|
|||
|
|
@ -31,6 +31,7 @@ Welcome to the GSD documentation. This covers everything from getting started to
|
|||
| [Architecture Overview](./architecture.md) | System design, extension model, state-on-disk, and dispatch pipeline |
|
||||
| [Native Engine](../native/README.md) | Rust N-API modules for performance-critical operations |
|
||||
| [ADR-001: Branchless Worktree Architecture](./ADR-001-branchless-worktree-architecture.md) | Decision record for the v2.14 git architecture |
|
||||
| [ADR-003: Pipeline Simplification](./ADR-003-pipeline-simplification.md) | Research merged into planning, mechanical completion (v2.30) |
|
||||
|
||||
## Pi SDK Documentation
|
||||
|
||||
|
|
|
|||
|
|
@ -241,3 +241,15 @@ See [Token Optimization](./token-optimization.md) for details.
|
|||
## Dynamic Model Routing
|
||||
|
||||
When enabled, auto-mode automatically selects cheaper models for simple units (slice completion, UAT) and reserves expensive models for complex work (replanning, architectural tasks). See [Dynamic Model Routing](./dynamic-model-routing.md).
|
||||
|
||||
## Reactive Task Execution (v2.38)
|
||||
|
||||
When `reactive_execution: true` is set in preferences, GSD derives a dependency graph from IO annotations in task plans. Tasks that don't conflict (no shared file reads/writes) are dispatched in parallel via subagents, while dependent tasks wait for their predecessors to complete.
|
||||
|
||||
```yaml
|
||||
reactive_execution: true # disabled by default
|
||||
```
|
||||
|
||||
The graph derivation is pure and deterministic — it resolves a ready-set of tasks, detects conflicts, and guards against deadlocks. Verification results carry forward across parallel batches, so tasks that pass verification don't need to be re-verified when subsequent tasks in the same slice complete.
|
||||
|
||||
The implementation lives in `reactive-graph.ts` (graph derivation, ready-set resolution, conflict/deadlock detection) with integration into `auto-dispatch.ts` and `auto-prompts.ts`.
|
||||
|
|
|
|||
|
|
@ -66,6 +66,9 @@ docker run --rm -v $(pwd):/workspace ghcr.io/gsd-build/gsd-pi:latest --version
|
|||
| Release Pipeline | `pipeline.yml` | After CI succeeds on main | Three-stage promotion |
|
||||
| Native Binaries | `build-native.yml` | `v*` tags | Cross-compile platform binaries |
|
||||
| Dev Cleanup | `cleanup-dev-versions.yml` | Weekly (Monday 06:00 UTC) | Unpublish `-dev.` versions older than 30 days |
|
||||
| AI Triage | `triage.yml` | New issues + PRs | Automated classification via Claude Haiku (v2.36) |
|
||||
|
||||
**CI optimization (v2.38):** GitHub Actions minutes were reduced ~60-70% (~10k → ~3-4k/month) through workflow consolidation and caching improvements.
|
||||
|
||||
### Gating Tests
|
||||
|
||||
|
|
|
|||
|
|
@ -193,6 +193,26 @@ rm -rf "$(dirname .gsd)/.gsd.lock"
|
|||
- Set required environment variables in the MCP config's `env` block
|
||||
- If needed, set `cwd` explicitly in the server definition
|
||||
|
||||
### Session lock stolen by `/gsd` in another terminal
|
||||
|
||||
**Symptoms:** Running `/gsd` (step mode) in a second terminal causes a running auto-mode session to lose its lock.
|
||||
|
||||
**Fix:** Fixed in v2.36.0. Bare `/gsd` no longer steals the session lock from a running auto-mode session. Upgrade to the latest version.
|
||||
|
||||
### Worktree commits landing on main instead of milestone branch
|
||||
|
||||
**Symptoms:** Auto-mode commits in a worktree end up on `main` instead of the `milestone/<MID>` branch.
|
||||
|
||||
**Fix:** Fixed in v2.37.1. CWD is now realigned before dispatch and stale merge state is cleaned on failure. Upgrade to the latest version.
|
||||
|
||||
### Extension loader fails with subpath export error
|
||||
|
||||
**Symptoms:** Extension fails to load with a `Cannot find module` error referencing npm subpath exports.
|
||||
|
||||
**Cause:** Dynamic imports in the extension loader didn't resolve npm subpath exports (e.g., `@pkg/foo/bar`).
|
||||
|
||||
**Fix:** Fixed in v2.38+. The extension loader now auto-resolves npm subpath exports and creates a `node_modules` symlink for dynamic import resolution. Upgrade to the latest version.
|
||||
|
||||
## Recovery Procedures
|
||||
|
||||
### Reset auto mode state
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd-build/engine-darwin-arm64",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD native engine binary for macOS ARM64",
|
||||
"os": [
|
||||
"darwin"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd-build/engine-darwin-x64",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD native engine binary for macOS Intel",
|
||||
"os": [
|
||||
"darwin"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd-build/engine-linux-arm64-gnu",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD native engine binary for Linux ARM64 (glibc)",
|
||||
"os": [
|
||||
"linux"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd-build/engine-linux-x64-gnu",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD native engine binary for Linux x64 (glibc)",
|
||||
"os": [
|
||||
"linux"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd-build/engine-win32-x64-msvc",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD native engine binary for Windows x64 (MSVC)",
|
||||
"os": [
|
||||
"win32"
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "gsd-pi",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "GSD — Get Shit Done coding agent",
|
||||
"license": "MIT",
|
||||
"repository": {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@gsd/pi-coding-agent",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"description": "Coding agent CLI (vendored from pi-mono)",
|
||||
"type": "module",
|
||||
"piConfig": {
|
||||
|
|
|
|||
|
|
@ -23,6 +23,12 @@ import * as _bundledYaml from "yaml";
|
|||
import * as _bundledMcpClient from "@modelcontextprotocol/sdk/client";
|
||||
import * as _bundledMcpStdio from "@modelcontextprotocol/sdk/client/stdio.js";
|
||||
import * as _bundledMcpStreamableHttp from "@modelcontextprotocol/sdk/client/streamableHttp.js";
|
||||
import * as _bundledMcpSse from "@modelcontextprotocol/sdk/client/sse.js";
|
||||
import * as _bundledMcpServer from "@modelcontextprotocol/sdk/server";
|
||||
import * as _bundledMcpServerStdio from "@modelcontextprotocol/sdk/server/stdio.js";
|
||||
import * as _bundledMcpServerSse from "@modelcontextprotocol/sdk/server/sse.js";
|
||||
import * as _bundledMcpServerStreamableHttp from "@modelcontextprotocol/sdk/server/streamableHttp.js";
|
||||
import * as _bundledMcpTypes from "@modelcontextprotocol/sdk/types.js";
|
||||
import { getAgentDir, isBunBinary } from "../../config.js";
|
||||
// NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
|
||||
// avoiding a circular dependency. Extensions can import from @gsd/pi-coding-agent.
|
||||
|
|
@ -44,8 +50,11 @@ import type {
|
|||
ToolDefinition,
|
||||
} from "./types.js";
|
||||
|
||||
/** Modules available to extensions via virtualModules (for compiled Bun binary) */
|
||||
const VIRTUAL_MODULES: Record<string, unknown> = {
|
||||
/**
|
||||
* Statically imported modules for Bun binary virtualModules.
|
||||
* Maps specifier -> module object for subpaths that must be available in compiled binaries.
|
||||
*/
|
||||
const STATIC_BUNDLED_MODULES: Record<string, unknown> = {
|
||||
"@sinclair/typebox": _bundledTypebox,
|
||||
"@gsd/pi-agent-core": _bundledPiAgentCore,
|
||||
"@gsd/pi-tui": _bundledPiTui,
|
||||
|
|
@ -58,6 +67,17 @@ const VIRTUAL_MODULES: Record<string, unknown> = {
|
|||
"@modelcontextprotocol/sdk/client/stdio.js": _bundledMcpStdio,
|
||||
"@modelcontextprotocol/sdk/client/streamableHttp": _bundledMcpStreamableHttp,
|
||||
"@modelcontextprotocol/sdk/client/streamableHttp.js": _bundledMcpStreamableHttp,
|
||||
"@modelcontextprotocol/sdk/client/sse": _bundledMcpSse,
|
||||
"@modelcontextprotocol/sdk/client/sse.js": _bundledMcpSse,
|
||||
"@modelcontextprotocol/sdk/server": _bundledMcpServer,
|
||||
"@modelcontextprotocol/sdk/server/stdio": _bundledMcpServerStdio,
|
||||
"@modelcontextprotocol/sdk/server/stdio.js": _bundledMcpServerStdio,
|
||||
"@modelcontextprotocol/sdk/server/sse": _bundledMcpServerSse,
|
||||
"@modelcontextprotocol/sdk/server/sse.js": _bundledMcpServerSse,
|
||||
"@modelcontextprotocol/sdk/server/streamableHttp": _bundledMcpServerStreamableHttp,
|
||||
"@modelcontextprotocol/sdk/server/streamableHttp.js": _bundledMcpServerStreamableHttp,
|
||||
"@modelcontextprotocol/sdk/types": _bundledMcpTypes,
|
||||
"@modelcontextprotocol/sdk/types.js": _bundledMcpTypes,
|
||||
// Aliases for external PI ecosystem packages that import from the original scope
|
||||
"@mariozechner/pi-agent-core": _bundledPiAgentCore,
|
||||
"@mariozechner/pi-tui": _bundledPiTui,
|
||||
|
|
@ -66,9 +86,198 @@ const VIRTUAL_MODULES: Record<string, unknown> = {
|
|||
"@mariozechner/pi-coding-agent": _bundledPiCodingAgent,
|
||||
};
|
||||
|
||||
/** Modules available to extensions via virtualModules (for compiled Bun binary) */
|
||||
const VIRTUAL_MODULES: Record<string, unknown> = { ...STATIC_BUNDLED_MODULES };
|
||||
|
||||
const require = createRequire(import.meta.url);
|
||||
const EXTENSION_TIMING_ENABLED = process.env.GSD_STARTUP_TIMING === "1" || process.env.PI_TIMING === "1";
|
||||
|
||||
/**
|
||||
* Bundled npm packages whose subpath exports should be auto-resolved for extensions.
|
||||
* Each package listed here will have its `exports` field read from package.json,
|
||||
* and all subpath exports will be registered as jiti aliases (Node.js mode) so that
|
||||
* extensions can import any standard subpath without hitting jiti's CJS double-resolve bug.
|
||||
*/
|
||||
const BUNDLED_PACKAGES_WITH_EXPORTS = [
|
||||
"@modelcontextprotocol/sdk",
|
||||
"yaml",
|
||||
];
|
||||
|
||||
/**
|
||||
* Read a package's `exports` field and return alias entries mapping
|
||||
* specifiers (e.g. `@modelcontextprotocol/sdk/server`) to resolved file paths.
|
||||
*
|
||||
* Handles:
|
||||
* - Explicit subpath exports: `./client` -> `@pkg/client`
|
||||
* - Wildcard exports (`./*`): scans the package's dist directory for actual files
|
||||
* - Both `.js`-suffixed and bare specifiers for each subpath
|
||||
*/
|
||||
function resolveSubpathExports(packageName: string): Record<string, string> {
|
||||
const aliases: Record<string, string> = {};
|
||||
|
||||
let packageJsonPath: string;
|
||||
try {
|
||||
// Resolve the package's root directory via its package.json
|
||||
packageJsonPath = require.resolve(`${packageName}/package.json`);
|
||||
} catch {
|
||||
// Package doesn't allow importing package.json via exports — find it manually
|
||||
try {
|
||||
const anyEntry = require.resolve(packageName);
|
||||
// Walk up from the resolved entry to find package.json
|
||||
let dir = path.dirname(anyEntry);
|
||||
while (dir !== path.dirname(dir)) {
|
||||
const candidate = path.join(dir, "package.json");
|
||||
if (fs.existsSync(candidate)) {
|
||||
try {
|
||||
const pkg = JSON.parse(fs.readFileSync(candidate, "utf-8"));
|
||||
if (pkg.name === packageName) {
|
||||
packageJsonPath = candidate;
|
||||
break;
|
||||
}
|
||||
} catch {
|
||||
// not valid JSON, keep walking
|
||||
}
|
||||
}
|
||||
dir = path.dirname(dir);
|
||||
}
|
||||
} catch {
|
||||
return aliases;
|
||||
}
|
||||
if (!packageJsonPath!) return aliases;
|
||||
}
|
||||
|
||||
let pkg: { exports?: Record<string, unknown> };
|
||||
try {
|
||||
pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
|
||||
} catch {
|
||||
return aliases;
|
||||
}
|
||||
|
||||
const exports = pkg.exports;
|
||||
if (!exports || typeof exports !== "object") return aliases;
|
||||
|
||||
const packageDir = path.dirname(packageJsonPath);
|
||||
|
||||
for (const [subpath, target] of Object.entries(exports)) {
|
||||
if (subpath === ".") continue; // Root export handled by static imports
|
||||
|
||||
// Handle wildcard exports like "./*"
|
||||
if (subpath.includes("*")) {
|
||||
resolveWildcardExports(packageName, packageDir, subpath, target, aliases);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Explicit subpath: "./client" -> "@pkg/client"
|
||||
const specifier = `${packageName}/${subpath.replace(/^\.\//, "")}`;
|
||||
|
||||
try {
|
||||
const resolved = require.resolve(specifier);
|
||||
aliases[specifier] = resolved;
|
||||
|
||||
// Add .js-suffixed variant if the specifier doesn't already end in .js
|
||||
if (!specifier.endsWith(".js")) {
|
||||
const jsSpecifier = `${specifier}.js`;
|
||||
try {
|
||||
const jsResolved = require.resolve(jsSpecifier);
|
||||
aliases[jsSpecifier] = jsResolved;
|
||||
} catch {
|
||||
// .js variant doesn't resolve — that's fine
|
||||
}
|
||||
}
|
||||
|
||||
// Add bare variant (without .js) if it ends in .js
|
||||
if (specifier.endsWith(".js")) {
|
||||
const bareSpecifier = specifier.slice(0, -3);
|
||||
try {
|
||||
const bareResolved = require.resolve(bareSpecifier);
|
||||
aliases[bareSpecifier] = bareResolved;
|
||||
} catch {
|
||||
// bare variant doesn't resolve — that's fine
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// Subpath doesn't resolve — skip it
|
||||
}
|
||||
}
|
||||
|
||||
return aliases;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve wildcard export patterns (e.g. `./*`) by scanning the package's
|
||||
* file structure to find all matching files and generate alias entries.
|
||||
*/
|
||||
function resolveWildcardExports(
|
||||
packageName: string,
|
||||
packageDir: string,
|
||||
subpathPattern: string,
|
||||
target: unknown,
|
||||
aliases: Record<string, string>,
|
||||
): void {
|
||||
// Extract the target directory pattern from the export target
|
||||
// e.g. { "require": "./dist/cjs/*" } -> "dist/cjs"
|
||||
let targetDir: string | null = null;
|
||||
|
||||
if (typeof target === "string") {
|
||||
targetDir = target.replace(/\/\*$/, "").replace(/^\.\//, "");
|
||||
} else if (target && typeof target === "object") {
|
||||
const targetObj = target as Record<string, unknown>;
|
||||
// Prefer "require" for CJS compatibility with jiti, fall back to "import"
|
||||
const resolved = targetObj.require ?? targetObj.import ?? targetObj.default;
|
||||
if (typeof resolved === "string") {
|
||||
targetDir = resolved.replace(/\/\*$/, "").replace(/^\.\//, "");
|
||||
}
|
||||
}
|
||||
|
||||
if (!targetDir) return;
|
||||
|
||||
const fullTargetDir = path.join(packageDir, targetDir);
|
||||
if (!fs.existsSync(fullTargetDir)) return;
|
||||
|
||||
// Scan for .js files and generate specifiers
|
||||
const subpathPrefix = subpathPattern.replace(/\/?\*$/, "").replace(/^\.\//, "");
|
||||
scanDirForExports(packageName, fullTargetDir, subpathPrefix, aliases);
|
||||
}
|
||||
|
||||
/**
|
||||
* Recursively scan a directory for .js files and register them as aliases.
|
||||
*/
|
||||
function scanDirForExports(
|
||||
packageName: string,
|
||||
dir: string,
|
||||
relativePath: string,
|
||||
aliases: Record<string, string>,
|
||||
): void {
|
||||
let entries: fs.Dirent[];
|
||||
try {
|
||||
entries = fs.readdirSync(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
|
||||
for (const entry of entries) {
|
||||
const entryRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
|
||||
|
||||
if (entry.isDirectory()) {
|
||||
// Skip examples/test directories — extensions don't need them
|
||||
if (entry.name === "examples" || entry.name === "__tests__" || entry.name === "test") continue;
|
||||
scanDirForExports(packageName, path.join(dir, entry.name), entryRelative, aliases);
|
||||
} else if (entry.name.endsWith(".js") && !entry.name.endsWith(".d.js")) {
|
||||
const filePath = path.join(dir, entry.name);
|
||||
const specifier = `${packageName}/${entryRelative}`;
|
||||
// Only add if not already covered by an explicit export
|
||||
if (!(specifier in aliases)) {
|
||||
aliases[specifier] = filePath;
|
||||
}
|
||||
// Also add bare (no .js) variant
|
||||
const bareSpecifier = specifier.replace(/\.js$/, "");
|
||||
if (!(bareSpecifier in aliases)) {
|
||||
aliases[bareSpecifier] = filePath;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function logExtensionTiming(extensionPath: string, ms: number, outcome: "loaded" | "failed"): void {
|
||||
if (!EXTENSION_TIMING_ENABLED) return;
|
||||
console.error(`[startup] extension ${outcome}: ${extensionPath} (${ms}ms)`);
|
||||
|
|
@ -100,7 +309,19 @@ function getAliases(): Record<string, string> {
|
|||
return fileURLToPath(import.meta.resolve(specifier));
|
||||
};
|
||||
|
||||
// Auto-discover subpath exports from bundled npm packages.
|
||||
// This ensures extensions can import any standard subpath (e.g. @modelcontextprotocol/sdk/server)
|
||||
// without hitting jiti's CJS double-resolve bug.
|
||||
const autoDiscovered: Record<string, string> = {};
|
||||
for (const packageName of BUNDLED_PACKAGES_WITH_EXPORTS) {
|
||||
const subpathAliases = resolveSubpathExports(packageName);
|
||||
Object.assign(autoDiscovered, subpathAliases);
|
||||
}
|
||||
|
||||
_aliases = {
|
||||
// Auto-discovered subpath exports (lowest priority — overridden by manual entries below)
|
||||
...autoDiscovered,
|
||||
// Manual entries for workspace packages and packages needing special resolution
|
||||
"@gsd/pi-coding-agent": packageIndex,
|
||||
"@gsd/pi-agent-core": resolveWorkspaceOrImport("agent/dist/index.js", "@gsd/pi-agent-core"),
|
||||
"@gsd/pi-tui": resolveWorkspaceOrImport("tui/dist/index.js", "@gsd/pi-tui"),
|
||||
|
|
@ -108,11 +329,6 @@ function getAliases(): Record<string, string> {
|
|||
"@gsd/pi-ai/oauth": resolveWorkspaceOrImport("ai/dist/oauth.js", "@gsd/pi-ai/oauth"),
|
||||
"@sinclair/typebox": typeboxRoot,
|
||||
"yaml": yamlRoot,
|
||||
"@modelcontextprotocol/sdk/client": require.resolve("@modelcontextprotocol/sdk/client"),
|
||||
"@modelcontextprotocol/sdk/client/stdio": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
|
||||
"@modelcontextprotocol/sdk/client/stdio.js": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
|
||||
"@modelcontextprotocol/sdk/client/streamableHttp": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
|
||||
"@modelcontextprotocol/sdk/client/streamableHttp.js": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
|
||||
// Aliases for external PI ecosystem packages that import from the original scope
|
||||
"@mariozechner/pi-coding-agent": packageIndex,
|
||||
"@mariozechner/pi-agent-core": resolveWorkspaceOrImport("agent/dist/index.js", "@gsd/pi-agent-core"),
|
||||
|
|
|
|||
|
|
@ -81,6 +81,12 @@ export interface LoadSkillsResult {
|
|||
diagnostics: ResourceDiagnostic[];
|
||||
}
|
||||
|
||||
let loadedSkills: Skill[] = [];
|
||||
|
||||
export function getLoadedSkills(): Skill[] {
|
||||
return [...loadedSkills];
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate skill name per Agent Skills spec.
|
||||
* Returns array of validation error messages (empty if valid).
|
||||
|
|
@ -449,8 +455,10 @@ export function loadSkills(options: LoadSkillsOptions = {}): LoadSkillsResult {
|
|||
}
|
||||
}
|
||||
|
||||
loadedSkills = Array.from(skillMap.values());
|
||||
|
||||
return {
|
||||
skills: Array.from(skillMap.values()),
|
||||
skills: [...loadedSkills],
|
||||
diagnostics: [...allDiagnostics, ...collisionDiagnostics],
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -213,6 +213,7 @@ export {
|
|||
// Skills
|
||||
export {
|
||||
formatSkillsForPrompt,
|
||||
getLoadedSkills,
|
||||
type LoadSkillsFromDirOptions,
|
||||
type LoadSkillsResult,
|
||||
loadSkills,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "@glittercowboy/gsd",
|
||||
"version": "2.38.0",
|
||||
"version": "2.39.0",
|
||||
"piConfig": {
|
||||
"name": "gsd",
|
||||
"configDir": ".gsd"
|
||||
|
|
|
|||
415
scripts/recover-gsd-1364.ps1
Normal file
415
scripts/recover-gsd-1364.ps1
Normal file
|
|
@ -0,0 +1,415 @@
|
|||
# recover-gsd-1364.ps1 - Recovery script for issue #1364 (Windows)
|
||||
#
|
||||
# CRITICAL DATA-LOSS BUG: GSD versions 2.30.0-2.35.x unconditionally added
|
||||
# ".gsd" to .gitignore via ensureGitignore(), causing git to report all
|
||||
# tracked .gsd/ files as deleted. Fixed in v2.36.0 (PR #1367).
|
||||
#
|
||||
# This script:
|
||||
# 1. Detects whether the repo was affected
|
||||
# 2. Finds the last clean commit before the damage
|
||||
# 3. Restores all deleted .gsd/ files from that commit
|
||||
# 4. Removes the bad ".gsd" line from .gitignore (if .gsd/ is tracked)
|
||||
# 5. Prints a ready-to-commit summary
|
||||
#
|
||||
# Usage:
|
||||
# powershell -ExecutionPolicy Bypass -File scripts\recover-gsd-1364.ps1 [-DryRun]
|
||||
#
|
||||
# Options:
|
||||
# -DryRun Show what would be done without making any changes
|
||||
#
|
||||
# Requirements: git >= 2.x, PowerShell >= 5.1, Git for Windows
|
||||
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[switch]$DryRun
|
||||
)
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
|
||||
# ── Helpers ───────────────────────────────────────────────────────────────────
|
||||
|
||||
function Write-Info { param($msg) Write-Host "[info] $msg" -ForegroundColor Cyan }
|
||||
function Write-Ok { param($msg) Write-Host "[ok] $msg" -ForegroundColor Green }
|
||||
function Write-Warn { param($msg) Write-Host "[warn] $msg" -ForegroundColor Yellow }
|
||||
function Write-Err { param($msg) Write-Host "[error] $msg" -ForegroundColor Red }
|
||||
function Write-Section { param($msg) Write-Host "`n$msg" -ForegroundColor White }
|
||||
|
||||
function Exit-Fatal {
|
||||
param($msg)
|
||||
Write-Err $msg
|
||||
exit 1
|
||||
}
|
||||
|
||||
function Invoke-Git {
|
||||
param([string[]]$Args, [switch]$AllowFailure)
|
||||
try {
|
||||
$result = & git @Args 2>&1
|
||||
if ($LASTEXITCODE -ne 0) {
|
||||
if ($AllowFailure) { return "" }
|
||||
throw "git $($Args -join ' ') exited $LASTEXITCODE"
|
||||
}
|
||||
return ($result -join "`n").Trim()
|
||||
} catch {
|
||||
if ($AllowFailure) { return "" }
|
||||
throw
|
||||
}
|
||||
}
|
||||
|
||||
# Run or dry-run a git command
|
||||
function Invoke-GitOrDryRun {
|
||||
param([string[]]$GitArgs, [string]$Display)
|
||||
if ($DryRun) {
|
||||
Write-Host " (dry-run) git $Display" -ForegroundColor Yellow
|
||||
} else {
|
||||
Invoke-Git $GitArgs | Out-Null
|
||||
}
|
||||
}
|
||||
|
||||
# Check whether a path is a symlink OR a junction (Windows uses junctions for
|
||||
# the .gsd external-state migration via symlinkSync(..., "junction"))
|
||||
function Test-ReparsePoint {
|
||||
param([string]$Path)
|
||||
if (-not (Test-Path $Path)) { return $false }
|
||||
$item = Get-Item -LiteralPath $Path -Force -ErrorAction SilentlyContinue
|
||||
if (-not $item) { return $false }
|
||||
# LinkType covers: SymbolicLink, Junction, HardLink
|
||||
return ($item.LinkType -eq 'SymbolicLink' -or $item.LinkType -eq 'Junction')
|
||||
}
|
||||
|
||||
# ── Preflight ─────────────────────────────────────────────────────────────────
|
||||
|
||||
Write-Section "── Preflight ───────────────────────────────────────────────────────"
|
||||
|
||||
# Verify git is available
|
||||
if (-not (Get-Command git -ErrorAction SilentlyContinue)) {
|
||||
Exit-Fatal "git not found on PATH. Install Git for Windows from https://git-scm.com"
|
||||
}
|
||||
|
||||
# Must be run from inside a git repo
|
||||
$gitDirCheck = & git rev-parse --git-dir 2>&1
|
||||
if ($LASTEXITCODE -ne 0) {
|
||||
Exit-Fatal "Not inside a git repository. Run this from your project root."
|
||||
}
|
||||
|
||||
$repoRoot = Invoke-Git @('rev-parse', '--show-toplevel')
|
||||
Set-Location $repoRoot
|
||||
Write-Info "Repo root: $repoRoot"
|
||||
|
||||
if ($DryRun) {
|
||||
Write-Warn "DRY-RUN mode — no changes will be made."
|
||||
}
|
||||
|
||||
# ── Step 1: Detect .gsd/ ─────────────────────────────────────────────────────
|
||||
|
||||
Write-Section "── Step 1: Detect .gsd/ directory ─────────────────────────────────"
|
||||
|
||||
$gsdDir = Join-Path $repoRoot '.gsd'
|
||||
$GsdIsSymlink = $false
|
||||
|
||||
if (-not (Test-Path $gsdDir)) {
|
||||
Write-Ok ".gsd/ does not exist in this repo — not affected."
|
||||
exit 0
|
||||
}
|
||||
|
||||
if (Test-ReparsePoint $gsdDir) {
|
||||
# Scenario C: migration succeeded (symlink/junction in place) but git index was never
|
||||
# cleaned — tracked .gsd/* files still appear as deleted through the reparse point.
|
||||
$GsdIsSymlink = $true
|
||||
Write-Warn ".gsd/ is a symlink/junction — checking for stale git index entries (Scenario C)..."
|
||||
} else {
|
||||
Write-Info ".gsd/ is a real directory (Scenario A/B)."
|
||||
}
|
||||
|
||||
# ── Step 2: Check .gitignore for .gsd entry ──────────────────────────────────
|
||||
|
||||
Write-Section "── Step 2: Check .gitignore for .gsd entry ─────────────────────────"
|
||||
|
||||
$gitignorePath = Join-Path $repoRoot '.gitignore'
|
||||
|
||||
if (-not (Test-Path $gitignorePath) -and -not $GsdIsSymlink) {
|
||||
Write-Ok ".gitignore does not exist — not affected."
|
||||
exit 0
|
||||
}
|
||||
|
||||
$gitignoreLines = @()
|
||||
$gsdIgnoreLine = $null
|
||||
if (Test-Path $gitignorePath) {
|
||||
$gitignoreLines = Get-Content $gitignorePath -Encoding UTF8
|
||||
$gsdIgnoreLine = $gitignoreLines | Where-Object {
|
||||
$trimmed = $_.Trim()
|
||||
$trimmed -eq '.gsd' -and -not $trimmed.StartsWith('#')
|
||||
} | Select-Object -First 1
|
||||
}
|
||||
|
||||
if ($GsdIsSymlink) {
|
||||
# Symlink layout: .gsd SHOULD be ignored (it's external state).
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Warn '".gsd" missing from .gitignore — will add (migration complete, .gsd/ is external).'
|
||||
} else {
|
||||
Write-Ok '".gsd" already in .gitignore — correct for external-state layout.'
|
||||
}
|
||||
} else {
|
||||
# Real-directory layout: .gsd should NOT be ignored.
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Ok '".gsd" not found in .gitignore — .gitignore not affected.'
|
||||
} else {
|
||||
Write-Warn '".gsd" found in .gitignore — this is the bad pattern from #1364.'
|
||||
}
|
||||
}
|
||||
|
||||
# ── Step 3: Find deleted .gsd/ files ─────────────────────────────────────────
|
||||
|
||||
Write-Section "── Step 3: Find deleted .gsd/ files ───────────────────────────────"
|
||||
|
||||
# Files deleted in working tree (tracked but missing)
|
||||
$deletedRaw = Invoke-Git @('ls-files', '--deleted', '--', '.gsd/*') -AllowFailure
|
||||
$deletedFiles = if ($deletedRaw) { $deletedRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
|
||||
# Files tracked in HEAD right now
|
||||
$trackedInHeadRaw = Invoke-Git @('ls-tree', '-r', '--name-only', 'HEAD', '--', '.gsd/') -AllowFailure
|
||||
$trackedInHead = if ($trackedInHeadRaw) { $trackedInHeadRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
|
||||
$deletedFromHistory = @()
|
||||
if ($GsdIsSymlink) {
|
||||
# Scenario C: migration succeeded. Files are safe via reparse point.
|
||||
# Only index entries can be stale — no need to scan commit history.
|
||||
if ($trackedInHead.Count -eq 0 -and $deletedFiles.Count -eq 0) {
|
||||
Write-Ok "No stale index entries found — symlink/junction layout is healthy."
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Info "Add .gsd to .gitignore manually to complete the migration."
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
$indexCount = if ($trackedInHead.Count -gt 0) { $trackedInHead.Count } else { $deletedFiles.Count }
|
||||
Write-Warn "Scenario C: $indexCount .gsd/ file(s) tracked in git index but inaccessible through reparse point."
|
||||
Write-Info "Files are safe in external storage — only the git index needs cleaning."
|
||||
} else {
|
||||
# Files deleted in committed history (post-commit damage scenario — Scenario B)
|
||||
$deletedHistoryRaw = Invoke-Git @('log', '--all', '--diff-filter=D', '--name-only', '--format=', '--', '.gsd/*') -AllowFailure
|
||||
$deletedFromHistory = if ($deletedHistoryRaw) {
|
||||
$deletedHistoryRaw -split "`n" | Where-Object { $_ -match '^\.gsd' } | Sort-Object -Unique
|
||||
} else { @() }
|
||||
|
||||
# Nothing was ever tracked in any scenario
|
||||
if ($trackedInHead.Count -eq 0 -and $deletedFiles.Count -eq 0 -and $deletedFromHistory.Count -eq 0) {
|
||||
Write-Ok "No .gsd/ files tracked in this repo — not affected by #1364."
|
||||
if ($gsdIgnoreLine) {
|
||||
Write-Warn '".gsd" is still in .gitignore but there is nothing to restore.'
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
|
||||
# Determine scenario
|
||||
if ($trackedInHead.Count -gt 0) {
|
||||
Write-Info "Scenario A: $($trackedInHead.Count) .gsd/ files still tracked in HEAD."
|
||||
} elseif ($deletedFromHistory.Count -gt 0) {
|
||||
Write-Warn "Scenario B: $($deletedFromHistory.Count) .gsd/ file(s) were tracked but deleted in a committed change:"
|
||||
$deletedFromHistory | Select-Object -First 20 | ForEach-Object { Write-Host " - $_" }
|
||||
if ($deletedFromHistory.Count -gt 20) {
|
||||
Write-Host " ... and $($deletedFromHistory.Count - 20) more"
|
||||
}
|
||||
}
|
||||
|
||||
if ($deletedFiles.Count -gt 0) {
|
||||
Write-Warn "$($deletedFiles.Count) .gsd/ file(s) are missing from working tree (tracked but deleted/gitignored):"
|
||||
$deletedFiles | Select-Object -First 20 | ForEach-Object { Write-Host " - $_" }
|
||||
if ($deletedFiles.Count -gt 20) {
|
||||
Write-Host " ... and $($deletedFiles.Count - 20) more"
|
||||
}
|
||||
}
|
||||
|
||||
# HEAD has files and working tree is clean — only .gitignore needs fixing
|
||||
if ($trackedInHead.Count -gt 0 -and $deletedFiles.Count -eq 0) {
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Ok "No action needed — .gsd/ is tracked in HEAD and .gitignore is clean."
|
||||
exit 0
|
||||
}
|
||||
Write-Info ".gsd/ is tracked in HEAD and working tree is clean — only .gitignore needs fixing."
|
||||
}
|
||||
}
|
||||
|
||||
# ── Step 4: Find last clean commit (Scenario A/B only) ───────────────────────
|
||||
|
||||
Write-Section "── Step 4: Find last clean commit ──────────────────────────────────"
|
||||
|
||||
$damageCommit = $null
|
||||
$cleanCommit = $null
|
||||
$restorableFiles = @()
|
||||
|
||||
if ($GsdIsSymlink) {
|
||||
Write-Info "Scenario C: symlink/junction layout — skipping commit history scan (no file restore needed)."
|
||||
} else {
|
||||
Write-Info "Scanning git log to find when .gsd was added to .gitignore..."
|
||||
|
||||
# Strategy 1: find first commit that added ".gsd" to .gitignore
|
||||
$gitignoreCommits = Invoke-Git @('log', '--format=%H', '--', '.gitignore') -AllowFailure
|
||||
if ($gitignoreCommits) {
|
||||
foreach ($sha in ($gitignoreCommits -split "`n" | Where-Object { $_ })) {
|
||||
$content = Invoke-Git @('show', "${sha}:.gitignore") -AllowFailure
|
||||
if ($content -and ($content -split "`n" | Where-Object { $_.Trim() -eq '.gsd' })) {
|
||||
$damageCommit = $sha
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# Strategy 2: find commit that deleted .gsd/ files
|
||||
if (-not $damageCommit -and $deletedFromHistory.Count -gt 0) {
|
||||
Write-Info "Searching for the commit that deleted .gsd/ files from the index..."
|
||||
$deleteCommits = Invoke-Git @('log', '--all', '--diff-filter=D', '--format=%H', '--', '.gsd/*') -AllowFailure
|
||||
if ($deleteCommits) {
|
||||
$damageCommit = ($deleteCommits -split "`n" | Where-Object { $_ } | Select-Object -First 1)
|
||||
}
|
||||
}
|
||||
|
||||
if (-not $damageCommit) {
|
||||
Write-Warn "Could not pinpoint the damage commit — falling back to HEAD."
|
||||
$cleanCommit = 'HEAD'
|
||||
} else {
|
||||
$damageMsg = Invoke-Git @('log', '--format=%s', '-1', $damageCommit) -AllowFailure
|
||||
Write-Info "Damage commit: $damageCommit ($damageMsg)"
|
||||
$cleanCommit = "${damageCommit}^"
|
||||
$cleanMsg = Invoke-Git @('log', '--format=%s', '-1', $cleanCommit) -AllowFailure
|
||||
if (-not $cleanMsg) { $cleanMsg = 'unknown' }
|
||||
Write-Info "Restoring from: $cleanCommit — $cleanMsg"
|
||||
}
|
||||
|
||||
# Verify restore point has .gsd/ files
|
||||
$restorable = Invoke-Git @('ls-tree', '-r', '--name-only', $cleanCommit, '--', '.gsd/') -AllowFailure
|
||||
$restorableFiles = if ($restorable) { $restorable -split "`n" | Where-Object { $_ } } else { @() }
|
||||
|
||||
if ($restorableFiles.Count -eq 0) {
|
||||
Exit-Fatal "No .gsd/ files found in restore point $cleanCommit — cannot recover. Check git log manually."
|
||||
}
|
||||
|
||||
Write-Ok "Restore point has $($restorableFiles.Count) .gsd/ files available."
|
||||
}
|
||||
|
||||
# ── Step 5: Clean index (Scenario C) or restore deleted files (Scenario A/B) ─
|
||||
|
||||
if ($GsdIsSymlink) {
|
||||
Write-Section "── Step 5: Clean stale git index entries ───────────────────────────"
|
||||
|
||||
Write-Info "Running: git rm -r --cached --ignore-unmatch .gsd/ ..."
|
||||
Invoke-GitOrDryRun -GitArgs @('rm', '-r', '--cached', '--ignore-unmatch', '.gsd') -Display "rm -r --cached --ignore-unmatch .gsd"
|
||||
|
||||
if (-not $DryRun) {
|
||||
$stillStaleRaw = Invoke-Git @('ls-files', '--deleted', '--', '.gsd/*') -AllowFailure
|
||||
$stillStale = if ($stillStaleRaw) { $stillStaleRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
if ($stillStale.Count -eq 0) {
|
||||
Write-Ok "Git index cleaned — no stale .gsd/ entries remain."
|
||||
} else {
|
||||
Write-Warn "$($stillStale.Count) stale entr(ies) still present — may need manual cleanup."
|
||||
}
|
||||
}
|
||||
} else {
|
||||
Write-Section "── Step 5: Restore deleted .gsd/ files ────────────────────────────"
|
||||
|
||||
$needsRestore = ($deletedFiles.Count -gt 0) -or ($deletedFromHistory.Count -gt 0 -and $trackedInHead.Count -eq 0)
|
||||
|
||||
if (-not $needsRestore) {
|
||||
Write-Ok "No deleted files to restore — skipping."
|
||||
} else {
|
||||
Write-Info "Restoring .gsd/ files from $cleanCommit..."
|
||||
Invoke-GitOrDryRun -GitArgs @('checkout', $cleanCommit, '--', '.gsd/') -Display "checkout $cleanCommit -- .gsd/"
|
||||
|
||||
if (-not $DryRun) {
|
||||
$stillMissingRaw = Invoke-Git @('ls-files', '--deleted', '--', '.gsd/*') -AllowFailure
|
||||
$stillMissing = if ($stillMissingRaw) { $stillMissingRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
if ($stillMissing.Count -eq 0) {
|
||||
Write-Ok "All .gsd/ files restored successfully."
|
||||
} else {
|
||||
Write-Warn "$($stillMissing.Count) file(s) still missing after restore — may need manual recovery:"
|
||||
$stillMissing | Select-Object -First 10 | ForEach-Object { Write-Host " - $_" }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# ── Step 6: Fix .gitignore ────────────────────────────────────────────────────
|
||||
|
||||
Write-Section "── Step 6: Fix .gitignore ──────────────────────────────────────────"
|
||||
|
||||
if ($GsdIsSymlink) {
|
||||
# Scenario C: .gsd IS external — it should be in .gitignore. Add if missing.
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Info 'Adding ".gsd" to .gitignore (migration complete — .gsd/ is external state)...'
|
||||
if ($DryRun) {
|
||||
Write-Host " (dry-run) Would append: .gsd" -ForegroundColor Yellow
|
||||
} else {
|
||||
$appendLines = @('', '# GSD external state (symlink/junction — added by recover-gsd-1364)', '.gsd')
|
||||
Add-Content -LiteralPath $gitignorePath -Value $appendLines -Encoding UTF8
|
||||
Write-Ok '".gsd" added to .gitignore.'
|
||||
}
|
||||
} else {
|
||||
Write-Ok '".gsd" already in .gitignore — correct for external-state layout.'
|
||||
}
|
||||
} else {
|
||||
# Scenario A/B: .gsd is a real tracked directory — remove the bad ignore line.
|
||||
if (-not $gsdIgnoreLine) {
|
||||
Write-Ok '".gsd" not in .gitignore — nothing to fix.'
|
||||
} else {
|
||||
Write-Info 'Removing bare ".gsd" line from .gitignore...'
|
||||
if ($DryRun) {
|
||||
Write-Host " (dry-run) Would remove line: .gsd" -ForegroundColor Yellow
|
||||
} else {
|
||||
# Filter out the exact bare ".gsd" line — preserve all other content including
|
||||
# sub-path patterns like ".gsd/", ".gsd/activity/" and comments
|
||||
$cleaned = $gitignoreLines | Where-Object { $_.Trim() -ne '.gsd' }
|
||||
# Write with UTF-8 no BOM to match git's expectations
|
||||
[System.IO.File]::WriteAllLines($gitignorePath, $cleaned, [System.Text.UTF8Encoding]::new($false))
|
||||
Write-Ok '".gsd" line removed from .gitignore.'
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# ── Step 7: Stage changes ─────────────────────────────────────────────────────
|
||||
|
||||
Write-Section "── Step 7: Stage recovery changes ──────────────────────────────────"
|
||||
|
||||
if (-not $DryRun) {
|
||||
$changed = Invoke-Git @('status', '--short', '--', '.gsd/', '.gitignore') -AllowFailure
|
||||
if (-not $changed) {
|
||||
Write-Ok "No staged changes — working tree was already clean."
|
||||
} else {
|
||||
if ($GsdIsSymlink) {
|
||||
# Scenario C: git rm --cached already staged the index cleanup.
|
||||
# Only stage .gitignore — adding .gsd/ would fail (now gitignored).
|
||||
Invoke-Git @('add', '.gitignore') -AllowFailure | Out-Null
|
||||
} else {
|
||||
Invoke-Git @('add', '.gsd/', '.gitignore') -AllowFailure | Out-Null
|
||||
}
|
||||
$stagedRaw = Invoke-Git @('diff', '--cached', '--name-only', '--', '.gsd/', '.gitignore') -AllowFailure
|
||||
$stagedFiles = if ($stagedRaw) { $stagedRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
Write-Ok "$($stagedFiles.Count) file(s) staged and ready to commit."
|
||||
}
|
||||
}
|
||||
|
||||
# ── Summary ───────────────────────────────────────────────────────────────────
|
||||
|
||||
Write-Section "── Summary ──────────────────────────────────────────────────────────"
|
||||
|
||||
if ($DryRun) {
|
||||
Write-Host "Dry-run complete. Re-run without -DryRun to apply changes." -ForegroundColor Yellow
|
||||
} else {
|
||||
$finalStagedRaw = Invoke-Git @('diff', '--cached', '--name-only', '--', '.gsd/', '.gitignore') -AllowFailure
|
||||
$finalStaged = if ($finalStagedRaw) { $finalStagedRaw -split "`n" | Where-Object { $_ } } else { @() }
|
||||
|
||||
if ($finalStaged.Count -gt 0) {
|
||||
Write-Host "Recovery complete. Commit with:" -ForegroundColor Green
|
||||
Write-Host ""
|
||||
if ($GsdIsSymlink) {
|
||||
Write-Host ' git commit -m "fix: clean stale .gsd/ index entries after external-state migration"'
|
||||
} else {
|
||||
Write-Host ' git commit -m "fix: restore .gsd/ files deleted by #1364 regression"'
|
||||
}
|
||||
Write-Host ""
|
||||
Write-Host "Staged files:"
|
||||
$finalStaged | Select-Object -First 20 | ForEach-Object { Write-Host " + $_" }
|
||||
if ($finalStaged.Count -gt 20) {
|
||||
Write-Host " ... and $($finalStaged.Count - 20) more"
|
||||
}
|
||||
} else {
|
||||
Write-Ok "Repo is healthy — no recovery needed."
|
||||
}
|
||||
}
|
||||
386
scripts/recover-gsd-1364.sh
Executable file
386
scripts/recover-gsd-1364.sh
Executable file
|
|
@ -0,0 +1,386 @@
|
|||
#!/usr/bin/env bash
|
||||
# recover-gsd-1364.sh — Recovery script for issue #1364 (Linux / macOS)
|
||||
#
|
||||
# For Windows use the PowerShell equivalent:
|
||||
# powershell -ExecutionPolicy Bypass -File scripts\recover-gsd-1364.ps1 [-DryRun]
|
||||
#
|
||||
# CRITICAL DATA-LOSS BUG: GSD versions 2.30.0–2.35.x unconditionally added
|
||||
# ".gsd" to .gitignore via ensureGitignore(), causing git to report all
|
||||
# tracked .gsd/ files as deleted. Fixed in v2.36.0 (PR #1367).
|
||||
# Three residual vectors remain on v2.36.0–v2.38.0 — see PR #1635 for details.
|
||||
#
|
||||
# This script:
|
||||
# 1. Detects whether the repo was affected
|
||||
# 2. Finds the last clean commit before the damage
|
||||
# 3. Restores all deleted .gsd/ files from that commit
|
||||
# 4. Removes the bad ".gsd" line from .gitignore (if .gsd/ is tracked)
|
||||
# 5. Prints a ready-to-commit summary
|
||||
#
|
||||
# Usage:
|
||||
# bash scripts/recover-gsd-1364.sh [--dry-run]
|
||||
#
|
||||
# Options:
|
||||
# --dry-run Show what would be done without making any changes
|
||||
#
|
||||
# Requirements: git >= 2.x, bash >= 4.x
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
# ─── Colours ──────────────────────────────────────────────────────────────────
|
||||
|
||||
RED='\033[0;31m'
|
||||
YELLOW='\033[1;33m'
|
||||
GREEN='\033[0;32m'
|
||||
CYAN='\033[0;36m'
|
||||
BOLD='\033[1m'
|
||||
RESET='\033[0m'
|
||||
|
||||
# ─── Args ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
DRY_RUN=false
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--dry-run) DRY_RUN=true ;;
|
||||
*) echo "Unknown argument: $arg" >&2; exit 1 ;;
|
||||
esac
|
||||
done
|
||||
|
||||
# ─── Helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
info() { echo -e "${CYAN}[info]${RESET} $*"; }
|
||||
ok() { echo -e "${GREEN}[ok]${RESET} $*"; }
|
||||
warn() { echo -e "${YELLOW}[warn]${RESET} $*"; }
|
||||
error() { echo -e "${RED}[error]${RESET} $*" >&2; }
|
||||
section() { echo -e "\n${BOLD}$*${RESET}"; }
|
||||
|
||||
die() {
|
||||
error "$*"
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Run or print-only depending on --dry-run
|
||||
run() {
|
||||
if $DRY_RUN; then
|
||||
echo -e " ${YELLOW}(dry-run)${RESET} $*"
|
||||
else
|
||||
eval "$*"
|
||||
fi
|
||||
}
|
||||
|
||||
# ─── Preflight ────────────────────────────────────────────────────────────────
|
||||
|
||||
section "── Preflight ───────────────────────────────────────────────────────"
|
||||
|
||||
# Must be run from a git repo root
|
||||
if ! git rev-parse --git-dir > /dev/null 2>&1; then
|
||||
die "Not inside a git repository. Run this from your project root."
|
||||
fi
|
||||
|
||||
REPO_ROOT="$(git rev-parse --show-toplevel)"
|
||||
cd "$REPO_ROOT"
|
||||
info "Repo root: $REPO_ROOT"
|
||||
|
||||
if $DRY_RUN; then
|
||||
warn "DRY-RUN mode — no changes will be made."
|
||||
fi
|
||||
|
||||
# ─── Step 1: Check if .gsd/ exists ────────────────────────────────────────────
|
||||
|
||||
section "── Step 1: Detect .gsd/ directory ────────────────────────────────────"
|
||||
|
||||
GSD_DIR="$REPO_ROOT/.gsd"
|
||||
GSD_IS_SYMLINK=false
|
||||
|
||||
if [[ ! -e "$GSD_DIR" ]]; then
|
||||
ok ".gsd/ does not exist in this repo — not affected."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if [[ -L "$GSD_DIR" ]]; then
|
||||
# Scenario C: migration succeeded (symlink in place) but git index was never
|
||||
# cleaned — tracked .gsd/* files still appear as deleted through the symlink.
|
||||
GSD_IS_SYMLINK=true
|
||||
warn ".gsd/ is a symlink — checking for stale git index entries (Scenario C)..."
|
||||
else
|
||||
info ".gsd/ is a real directory (Scenario A/B)."
|
||||
fi
|
||||
|
||||
# ─── Step 2: Check if .gsd is in .gitignore ───────────────────────────────────
|
||||
|
||||
section "── Step 2: Check .gitignore for .gsd entry ────────────────────────────"
|
||||
|
||||
GITIGNORE="$REPO_ROOT/.gitignore"
|
||||
|
||||
if [[ ! -f "$GITIGNORE" ]] && ! $GSD_IS_SYMLINK; then
|
||||
ok ".gitignore does not exist — not affected."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Look for a bare ".gsd" line (not a comment, not a sub-path like .gsd/)
|
||||
GSD_IGNORE_LINE=""
|
||||
if [[ -f "$GITIGNORE" ]]; then
|
||||
while IFS= read -r line; do
|
||||
trimmed="${line#"${line%%[![:space:]]*}"}"
|
||||
trimmed="${trimmed%"${trimmed##*[![:space:]]}"}"
|
||||
if [[ "$trimmed" == ".gsd" ]] && [[ "${trimmed:0:1}" != "#" ]]; then
|
||||
GSD_IGNORE_LINE="$trimmed"
|
||||
break
|
||||
fi
|
||||
done < "$GITIGNORE"
|
||||
fi
|
||||
|
||||
if $GSD_IS_SYMLINK; then
|
||||
# Symlink layout: .gsd SHOULD be ignored (it's external state).
|
||||
# Missing = needs adding. Present = correct.
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
warn '".gsd" missing from .gitignore — will add (migration complete, .gsd/ is external).'
|
||||
else
|
||||
ok '".gsd" already in .gitignore — correct for external-state layout.'
|
||||
fi
|
||||
else
|
||||
# Real-directory layout: .gsd should NOT be ignored.
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
ok '".gsd" not found in .gitignore — .gitignore not affected.'
|
||||
else
|
||||
warn '".gsd" found in .gitignore — this is the bad pattern from #1364.'
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─── Step 3: Find deleted .gsd/ tracked files ─────────────────────────────────
|
||||
|
||||
section "── Step 3: Find deleted .gsd/ files ───────────────────────────────────"
|
||||
|
||||
# Files showing as deleted in the working tree (tracked in index but missing)
|
||||
DELETED_FILES="$(git ls-files --deleted -- '.gsd/*' 2>/dev/null || true)"
|
||||
|
||||
# Files tracked in HEAD right now
|
||||
TRACKED_IN_HEAD="$(git ls-tree -r --name-only HEAD -- '.gsd/' 2>/dev/null || true)"
|
||||
|
||||
if $GSD_IS_SYMLINK; then
|
||||
# Scenario C: migration succeeded. Files are safe via symlink.
|
||||
# Only index entries can be stale — no need to scan commit history.
|
||||
if [[ -z "$TRACKED_IN_HEAD" ]] && [[ -z "$DELETED_FILES" ]]; then
|
||||
ok "No stale index entries found — symlink layout is healthy."
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
info "Add .gsd to .gitignore manually to complete the migration."
|
||||
fi
|
||||
exit 0
|
||||
fi
|
||||
INDEX_COUNT="$(echo "${TRACKED_IN_HEAD:-$DELETED_FILES}" | wc -l | tr -d ' ')"
|
||||
warn "Scenario C: ${INDEX_COUNT} .gsd/ file(s) tracked in git index but inaccessible through symlink."
|
||||
info "Files are safe in external storage — only the git index needs cleaning."
|
||||
else
|
||||
# Files deleted via a committed git rm --cached (Scenario B)
|
||||
DELETED_FROM_HISTORY="$(git log --all --diff-filter=D --name-only --format="" -- '.gsd/*' 2>/dev/null \
|
||||
| grep '^\.gsd' | sort -u || true)"
|
||||
|
||||
if [[ -z "$TRACKED_IN_HEAD" ]] && [[ -z "$DELETED_FILES" ]] && [[ -z "$DELETED_FROM_HISTORY" ]]; then
|
||||
ok "No .gsd/ files tracked in this repo — not affected by #1364."
|
||||
if [[ -n "$GSD_IGNORE_LINE" ]]; then
|
||||
warn '".gsd" is still in .gitignore but there is nothing to restore.'
|
||||
fi
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if [[ -n "$TRACKED_IN_HEAD" ]]; then
|
||||
TRACKED_COUNT="$(echo "$TRACKED_IN_HEAD" | wc -l | tr -d ' ')"
|
||||
info "Scenario A: ${TRACKED_COUNT} .gsd/ files still tracked in HEAD."
|
||||
elif [[ -n "$DELETED_FROM_HISTORY" ]]; then
|
||||
DELETED_HIST_COUNT="$(echo "$DELETED_FROM_HISTORY" | wc -l | tr -d ' ')"
|
||||
warn "Scenario B: ${DELETED_HIST_COUNT} .gsd/ file(s) deleted in a committed change:"
|
||||
echo "$DELETED_FROM_HISTORY" | head -20 | while IFS= read -r f; do echo " - $f"; done
|
||||
if (( DELETED_HIST_COUNT > 20 )); then echo " ... and $((DELETED_HIST_COUNT - 20)) more"; fi
|
||||
fi
|
||||
|
||||
if [[ -n "$DELETED_FILES" ]]; then
|
||||
DELETED_COUNT="$(echo "$DELETED_FILES" | wc -l | tr -d ' ')"
|
||||
warn "${DELETED_COUNT} .gsd/ file(s) missing from working tree:"
|
||||
echo "$DELETED_FILES" | head -20 | while IFS= read -r f; do echo " - $f"; done
|
||||
if (( DELETED_COUNT > 20 )); then echo " ... and $((DELETED_COUNT - 20)) more"; fi
|
||||
fi
|
||||
|
||||
if [[ -n "$TRACKED_IN_HEAD" ]] && [[ -z "$DELETED_FILES" ]]; then
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
ok "No action needed — .gsd/ is tracked in HEAD and .gitignore is clean."
|
||||
exit 0
|
||||
fi
|
||||
info ".gsd/ is tracked in HEAD and working tree is clean — only .gitignore needs fixing."
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─── Step 4: Find the last clean commit (Scenario A/B only) ───────────────────
|
||||
|
||||
section "── Step 4: Find last clean commit ──────────────────────────────────────"
|
||||
|
||||
DAMAGE_COMMIT=""
|
||||
CLEAN_COMMIT=""
|
||||
RESTORABLE=""
|
||||
|
||||
if $GSD_IS_SYMLINK; then
|
||||
info "Scenario C: symlink layout — skipping commit history scan (no file restore needed)."
|
||||
else
|
||||
# Find the commit where ".gsd" was first added to .gitignore
|
||||
# by walking the log and finding the first commit where .gitignore contained ".gsd"
|
||||
info "Scanning git log to find when .gsd was added to .gitignore..."
|
||||
|
||||
# Strategy 1: find the first commit that added ".gsd" to .gitignore
|
||||
while IFS= read -r sha; do
|
||||
content="$(git show "${sha}:.gitignore" 2>/dev/null || true)"
|
||||
if echo "$content" | grep -qx '\.gsd' 2>/dev/null; then
|
||||
DAMAGE_COMMIT="$sha"
|
||||
break
|
||||
fi
|
||||
done < <(git log --format="%H" -- .gitignore)
|
||||
|
||||
# Strategy 2: if .gsd files were committed as deleted, find that commit
|
||||
if [[ -z "$DAMAGE_COMMIT" ]] && [[ -n "${DELETED_FROM_HISTORY:-}" ]]; then
|
||||
info "Searching for the commit that deleted .gsd/ files from the index..."
|
||||
DAMAGE_COMMIT="$(git log --all --diff-filter=D --format="%H" -- '.gsd/*' 2>/dev/null | head -1 || true)"
|
||||
fi
|
||||
|
||||
if [[ -z "$DAMAGE_COMMIT" ]]; then
|
||||
warn "Could not pinpoint the damage commit — falling back to HEAD."
|
||||
CLEAN_COMMIT="HEAD"
|
||||
else
|
||||
info "Damage commit: $DAMAGE_COMMIT ($(git log --format='%s' -1 "$DAMAGE_COMMIT"))"
|
||||
CLEAN_COMMIT="${DAMAGE_COMMIT}^"
|
||||
CLEAN_MSG="$(git log --format='%s' -1 "$CLEAN_COMMIT" 2>/dev/null || echo "unknown")"
|
||||
info "Restoring from: $CLEAN_COMMIT — $CLEAN_MSG"
|
||||
fi
|
||||
|
||||
# Verify the clean commit actually has .gsd/ files
|
||||
RESTORABLE="$(git ls-tree -r --name-only "$CLEAN_COMMIT" -- '.gsd/' 2>/dev/null || true)"
|
||||
if [[ -z "$RESTORABLE" ]]; then
|
||||
die "No .gsd/ files found in restore point $CLEAN_COMMIT — cannot recover. Check git log manually."
|
||||
fi
|
||||
|
||||
RESTORABLE_COUNT="$(echo "$RESTORABLE" | wc -l | tr -d ' ')"
|
||||
ok "Restore point has ${RESTORABLE_COUNT} .gsd/ files available."
|
||||
fi
|
||||
|
||||
# ─── Step 5: Clean index (Scenario C) or restore deleted files (Scenario A/B) ─
|
||||
|
||||
if $GSD_IS_SYMLINK; then
|
||||
section "── Step 5: Clean stale git index entries ───────────────────────────────"
|
||||
|
||||
info "Running: git rm -r --cached --ignore-unmatch .gsd/ ..."
|
||||
run "git rm -r --cached --ignore-unmatch .gsd"
|
||||
if ! $DRY_RUN; then
|
||||
STILL_STALE="$(git ls-files --deleted -- '.gsd/*' 2>/dev/null || true)"
|
||||
if [[ -z "$STILL_STALE" ]]; then
|
||||
ok "Git index cleaned — no stale .gsd/ entries remain."
|
||||
else
|
||||
warn "$(echo "$STILL_STALE" | wc -l | tr -d ' ') stale entr(ies) still present — may need manual cleanup."
|
||||
fi
|
||||
fi
|
||||
else
|
||||
section "── Step 5: Restore deleted .gsd/ files ────────────────────────────────"
|
||||
|
||||
NEEDS_RESTORE=false
|
||||
[[ -n "$DELETED_FILES" ]] && NEEDS_RESTORE=true
|
||||
[[ -n "${DELETED_FROM_HISTORY:-}" ]] && [[ -z "$TRACKED_IN_HEAD" ]] && NEEDS_RESTORE=true
|
||||
|
||||
if ! $NEEDS_RESTORE; then
|
||||
ok "No deleted files to restore — skipping."
|
||||
else
|
||||
info "Restoring .gsd/ files from $CLEAN_COMMIT..."
|
||||
run "git checkout \"$CLEAN_COMMIT\" -- .gsd/"
|
||||
if ! $DRY_RUN; then
|
||||
STILL_MISSING="$(git ls-files --deleted -- '.gsd/*' 2>/dev/null || true)"
|
||||
if [[ -z "$STILL_MISSING" ]]; then
|
||||
ok "All .gsd/ files restored successfully."
|
||||
else
|
||||
MISS_COUNT="$(echo "$STILL_MISSING" | wc -l | tr -d ' ')"
|
||||
warn "${MISS_COUNT} file(s) still missing after restore — may need manual recovery:"
|
||||
echo "$STILL_MISSING" | head -10 | while IFS= read -r f; do echo " - $f"; done
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─── Step 6: Fix .gitignore ───────────────────────────────────────────────────
|
||||
|
||||
section "── Step 6: Fix .gitignore ───────────────────────────────────────────────"
|
||||
|
||||
if $GSD_IS_SYMLINK; then
|
||||
# Scenario C: .gsd IS external — it should be in .gitignore. Add if missing.
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
info 'Adding ".gsd" to .gitignore (migration complete — .gsd/ is external state)...'
|
||||
if $DRY_RUN; then
|
||||
echo -e " ${YELLOW}(dry-run)${RESET} Would append: .gsd"
|
||||
else
|
||||
printf '\n# GSD external state (symlink — added by recover-gsd-1364)\n.gsd\n' >> "$GITIGNORE"
|
||||
ok '".gsd" added to .gitignore.'
|
||||
fi
|
||||
else
|
||||
ok '".gsd" already in .gitignore — correct for external-state layout.'
|
||||
fi
|
||||
else
|
||||
# Scenario A/B: .gsd is a real tracked directory — remove the bad ignore line.
|
||||
if [[ -z "$GSD_IGNORE_LINE" ]]; then
|
||||
ok '".gsd" not in .gitignore — nothing to fix.'
|
||||
else
|
||||
info 'Removing bare ".gsd" line from .gitignore...'
|
||||
if $DRY_RUN; then
|
||||
echo -e " ${YELLOW}(dry-run)${RESET} Would remove line: .gsd"
|
||||
else
|
||||
# Remove the exact line ".gsd" (not comments, not .gsd/ subdirs)
|
||||
# Use a temp file for portability (no sed -i on all platforms)
|
||||
TMP="$(mktemp)"
|
||||
grep -v '^\.gsd$' "$GITIGNORE" > "$TMP" || true
|
||||
mv "$TMP" "$GITIGNORE"
|
||||
ok '".gsd" line removed from .gitignore.'
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─── Step 7: Stage changes ────────────────────────────────────────────────────
|
||||
|
||||
section "── Step 7: Stage recovery changes ──────────────────────────────────────"
|
||||
|
||||
if ! $DRY_RUN; then
|
||||
CHANGED="$(git status --short -- '.gsd/' .gitignore 2>/dev/null || true)"
|
||||
if [[ -z "$CHANGED" ]]; then
|
||||
ok "No staged changes — working tree was already clean."
|
||||
else
|
||||
if $GSD_IS_SYMLINK; then
|
||||
# Scenario C: the git rm --cached already staged the index cleanup.
|
||||
# Only stage .gitignore — adding .gsd/ would fail (now gitignored).
|
||||
git add .gitignore 2>/dev/null || true
|
||||
else
|
||||
git add .gsd/ .gitignore 2>/dev/null || true
|
||||
fi
|
||||
STAGED_COUNT="$(git diff --cached --name-only -- '.gsd/' .gitignore | wc -l | tr -d ' ')"
|
||||
ok "${STAGED_COUNT} file(s) staged and ready to commit."
|
||||
fi
|
||||
fi
|
||||
|
||||
# ─── Summary ──────────────────────────────────────────────────────────────────
|
||||
|
||||
section "── Summary ──────────────────────────────────────────────────────────────"
|
||||
|
||||
if $DRY_RUN; then
|
||||
echo -e "${YELLOW}Dry-run complete. Re-run without --dry-run to apply changes.${RESET}"
|
||||
else
|
||||
FINAL_STAGED="$(git diff --cached --name-only -- '.gsd/' .gitignore 2>/dev/null | wc -l | tr -d ' ')"
|
||||
if (( FINAL_STAGED > 0 )); then
|
||||
echo -e "${GREEN}Recovery complete. Commit with:${RESET}"
|
||||
echo ""
|
||||
if $GSD_IS_SYMLINK; then
|
||||
echo " git commit -m \"fix: clean stale .gsd/ index entries after external-state migration\""
|
||||
else
|
||||
echo " git commit -m \"fix: restore .gsd/ files deleted by #1364 regression\""
|
||||
fi
|
||||
echo ""
|
||||
echo "Staged files:"
|
||||
git diff --cached --name-only -- '.gsd/' .gitignore | head -20 | while IFS= read -r f; do
|
||||
echo " + $f"
|
||||
done
|
||||
TOTAL_STAGED="$(git diff --cached --name-only -- '.gsd/' .gitignore | wc -l | tr -d ' ')"
|
||||
if (( TOTAL_STAGED > 20 )); then
|
||||
echo " ... and $((TOTAL_STAGED - 20)) more"
|
||||
fi
|
||||
else
|
||||
ok "Repo is healthy — no recovery needed."
|
||||
fi
|
||||
fi
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
import { DefaultResourceLoader } from '@gsd/pi-coding-agent'
|
||||
import { createHash } from 'node:crypto'
|
||||
import { homedir } from 'node:os'
|
||||
import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
|
||||
import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs'
|
||||
import { dirname, join, relative, resolve } from 'node:path'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { compareSemver } from './update-check.js'
|
||||
|
|
@ -237,6 +237,35 @@ function copyDirRecursive(src: string, dest: string): void {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates (or updates) a symlink at agentDir/node_modules pointing to GSD's
|
||||
* own node_modules directory.
|
||||
*
|
||||
* Native ESM `import()` ignores NODE_PATH — it resolves packages by walking
|
||||
* up the directory tree from the importing file. Extension files synced to
|
||||
* ~/.gsd/agent/extensions/ have no ancestor node_modules, so imports of
|
||||
* @gsd/* packages fail. The symlink makes Node's standard resolution find
|
||||
* them without requiring every call site to use jiti.
|
||||
*/
|
||||
function ensureNodeModulesSymlink(agentDir: string): void {
|
||||
const agentNodeModules = join(agentDir, 'node_modules')
|
||||
const gsdNodeModules = join(packageRoot, 'node_modules')
|
||||
|
||||
try {
|
||||
const existing = readlinkSync(agentNodeModules)
|
||||
if (existing === gsdNodeModules) return // already correct
|
||||
unlinkSync(agentNodeModules)
|
||||
} catch {
|
||||
// readlinkSync throws if path doesn't exist or isn't a symlink — both are fine
|
||||
}
|
||||
|
||||
try {
|
||||
symlinkSync(gsdNodeModules, agentNodeModules, 'junction')
|
||||
} catch {
|
||||
// Non-fatal — worst case, extensions fall back to NODE_PATH via jiti
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
|
||||
*
|
||||
|
|
@ -284,6 +313,11 @@ export function initResources(agentDir: string): void {
|
|||
// overwrite them (covers extensions, agents, and skills in one walk).
|
||||
makeTreeWritable(agentDir)
|
||||
|
||||
// Ensure ~/.gsd/agent/node_modules symlinks to GSD's node_modules so that
|
||||
// native ESM import() calls from synced extension files can resolve @gsd/*
|
||||
// packages via ancestor directory lookup. NODE_PATH only applies to CJS/jiti.
|
||||
ensureNodeModulesSymlink(agentDir)
|
||||
|
||||
writeManagedResourceManifest(agentDir)
|
||||
ensureRegistryEntries(join(agentDir, 'extensions'))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,6 +78,17 @@ export default function AsyncJobs(pi: ExtensionAPI) {
|
|||
});
|
||||
});
|
||||
|
||||
pi.on("session_before_switch", async () => {
|
||||
if (manager) {
|
||||
// Cancel all running background jobs — their results are no longer
|
||||
// relevant to the new session and would produce wasteful follow-up
|
||||
// notifications that trigger empty LLM turns (#1642).
|
||||
for (const job of manager.getRunningJobs()) {
|
||||
manager.cancel(job.id);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
pi.on("session_shutdown", async () => {
|
||||
if (manager) {
|
||||
manager.shutdown();
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
|
|||
codegen,
|
||||
actionCache,
|
||||
injectionDetection,
|
||||
verify,
|
||||
] = await Promise.all([
|
||||
importExtensionModule<typeof import("./lifecycle.js")>(import.meta.url, "./lifecycle.js"),
|
||||
importExtensionModule<typeof import("./capture.js")>(import.meta.url, "./capture.js"),
|
||||
|
|
@ -60,6 +61,7 @@ async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
|
|||
importExtensionModule<typeof import("./tools/codegen.js")>(import.meta.url, "./tools/codegen.js"),
|
||||
importExtensionModule<typeof import("./tools/action-cache.js")>(import.meta.url, "./tools/action-cache.js"),
|
||||
importExtensionModule<typeof import("./tools/injection-detect.js")>(import.meta.url, "./tools/injection-detect.js"),
|
||||
importExtensionModule<typeof import("./tools/verify.js")>(import.meta.url, "./tools/verify.js"),
|
||||
]);
|
||||
|
||||
const deps = {
|
||||
|
|
@ -132,6 +134,7 @@ async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
|
|||
codegen.registerCodegenTools(pi, deps);
|
||||
actionCache.registerActionCacheTools(pi, deps);
|
||||
injectionDetection.registerInjectionDetectionTools(pi, deps);
|
||||
verify.registerVerifyTools(pi, deps);
|
||||
})().catch((error) => {
|
||||
registrationPromise = null;
|
||||
throw error;
|
||||
|
|
|
|||
117
src/resources/extensions/browser-tools/tools/verify.ts
Normal file
117
src/resources/extensions/browser-tools/tools/verify.ts
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
import type { ExtensionAPI } from "@gsd/pi-coding-agent";
|
||||
import { Type } from "@sinclair/typebox";
|
||||
import type { ToolDeps } from "../state.js";
|
||||
|
||||
export function registerVerifyTools(pi: ExtensionAPI, deps: ToolDeps): void {
|
||||
pi.registerTool({
|
||||
name: "browser_verify",
|
||||
label: "Browser Verify",
|
||||
description:
|
||||
"Run a structured browser verification flow: navigate to a URL, run checks (element visibility, text content), capture screenshots as evidence, and return structured pass/fail results.",
|
||||
promptGuidelines: [
|
||||
"Use browser_verify for UAT verification flows that need structured evidence.",
|
||||
"Each check produces a pass/fail result with captured evidence.",
|
||||
"Prefer this over manual navigation + assertion sequences for verification tasks.",
|
||||
],
|
||||
parameters: Type.Object({
|
||||
url: Type.String({ description: "URL to navigate to" }),
|
||||
checks: Type.Array(
|
||||
Type.Object({
|
||||
description: Type.String({ description: "What this check verifies" }),
|
||||
selector: Type.Optional(Type.String({ description: "CSS selector to check" })),
|
||||
expectedText: Type.Optional(Type.String({ description: "Expected text content" })),
|
||||
expectedVisible: Type.Optional(Type.Boolean({ description: "Whether element should be visible" })),
|
||||
screenshot: Type.Optional(Type.Boolean({ description: "Capture screenshot as evidence" })),
|
||||
}),
|
||||
{ description: "Verification checks to run" },
|
||||
),
|
||||
timeout: Type.Optional(Type.Number({ description: "Navigation timeout in ms", default: 10000 })),
|
||||
}),
|
||||
async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
|
||||
const startTime = Date.now();
|
||||
const { page } = await deps.ensureBrowser();
|
||||
const timeout = params.timeout ?? 10000;
|
||||
|
||||
try {
|
||||
await page.goto(params.url, { waitUntil: "domcontentloaded", timeout });
|
||||
} catch (navErr) {
|
||||
const msg = navErr instanceof Error ? navErr.message : String(navErr);
|
||||
return {
|
||||
content: [{ type: "text" as const, text: `Navigation failed: ${msg}` }],
|
||||
details: {
|
||||
url: params.url,
|
||||
passed: false,
|
||||
checks: params.checks.map((c) => ({ description: c.description, passed: false, error: msg })),
|
||||
duration: Date.now() - startTime,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const results: Array<{
|
||||
description: string;
|
||||
passed: boolean;
|
||||
actual?: string;
|
||||
evidence?: string;
|
||||
error?: string;
|
||||
}> = [];
|
||||
|
||||
for (const check of params.checks) {
|
||||
try {
|
||||
let passed = true;
|
||||
let actual: string | undefined;
|
||||
let evidence: string | undefined;
|
||||
|
||||
if (check.selector) {
|
||||
const element = await page.$(check.selector);
|
||||
|
||||
if (check.expectedVisible !== undefined) {
|
||||
const isVisible = element ? await element.isVisible() : false;
|
||||
passed = isVisible === check.expectedVisible;
|
||||
actual = `visible=${isVisible}`;
|
||||
}
|
||||
|
||||
if (check.expectedText !== undefined && element) {
|
||||
const text = await element.textContent();
|
||||
passed = passed && (text?.includes(check.expectedText) ?? false);
|
||||
actual = `text="${text?.slice(0, 200)}"`;
|
||||
}
|
||||
|
||||
if (!element && (check.expectedVisible === true || check.expectedText)) {
|
||||
passed = false;
|
||||
actual = "element not found";
|
||||
}
|
||||
}
|
||||
|
||||
if (check.screenshot) {
|
||||
try {
|
||||
const buf = await page.screenshot({ type: "png" });
|
||||
evidence = `screenshot captured (${buf.length} bytes)`;
|
||||
} catch {
|
||||
evidence = "screenshot failed";
|
||||
}
|
||||
}
|
||||
|
||||
results.push({ description: check.description, passed, actual, evidence });
|
||||
} catch (checkErr) {
|
||||
results.push({
|
||||
description: check.description,
|
||||
passed: false,
|
||||
error: checkErr instanceof Error ? checkErr.message : String(checkErr),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const allPassed = results.every((r) => r.passed);
|
||||
const summary = results.map((r) => `${r.passed ? "PASS" : "FAIL"}: ${r.description}${r.actual ? ` (${r.actual})` : ""}${r.error ? ` — ${r.error}` : ""}`).join("\n");
|
||||
return {
|
||||
content: [{ type: "text" as const, text: `Verification ${allPassed ? "PASSED" : "FAILED"} (${results.filter(r => r.passed).length}/${results.length})\n\n${summary}` }],
|
||||
details: {
|
||||
url: params.url,
|
||||
passed: allPassed,
|
||||
checks: results,
|
||||
duration: Date.now() - startTime,
|
||||
},
|
||||
};
|
||||
},
|
||||
});
|
||||
}
|
||||
|
|
@ -10,9 +10,9 @@
|
|||
* session rotation). No queue — stale agent_end events are dropped.
|
||||
*/
|
||||
|
||||
import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
|
||||
import { importExtensionModule, type ExtensionAPI, type ExtensionContext } from "@gsd/pi-coding-agent";
|
||||
|
||||
import type { AutoSession } from "./auto/session.js";
|
||||
import type { AutoSession, SidecarItem } from "./auto/session.js";
|
||||
import { NEW_SESSION_TIMEOUT_MS } from "./auto/session.js";
|
||||
import type { GSDPreferences } from "./preferences.js";
|
||||
import type { SessionLockStatus } from "./session-lock.js";
|
||||
|
|
@ -287,6 +287,20 @@ export async function runUnit(
|
|||
status: result.status,
|
||||
});
|
||||
|
||||
// Discard trailing follow-up messages (e.g. async_job_result notifications)
|
||||
// from the completed unit. Without this, queued follow-ups trigger wasteful
|
||||
// LLM turns before the next session can start (#1642).
|
||||
// clearQueue() lives on AgentSession but isn't part of the typed
|
||||
// ExtensionCommandContext interface — call it via runtime check.
|
||||
try {
|
||||
const cmdCtxAny = s.cmdCtx as Record<string, unknown> | null;
|
||||
if (typeof cmdCtxAny?.clearQueue === "function") {
|
||||
(cmdCtxAny.clearQueue as () => unknown)();
|
||||
}
|
||||
} catch {
|
||||
// Non-fatal — clearQueue may not be available in all contexts
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -563,9 +577,9 @@ async function generateMilestoneReport(
|
|||
ctx: ExtensionContext,
|
||||
milestoneId: string,
|
||||
): Promise<void> {
|
||||
const { loadVisualizerData } = await import("./visualizer-data.js");
|
||||
const { generateHtmlReport } = await import("./export-html.js");
|
||||
const { writeReportSnapshot } = await import("./reports.js");
|
||||
const { loadVisualizerData } = await importExtensionModule<typeof import("./visualizer-data.js")>(import.meta.url, "./visualizer-data.js");
|
||||
const { generateHtmlReport } = await importExtensionModule<typeof import("./export-html.js")>(import.meta.url, "./export-html.js");
|
||||
const { writeReportSnapshot } = await importExtensionModule<typeof import("./reports.js")>(import.meta.url, "./reports.js");
|
||||
const { basename } = await import("node:path");
|
||||
|
||||
const snapData = await loadVisualizerData(s.basePath);
|
||||
|
|
@ -694,6 +708,18 @@ export async function autoLoop(
|
|||
// ── Blanket try/catch: one bad iteration must not kill the session
|
||||
const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
|
||||
|
||||
// ── Check sidecar queue before deriveState ──
|
||||
let sidecarItem: SidecarItem | undefined;
|
||||
if (s.sidecarQueue.length > 0) {
|
||||
sidecarItem = s.sidecarQueue.shift()!;
|
||||
debugLog("autoLoop", {
|
||||
phase: "sidecar-dequeue",
|
||||
kind: sidecarItem.kind,
|
||||
unitType: sidecarItem.unitType,
|
||||
unitId: sidecarItem.unitId,
|
||||
});
|
||||
}
|
||||
|
||||
const sessionLockBase = deps.lockBase();
|
||||
if (sessionLockBase) {
|
||||
const lockStatus = deps.validateSessionLock(sessionLockBase);
|
||||
|
|
@ -714,6 +740,17 @@ export async function autoLoop(
|
|||
}
|
||||
}
|
||||
|
||||
// Variables shared between the sidecar and normal paths
|
||||
let unitType: string;
|
||||
let unitId: string;
|
||||
let prompt: string;
|
||||
let pauseAfterUatDispatch = false;
|
||||
let state: GSDState;
|
||||
let mid: string | undefined;
|
||||
let midTitle: string | undefined;
|
||||
let observabilityIssues: unknown[] = [];
|
||||
|
||||
if (!sidecarItem) {
|
||||
// ── Phase 1: Pre-dispatch ───────────────────────────────────────────
|
||||
|
||||
// Resource version guard
|
||||
|
|
@ -764,10 +801,10 @@ export async function autoLoop(
|
|||
}
|
||||
|
||||
// Derive state
|
||||
let state = await deps.deriveState(s.basePath);
|
||||
state = await deps.deriveState(s.basePath);
|
||||
deps.syncCmuxSidebar(prefs, state);
|
||||
let mid = state.activeMilestone?.id;
|
||||
let midTitle = state.activeMilestone?.title;
|
||||
mid = state.activeMilestone?.id;
|
||||
midTitle = state.activeMilestone?.title;
|
||||
debugLog("autoLoop", {
|
||||
phase: "state-derived",
|
||||
iteration,
|
||||
|
|
@ -817,6 +854,25 @@ export async function autoLoop(
|
|||
|
||||
// Worktree lifecycle on milestone transition — merge current, enter next
|
||||
deps.resolver.mergeAndExit(s.currentMilestoneId!, ctx.ui);
|
||||
|
||||
// Opt-in: create draft PR on milestone completion
|
||||
if (prefs?.git?.auto_pr) {
|
||||
try {
|
||||
const { createDraftPR } = await import("./git-service.js");
|
||||
const prUrl = createDraftPR(
|
||||
s.basePath,
|
||||
s.currentMilestoneId!,
|
||||
`[GSD] ${s.currentMilestoneId} complete`,
|
||||
`Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`,
|
||||
);
|
||||
if (prUrl) {
|
||||
ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
|
||||
}
|
||||
} catch {
|
||||
// Non-fatal — PR creation is best-effort
|
||||
}
|
||||
}
|
||||
|
||||
deps.invalidateAllCaches();
|
||||
|
||||
state = await deps.deriveState(s.basePath);
|
||||
|
|
@ -870,6 +926,24 @@ export async function autoLoop(
|
|||
// All milestones complete — merge milestone branch before stopping
|
||||
if (s.currentMilestoneId) {
|
||||
deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
|
||||
|
||||
// Opt-in: create draft PR on milestone completion
|
||||
if (prefs?.git?.auto_pr) {
|
||||
try {
|
||||
const { createDraftPR } = await import("./git-service.js");
|
||||
const prUrl = createDraftPR(
|
||||
s.basePath,
|
||||
s.currentMilestoneId,
|
||||
`[GSD] ${s.currentMilestoneId} complete`,
|
||||
`Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`,
|
||||
);
|
||||
if (prUrl) {
|
||||
ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
|
||||
}
|
||||
} catch {
|
||||
// Non-fatal — PR creation is best-effort
|
||||
}
|
||||
}
|
||||
}
|
||||
deps.sendDesktopNotification(
|
||||
"GSD",
|
||||
|
|
@ -951,6 +1025,24 @@ export async function autoLoop(
|
|||
// Milestone merge on complete (before closeout so branch state is clean)
|
||||
if (s.currentMilestoneId) {
|
||||
deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
|
||||
|
||||
// Opt-in: create draft PR on milestone completion
|
||||
if (prefs?.git?.auto_pr) {
|
||||
try {
|
||||
const { createDraftPR } = await import("./git-service.js");
|
||||
const prUrl = createDraftPR(
|
||||
s.basePath,
|
||||
s.currentMilestoneId,
|
||||
`[GSD] ${s.currentMilestoneId} complete`,
|
||||
`Milestone ${s.currentMilestoneId} completed by GSD auto-mode.\n\nSee .gsd/${s.currentMilestoneId}/ for details.`,
|
||||
);
|
||||
if (prUrl) {
|
||||
ctx.ui.notify(`Draft PR created: ${prUrl}`, "info");
|
||||
}
|
||||
} catch {
|
||||
// Non-fatal — PR creation is best-effort
|
||||
}
|
||||
}
|
||||
}
|
||||
deps.sendDesktopNotification(
|
||||
"GSD",
|
||||
|
|
@ -1130,10 +1222,10 @@ export async function autoLoop(
|
|||
continue;
|
||||
}
|
||||
|
||||
let unitType = dispatchResult.unitType;
|
||||
let unitId = dispatchResult.unitId;
|
||||
let prompt = dispatchResult.prompt;
|
||||
const pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
|
||||
unitType = dispatchResult.unitType;
|
||||
unitId = dispatchResult.unitId;
|
||||
prompt = dispatchResult.prompt;
|
||||
pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
|
||||
|
||||
// ── Sliding-window stuck detection with graduated recovery ──
|
||||
const derivedKey = `${unitType}/${unitId}`;
|
||||
|
|
@ -1250,13 +1342,27 @@ export async function autoLoop(
|
|||
break;
|
||||
}
|
||||
|
||||
const observabilityIssues = await deps.collectObservabilityWarnings(
|
||||
observabilityIssues = await deps.collectObservabilityWarnings(
|
||||
ctx,
|
||||
s.basePath,
|
||||
unitType,
|
||||
unitId,
|
||||
);
|
||||
|
||||
// Derive state for shared use in execution phase
|
||||
// (state, mid, midTitle already set above)
|
||||
|
||||
} else {
|
||||
// ── Sidecar path: use values from the sidecar item directly ──
|
||||
unitType = sidecarItem.unitType;
|
||||
unitId = sidecarItem.unitId;
|
||||
prompt = sidecarItem.prompt;
|
||||
// Derive minimal state for progress widget / execution context
|
||||
state = await deps.deriveState(s.basePath);
|
||||
mid = state.activeMilestone?.id;
|
||||
midTitle = state.activeMilestone?.title;
|
||||
}
|
||||
|
||||
// ── Phase 4: Unit execution ─────────────────────────────────────────
|
||||
|
||||
debugLog("autoLoop", {
|
||||
|
|
@ -1344,7 +1450,7 @@ export async function autoLoop(
|
|||
s.lastBaselineCharCount = undefined;
|
||||
if (deps.isDbAvailable()) {
|
||||
try {
|
||||
const { inlineGsdRootFile } = await import("./auto-prompts.js");
|
||||
const { inlineGsdRootFile } = await importExtensionModule<typeof import("./auto-prompts.js")>(import.meta.url, "./auto-prompts.js");
|
||||
const [decisionsContent, requirementsContent, projectContent] =
|
||||
await Promise.all([
|
||||
inlineGsdRootFile(s.basePath, "decisions.md", "Decisions"),
|
||||
|
|
@ -1371,7 +1477,7 @@ export async function autoLoop(
|
|||
);
|
||||
}
|
||||
|
||||
// Select and apply model (with tier escalation on retry)
|
||||
// Select and apply model (with tier escalation on retry — normal units only)
|
||||
const modelResult = await deps.selectAndApplyModel(
|
||||
ctx,
|
||||
pi,
|
||||
|
|
@ -1381,7 +1487,7 @@ export async function autoLoop(
|
|||
prefs,
|
||||
s.verbose,
|
||||
s.autoModeStartModel,
|
||||
{ isRetry, previousTier },
|
||||
sidecarItem ? undefined : { isRetry, previousTier },
|
||||
);
|
||||
s.currentUnitRouting =
|
||||
modelResult.routing as AutoSession["currentUnitRouting"];
|
||||
|
|
@ -1532,7 +1638,13 @@ export async function autoLoop(
|
|||
};
|
||||
|
||||
// Pre-verification processing (commit, doctor, state rebuild, etc.)
|
||||
const preResult = await deps.postUnitPreVerification(postUnitCtx);
|
||||
// Sidecar items use lightweight pre-verification opts
|
||||
const preVerificationOpts: PreVerificationOpts | undefined = sidecarItem
|
||||
? sidecarItem.kind === "hook"
|
||||
? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
|
||||
: { skipSettleDelay: true, skipStateRebuild: true }
|
||||
: undefined;
|
||||
const preResult = await deps.postUnitPreVerification(postUnitCtx, preVerificationOpts);
|
||||
if (preResult === "dispatched") {
|
||||
debugLog("autoLoop", {
|
||||
phase: "exit",
|
||||
|
|
@ -1551,22 +1663,32 @@ export async function autoLoop(
|
|||
break;
|
||||
}
|
||||
|
||||
// Verification gate — the loop handles retries via s.pendingVerificationRetry
|
||||
const verificationResult = await deps.runPostUnitVerification(
|
||||
{ s, ctx, pi },
|
||||
deps.pauseAuto,
|
||||
);
|
||||
// Verification gate
|
||||
// Hook sidecar items skip verification entirely.
|
||||
// Non-hook sidecar items run verification but skip retries (just continue).
|
||||
const skipVerification = sidecarItem?.kind === "hook";
|
||||
if (!skipVerification) {
|
||||
const verificationResult = await deps.runPostUnitVerification(
|
||||
{ s, ctx, pi },
|
||||
deps.pauseAuto,
|
||||
);
|
||||
|
||||
if (verificationResult === "pause") {
|
||||
debugLog("autoLoop", { phase: "exit", reason: "verification-pause" });
|
||||
break;
|
||||
}
|
||||
if (verificationResult === "pause") {
|
||||
debugLog("autoLoop", { phase: "exit", reason: "verification-pause" });
|
||||
break;
|
||||
}
|
||||
|
||||
if (verificationResult === "retry") {
|
||||
// s.pendingVerificationRetry was set by runPostUnitVerification.
|
||||
// Continue the loop — next iteration will inject the retry context into the prompt.
|
||||
debugLog("autoLoop", { phase: "verification-retry", iteration });
|
||||
continue;
|
||||
if (verificationResult === "retry") {
|
||||
if (sidecarItem) {
|
||||
// Sidecar verification retries are skipped — just continue
|
||||
debugLog("autoLoop", { phase: "sidecar-verification-retry-skipped", iteration });
|
||||
} else {
|
||||
// s.pendingVerificationRetry was set by runPostUnitVerification.
|
||||
// Continue the loop — next iteration will inject the retry context into the prompt.
|
||||
debugLog("autoLoop", { phase: "verification-retry", iteration });
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Post-verification processing (DB dual-write, hooks, triage, quick-tasks)
|
||||
|
|
@ -1586,162 +1708,6 @@ export async function autoLoop(
|
|||
break;
|
||||
}
|
||||
|
||||
// ── Sidecar drain: dispatch enqueued hooks/triage/quick-tasks ──
|
||||
let sidecarBroke = false;
|
||||
while (s.sidecarQueue.length > 0 && s.active) {
|
||||
const item = s.sidecarQueue.shift()!;
|
||||
debugLog("autoLoop", {
|
||||
phase: "sidecar-dequeue",
|
||||
kind: item.kind,
|
||||
unitType: item.unitType,
|
||||
unitId: item.unitId,
|
||||
});
|
||||
|
||||
// Set up as current unit
|
||||
const sidecarStartedAt = Date.now();
|
||||
s.currentUnit = {
|
||||
type: item.unitType,
|
||||
id: item.unitId,
|
||||
startedAt: sidecarStartedAt,
|
||||
};
|
||||
deps.writeUnitRuntimeRecord(
|
||||
s.basePath,
|
||||
item.unitType,
|
||||
item.unitId,
|
||||
sidecarStartedAt,
|
||||
{
|
||||
phase: "dispatched",
|
||||
wrapupWarningSent: false,
|
||||
timeoutAt: null,
|
||||
lastProgressAt: sidecarStartedAt,
|
||||
progressCount: 0,
|
||||
lastProgressKind: "dispatch",
|
||||
},
|
||||
);
|
||||
|
||||
// Model selection (handles hook model override)
|
||||
await deps.selectAndApplyModel(
|
||||
ctx,
|
||||
pi,
|
||||
item.unitType,
|
||||
item.unitId,
|
||||
s.basePath,
|
||||
prefs,
|
||||
s.verbose,
|
||||
s.autoModeStartModel,
|
||||
);
|
||||
|
||||
// Supervision
|
||||
deps.clearUnitTimeout();
|
||||
deps.startUnitSupervision({
|
||||
s,
|
||||
ctx,
|
||||
pi,
|
||||
unitType: item.unitType,
|
||||
unitId: item.unitId,
|
||||
prefs,
|
||||
buildSnapshotOpts: () =>
|
||||
deps.buildSnapshotOpts(item.unitType, item.unitId),
|
||||
buildRecoveryContext: () => ({}),
|
||||
pauseAuto: deps.pauseAuto,
|
||||
});
|
||||
|
||||
// Write lock
|
||||
const sidecarSessionFile = deps.getSessionFile(ctx);
|
||||
deps.writeLock(
|
||||
deps.lockBase(),
|
||||
item.unitType,
|
||||
item.unitId,
|
||||
s.completedUnits.length,
|
||||
sidecarSessionFile,
|
||||
);
|
||||
|
||||
// Execute via standard runUnit
|
||||
const sidecarResult = await runUnit(
|
||||
ctx,
|
||||
pi,
|
||||
s,
|
||||
item.unitType,
|
||||
item.unitId,
|
||||
item.prompt,
|
||||
);
|
||||
deps.clearUnitTimeout();
|
||||
|
||||
if (sidecarResult.status === "cancelled") {
|
||||
ctx.ui.notify(
|
||||
`Sidecar unit ${item.unitType} ${item.unitId} session cancelled. Stopping.`,
|
||||
"warning",
|
||||
);
|
||||
await deps.stopAuto(ctx, pi, "Sidecar session creation failed");
|
||||
sidecarBroke = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// Immediate closeout for sidecar unit
|
||||
await deps.closeoutUnit(
|
||||
ctx,
|
||||
s.basePath,
|
||||
item.unitType,
|
||||
item.unitId,
|
||||
sidecarStartedAt,
|
||||
deps.buildSnapshotOpts(item.unitType, item.unitId),
|
||||
);
|
||||
|
||||
// Run pre-verification for the sidecar unit (lightweight path)
|
||||
const sidecarPreOpts: PreVerificationOpts = item.kind === "hook"
|
||||
? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
|
||||
: { skipSettleDelay: true, skipStateRebuild: true };
|
||||
const sidecarPreResult =
|
||||
await deps.postUnitPreVerification(postUnitCtx, sidecarPreOpts);
|
||||
if (sidecarPreResult === "dispatched") {
|
||||
// Pre-verification caused stop/pause
|
||||
debugLog("autoLoop", {
|
||||
phase: "exit",
|
||||
reason: "sidecar-pre-verification-stop",
|
||||
});
|
||||
sidecarBroke = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// Verification gate for non-hook sidecar units (triage, quick-tasks)
|
||||
// Hook units are lightweight and don't need verification.
|
||||
if (item.kind !== "hook") {
|
||||
const sidecarVerification = await deps.runPostUnitVerification(
|
||||
{ s, ctx, pi },
|
||||
deps.pauseAuto,
|
||||
);
|
||||
if (sidecarVerification === "pause") {
|
||||
debugLog("autoLoop", {
|
||||
phase: "exit",
|
||||
reason: "sidecar-verification-pause",
|
||||
});
|
||||
sidecarBroke = true;
|
||||
break;
|
||||
}
|
||||
// "retry" for sidecars — skip retry, just continue (sidecar retries are not worth the complexity)
|
||||
}
|
||||
|
||||
// Post-verification (may enqueue more sidecar items)
|
||||
const sidecarPostResult =
|
||||
await deps.postUnitPostVerification(postUnitCtx);
|
||||
if (sidecarPostResult === "stopped") {
|
||||
debugLog("autoLoop", { phase: "exit", reason: "sidecar-stopped" });
|
||||
sidecarBroke = true;
|
||||
break;
|
||||
}
|
||||
if (sidecarPostResult === "step-wizard") {
|
||||
debugLog("autoLoop", {
|
||||
phase: "exit",
|
||||
reason: "sidecar-step-wizard",
|
||||
});
|
||||
sidecarBroke = true;
|
||||
break;
|
||||
}
|
||||
// "continue" — loop checks sidecarQueue again
|
||||
}
|
||||
|
||||
if (sidecarBroke) break;
|
||||
|
||||
consecutiveErrors = 0; // Iteration completed successfully
|
||||
debugLog("autoLoop", { phase: "iteration-complete", iteration });
|
||||
} catch (loopErr) {
|
||||
|
|
|
|||
|
|
@ -172,13 +172,20 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
|
|||
ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
|
||||
}
|
||||
|
||||
// Proactive health tracking
|
||||
const summary = summarizeDoctorIssues(report.issues);
|
||||
// Proactive health tracking — filter to current milestone to avoid
|
||||
// cross-milestone stale errors inflating the escalation counter
|
||||
const currentMilestoneId = s.currentUnit.id.split("/")[0];
|
||||
const milestoneIssues = currentMilestoneId
|
||||
? report.issues.filter(i =>
|
||||
i.unitId === currentMilestoneId ||
|
||||
i.unitId.startsWith(`${currentMilestoneId}/`))
|
||||
: report.issues;
|
||||
const summary = summarizeDoctorIssues(milestoneIssues);
|
||||
recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
|
||||
|
||||
// Check if we should escalate to LLM-assisted heal
|
||||
if (summary.errors > 0) {
|
||||
const unresolvedErrors = report.issues
|
||||
const unresolvedErrors = milestoneIssues
|
||||
.filter(i => i.severity === "error" && !i.fixable)
|
||||
.map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
|
||||
const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
|
||||
|
|
|
|||
|
|
@ -6,19 +6,20 @@
|
|||
* utility.
|
||||
*/
|
||||
|
||||
import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection } from "./files.js";
|
||||
import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
|
||||
import type { Override, UatType } from "./files.js";
|
||||
import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
|
||||
import {
|
||||
resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
|
||||
resolveTasksDir, resolveTaskFiles, resolveTaskFile,
|
||||
relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
|
||||
resolveGsdRootFile, relGsdRootFile,
|
||||
resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile,
|
||||
} from "./paths.js";
|
||||
import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
|
||||
import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
|
||||
import type { GSDState, InlineLevel } from "./types.js";
|
||||
import type { GSDPreferences } from "./preferences.js";
|
||||
import { join } from "node:path";
|
||||
import { getLoadedSkills, type Skill } from "@gsd/pi-coding-agent";
|
||||
import { join, basename } from "node:path";
|
||||
import { existsSync } from "node:fs";
|
||||
import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
|
||||
import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
|
||||
|
|
@ -297,7 +298,171 @@ export async function inlineProjectFromDb(
|
|||
return inlineGsdRootFile(base, "project.md", "Project");
|
||||
}
|
||||
|
||||
// ─── Skill Discovery ──────────────────────────────────────────────────────
|
||||
// ─── Skill Activation & Discovery ─────────────────────────────────────────
|
||||
|
||||
function normalizeSkillReference(ref: string): string {
|
||||
const normalized = ref.replace(/\\/g, "/").trim();
|
||||
const base = basename(normalized).replace(/\.md$/i, "");
|
||||
const name = /^SKILL$/i.test(base)
|
||||
? basename(normalized.replace(/\/SKILL(?:\.md)?$/i, ""))
|
||||
: base;
|
||||
return name.trim().toLowerCase();
|
||||
}
|
||||
|
||||
function tokenizeSkillContext(...parts: Array<string | null | undefined>): Set<string> {
|
||||
const tokens = new Set<string>();
|
||||
const addVariants = (raw: string) => {
|
||||
const value = raw.trim().toLowerCase();
|
||||
if (!value || value.length < 2) return;
|
||||
tokens.add(value);
|
||||
tokens.add(value.replace(/[-_]+/g, " "));
|
||||
tokens.add(value.replace(/\s+/g, "-"));
|
||||
tokens.add(value.replace(/\s+/g, ""));
|
||||
};
|
||||
|
||||
for (const part of parts) {
|
||||
if (!part) continue;
|
||||
const text = part.toLowerCase();
|
||||
const phraseMatches = text.match(/[a-z0-9][a-z0-9+.#/_-]{1,}/g) ?? [];
|
||||
for (const match of phraseMatches) {
|
||||
addVariants(match);
|
||||
for (const piece of match.split(/[^a-z0-9+.#]+/g)) {
|
||||
if (piece.length >= 3) addVariants(piece);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return tokens;
|
||||
}
|
||||
|
||||
function skillMatchesContext(skill: Skill, contextTokens: Set<string>): boolean {
|
||||
const haystacks = [
|
||||
skill.name.toLowerCase(),
|
||||
skill.name.toLowerCase().replace(/[-_]+/g, " "),
|
||||
skill.description.toLowerCase(),
|
||||
];
|
||||
|
||||
return [...contextTokens].some(token =>
|
||||
token.length >= 3 && haystacks.some(haystack => haystack.includes(token)),
|
||||
);
|
||||
}
|
||||
|
||||
function resolvePreferenceSkillNames(refs: string[], base: string): string[] {
|
||||
if (refs.length === 0) return [];
|
||||
const prefs: GSDPreferences = { always_use_skills: refs };
|
||||
const report = resolveAllSkillReferences(prefs, base);
|
||||
return refs.map(ref => {
|
||||
const resolution = report.resolutions.get(ref);
|
||||
return normalizeSkillReference(resolution?.resolvedPath ?? ref);
|
||||
}).filter(Boolean);
|
||||
}
|
||||
|
||||
function ruleMatchesContext(when: string, contextTokens: Set<string>): boolean {
|
||||
const whenTokens = tokenizeSkillContext(when);
|
||||
return [...whenTokens].some(token =>
|
||||
contextTokens.has(token) || [...contextTokens].some(ctx => ctx.includes(token) || token.includes(ctx)),
|
||||
);
|
||||
}
|
||||
|
||||
function resolveSkillRuleMatches(
|
||||
prefs: GSDPreferences | undefined,
|
||||
contextTokens: Set<string>,
|
||||
base: string,
|
||||
): { include: string[]; avoid: string[] } {
|
||||
if (!prefs?.skill_rules?.length) return { include: [], avoid: [] };
|
||||
|
||||
const include: string[] = [];
|
||||
const avoid: string[] = [];
|
||||
for (const rule of prefs.skill_rules) {
|
||||
if (!ruleMatchesContext(rule.when, contextTokens)) continue;
|
||||
include.push(...resolvePreferenceSkillNames([...(rule.use ?? []), ...(rule.prefer ?? [])], base));
|
||||
avoid.push(...resolvePreferenceSkillNames(rule.avoid ?? [], base));
|
||||
}
|
||||
return { include, avoid };
|
||||
}
|
||||
|
||||
function resolvePreferredSkillNames(
|
||||
prefs: GSDPreferences | undefined,
|
||||
visibleSkills: Skill[],
|
||||
contextTokens: Set<string>,
|
||||
base: string,
|
||||
): string[] {
|
||||
if (!prefs?.prefer_skills?.length) return [];
|
||||
const preferred = new Set(resolvePreferenceSkillNames(prefs.prefer_skills, base));
|
||||
return visibleSkills
|
||||
.filter(skill => preferred.has(normalizeSkillReference(skill.name)) && skillMatchesContext(skill, contextTokens))
|
||||
.map(skill => normalizeSkillReference(skill.name));
|
||||
}
|
||||
|
||||
function formatSkillActivationBlock(skillNames: string[]): string {
|
||||
if (skillNames.length === 0) return "";
|
||||
const calls = skillNames.map(name => `Call Skill('${name}')`).join('. ');
|
||||
return `<skill_activation>${calls}.</skill_activation>`;
|
||||
}
|
||||
|
||||
export function buildSkillActivationBlock(params: {
|
||||
base: string;
|
||||
milestoneId: string;
|
||||
milestoneTitle?: string;
|
||||
sliceId?: string;
|
||||
sliceTitle?: string;
|
||||
taskId?: string;
|
||||
taskTitle?: string;
|
||||
extraContext?: string[];
|
||||
taskPlanContent?: string | null;
|
||||
preferences?: GSDPreferences;
|
||||
}): string {
|
||||
const prefs = params.preferences ?? loadEffectiveGSDPreferences()?.preferences;
|
||||
const contextTokens = tokenizeSkillContext(
|
||||
params.milestoneId,
|
||||
params.milestoneTitle,
|
||||
params.sliceId,
|
||||
params.sliceTitle,
|
||||
params.taskId,
|
||||
params.taskTitle,
|
||||
...(params.extraContext ?? []),
|
||||
params.taskPlanContent ?? undefined,
|
||||
);
|
||||
|
||||
const visibleSkills = getLoadedSkills().filter(skill => !skill.disableModelInvocation);
|
||||
const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
|
||||
const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
|
||||
const matched = new Set<string>();
|
||||
|
||||
for (const name of resolvePreferenceSkillNames(prefs?.always_use_skills ?? [], params.base)) {
|
||||
matched.add(name);
|
||||
}
|
||||
|
||||
const ruleMatches = resolveSkillRuleMatches(prefs, contextTokens, params.base);
|
||||
for (const name of ruleMatches.include) matched.add(name);
|
||||
for (const name of ruleMatches.avoid) avoided.add(name);
|
||||
|
||||
for (const name of resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, params.base)) {
|
||||
matched.add(name);
|
||||
}
|
||||
|
||||
if (params.taskPlanContent) {
|
||||
try {
|
||||
const taskPlan = parseTaskPlanFile(params.taskPlanContent);
|
||||
for (const skillName of taskPlan.frontmatter.skills_used) {
|
||||
matched.add(normalizeSkillReference(skillName));
|
||||
}
|
||||
} catch {
|
||||
// Non-fatal — malformed task plan should not break prompt construction
|
||||
}
|
||||
}
|
||||
|
||||
for (const skill of visibleSkills) {
|
||||
if (skillMatchesContext(skill, contextTokens)) {
|
||||
matched.add(normalizeSkillReference(skill.name));
|
||||
}
|
||||
}
|
||||
|
||||
const ordered = [...matched]
|
||||
.filter(name => installedNames.has(name) && !avoided.has(name))
|
||||
.sort();
|
||||
return formatSkillActivationBlock(ordered);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the skill discovery template variables for research prompts.
|
||||
|
|
@ -628,6 +793,12 @@ export async function buildResearchMilestonePrompt(mid: string, midTitle: string
|
|||
contextPath: contextRel,
|
||||
outputPath: join(base, outputRelPath),
|
||||
inlinedContext,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
milestoneTitle: midTitle,
|
||||
extraContext: [inlinedContext],
|
||||
}),
|
||||
...buildSkillDiscoveryVars(),
|
||||
});
|
||||
}
|
||||
|
|
@ -684,6 +855,12 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
|
|||
secretsOutputPath,
|
||||
inlinedContext,
|
||||
sourceFilePaths: buildSourceFilePaths(base, mid),
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
milestoneTitle: midTitle,
|
||||
extraContext: [inlinedContext],
|
||||
}),
|
||||
...buildSkillDiscoveryVars(),
|
||||
});
|
||||
}
|
||||
|
|
@ -730,6 +907,13 @@ export async function buildResearchSlicePrompt(
|
|||
outputPath: join(base, outputRelPath),
|
||||
inlinedContext,
|
||||
dependencySummaries: depContent,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
sliceId: sid,
|
||||
sliceTitle: sTitle,
|
||||
extraContext: [inlinedContext, depContent],
|
||||
}),
|
||||
...buildSkillDiscoveryVars(),
|
||||
});
|
||||
}
|
||||
|
|
@ -788,6 +972,13 @@ export async function buildPlanSlicePrompt(
|
|||
sourceFilePaths: buildSourceFilePaths(base, mid, sid),
|
||||
executorContextConstraints,
|
||||
commitInstruction,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
sliceId: sid,
|
||||
sliceTitle: sTitle,
|
||||
extraContext: [inlinedContext, depContent],
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -891,8 +1082,16 @@ export async function buildExecuteTaskPrompt(
|
|||
finalCarryForward = truncateAtSectionBoundary(carryForwardSection, carryForwardBudget).content;
|
||||
}
|
||||
|
||||
// Inline RUNTIME.md if present
|
||||
const runtimePath = resolveRuntimeFile(base);
|
||||
const runtimeContent = existsSync(runtimePath) ? await loadFile(runtimePath) : null;
|
||||
const runtimeContext = runtimeContent
|
||||
? `### Runtime Context\nSource: \`.gsd/RUNTIME.md\`\n\n${runtimeContent.trim()}`
|
||||
: "";
|
||||
|
||||
return loadPrompt("execute-task", {
|
||||
overridesSection,
|
||||
runtimeContext,
|
||||
workingDirectory: base,
|
||||
milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
|
||||
planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),
|
||||
|
|
@ -906,6 +1105,16 @@ export async function buildExecuteTaskPrompt(
|
|||
taskSummaryPath,
|
||||
inlinedTemplates,
|
||||
verificationBudget,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
sliceId: sid,
|
||||
sliceTitle: sTitle,
|
||||
taskId: tid,
|
||||
taskTitle: tTitle,
|
||||
taskPlanContent,
|
||||
extraContext: [taskPlanInline, slicePlanExcerpt, finalCarryForward, resumeSection],
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -1164,6 +1373,14 @@ export async function buildReplanSlicePrompt(
|
|||
inlinedContext,
|
||||
replanPath,
|
||||
captureContext,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: mid,
|
||||
milestoneTitle: midTitle,
|
||||
sliceId: sid,
|
||||
sliceTitle: sTitle,
|
||||
extraContext: [inlinedContext, captureContext],
|
||||
}),
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
* One command, one wizard. Routes to smart entry or status.
|
||||
*/
|
||||
|
||||
import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
|
||||
import { importExtensionModule, type ExtensionAPI, type ExtensionCommandContext } from "@gsd/pi-coding-agent";
|
||||
import type { GSDState } from "./types.js";
|
||||
import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
|
||||
import { homedir } from "node:os";
|
||||
|
|
@ -585,7 +585,7 @@ export async function handleGSDCommand(
|
|||
}
|
||||
|
||||
if (trimmed === "widget" || trimmed.startsWith("widget ")) {
|
||||
const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("./auto-dashboard.js");
|
||||
const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await importExtensionModule<typeof import("./auto-dashboard.js")>(import.meta.url, "./auto-dashboard.js");
|
||||
const arg = trimmed.replace(/^widget\s*/, "").trim();
|
||||
if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
|
||||
setWidgetMode(arg);
|
||||
|
|
|
|||
|
|
@ -128,6 +128,10 @@ interface KeyLookup {
|
|||
function resolveKey(providerId: string): KeyLookup {
|
||||
const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
|
||||
|
||||
if (providerId === "anthropic-vertex" && process.env.ANTHROPIC_VERTEX_PROJECT_ID) {
|
||||
return { found: true, source: "env", backedOff: false };
|
||||
}
|
||||
|
||||
// Check auth.json
|
||||
const authPath = getAuthPath();
|
||||
if (existsSync(authPath)) {
|
||||
|
|
|
|||
|
|
@ -297,7 +297,7 @@ async function markSliceUndoneInRoadmap(basePath: string, milestoneId: string, s
|
|||
|
||||
function matchesScope(unitId: string, scope?: string): boolean {
|
||||
if (!scope) return true;
|
||||
return unitId === scope || unitId.startsWith(`${scope}/`) || unitId.startsWith(`${scope}`);
|
||||
return unitId === scope || unitId.startsWith(`${scope}/`);
|
||||
}
|
||||
|
||||
function auditRequirements(content: string | null): DoctorIssue[] {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
|
||||
import { importExtensionModule, type ExtensionAPI, type ExtensionCommandContext } from "@gsd/pi-coding-agent";
|
||||
|
||||
type StopAutoFn = (ctx: ExtensionCommandContext, pi: ExtensionAPI, reason?: string) => Promise<void>;
|
||||
|
||||
|
|
@ -10,7 +10,7 @@ export function registerExitCommand(
|
|||
description: "Exit GSD gracefully",
|
||||
handler: async (_args: string, ctx: ExtensionCommandContext) => {
|
||||
// Stop auto-mode first so locks and activity state are cleaned up before shutdown.
|
||||
const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
|
||||
const stopAuto = deps.stopAuto ?? (await importExtensionModule<typeof import("./auto.js")>(import.meta.url, "./auto.js")).stopAuto;
|
||||
await stopAuto(ctx, pi, "Graceful exit");
|
||||
ctx.shutdown();
|
||||
},
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import { milestoneIdSort, findMilestoneIds } from './milestone-ids.js';
|
|||
|
||||
import type {
|
||||
Roadmap, BoundaryMapEntry,
|
||||
SlicePlan, TaskPlanEntry,
|
||||
SlicePlan, TaskPlanEntry, TaskPlanFile, TaskPlanFrontmatter,
|
||||
Summary, SummaryFrontmatter, SummaryRequires, FileModified,
|
||||
Continue, ContinueFrontmatter, ContinueStatus,
|
||||
RequirementCounts,
|
||||
|
|
@ -277,14 +277,52 @@ export function formatSecretsManifest(manifest: SecretsManifest): string {
|
|||
|
||||
// ─── Slice Plan Parser ─────────────────────────────────────────────────────
|
||||
|
||||
function normalizeTaskPlanFrontmatter(frontmatter: Record<string, unknown>): TaskPlanFrontmatter {
|
||||
const estimatedStepsRaw = frontmatter.estimated_steps;
|
||||
const estimatedFilesRaw = frontmatter.estimated_files;
|
||||
const skillsUsedRaw = frontmatter.skills_used;
|
||||
|
||||
const parseOptionalNumber = (value: unknown): number | undefined => {
|
||||
if (typeof value === 'number' && Number.isFinite(value)) return value;
|
||||
if (typeof value === 'string' && value.trim()) {
|
||||
const parsed = parseInt(value, 10);
|
||||
if (Number.isFinite(parsed)) return parsed;
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
const estimated_steps = parseOptionalNumber(estimatedStepsRaw);
|
||||
const estimated_files = parseOptionalNumber(estimatedFilesRaw);
|
||||
const skills_used = Array.isArray(skillsUsedRaw)
|
||||
? skillsUsedRaw.map(v => String(v).trim()).filter(Boolean)
|
||||
: typeof skillsUsedRaw === 'string' && skillsUsedRaw.trim()
|
||||
? [skillsUsedRaw.trim()]
|
||||
: [];
|
||||
|
||||
return {
|
||||
...(estimated_steps !== undefined ? { estimated_steps } : {}),
|
||||
...(estimated_files !== undefined ? { estimated_files } : {}),
|
||||
skills_used,
|
||||
};
|
||||
}
|
||||
|
||||
export function parseTaskPlanFile(content: string): TaskPlanFile {
|
||||
const [fmLines] = splitFrontmatter(content);
|
||||
const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
|
||||
return {
|
||||
frontmatter: normalizeTaskPlanFrontmatter(fm),
|
||||
};
|
||||
}
|
||||
|
||||
export function parsePlan(content: string): SlicePlan {
|
||||
return cachedParse(content, 'plan', _parsePlanImpl);
|
||||
}
|
||||
|
||||
function _parsePlanImpl(content: string): SlicePlan {
|
||||
const stopTimer = debugTime("parse-plan");
|
||||
const [, body] = splitFrontmatter(content);
|
||||
// Try native parser first for better performance
|
||||
const nativeResult = nativeParsePlanFile(content);
|
||||
const nativeResult = nativeParsePlanFile(body);
|
||||
if (nativeResult) {
|
||||
stopTimer({ native: true });
|
||||
return {
|
||||
|
|
@ -306,7 +344,7 @@ function _parsePlanImpl(content: string): SlicePlan {
|
|||
};
|
||||
}
|
||||
|
||||
const lines = content.split('\n');
|
||||
const lines = body.split('\n');
|
||||
|
||||
const h1 = lines.find(l => l.startsWith('# '));
|
||||
let id = '';
|
||||
|
|
@ -321,13 +359,13 @@ function _parsePlanImpl(content: string): SlicePlan {
|
|||
}
|
||||
}
|
||||
|
||||
const goal = extractBoldField(content, 'Goal') || '';
|
||||
const demo = extractBoldField(content, 'Demo') || '';
|
||||
const goal = extractBoldField(body, 'Goal') || '';
|
||||
const demo = extractBoldField(body, 'Demo') || '';
|
||||
|
||||
const mhSection = extractSection(content, 'Must-Haves');
|
||||
const mhSection = extractSection(body, 'Must-Haves');
|
||||
const mustHaves = mhSection ? parseBullets(mhSection) : [];
|
||||
|
||||
const tasksSection = extractSection(content, 'Tasks');
|
||||
const tasksSection = extractSection(body, 'Tasks');
|
||||
const tasks: TaskPlanEntry[] = [];
|
||||
|
||||
if (tasksSection) {
|
||||
|
|
@ -375,7 +413,7 @@ function _parsePlanImpl(content: string): SlicePlan {
|
|||
if (currentTask) tasks.push(currentTask);
|
||||
}
|
||||
|
||||
const filesSection = extractSection(content, 'Files Likely Touched');
|
||||
const filesSection = extractSection(body, 'Files Likely Touched');
|
||||
const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];
|
||||
|
||||
const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };
|
||||
|
|
|
|||
|
|
@ -584,6 +584,30 @@ export class GitServiceImpl {
|
|||
|
||||
}
|
||||
|
||||
// ─── Draft PR Creation ─────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Create a draft pull request for a completed milestone using `gh pr create`.
|
||||
* Returns the PR URL on success, or null on failure.
|
||||
* Non-fatal: callers should treat failure as best-effort.
|
||||
*/
|
||||
export function createDraftPR(
|
||||
basePath: string,
|
||||
milestoneId: string,
|
||||
title: string,
|
||||
body: string,
|
||||
): string | null {
|
||||
try {
|
||||
const result = execSync(
|
||||
`gh pr create --draft --title ${JSON.stringify(title)} --body ${JSON.stringify(body)}`,
|
||||
{ cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV },
|
||||
);
|
||||
return result.trim();
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Factory ───────────────────────────────────────────────────────────────
|
||||
|
||||
/** Create a GitServiceImpl with the current effective git preferences. */
|
||||
|
|
|
|||
|
|
@ -7,9 +7,11 @@
|
|||
*/
|
||||
|
||||
import { join } from "node:path";
|
||||
import { execFileSync } from "node:child_process";
|
||||
import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
|
||||
import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
|
||||
import { gsdRoot } from "./paths.js";
|
||||
import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
|
||||
|
||||
/**
|
||||
* GSD runtime patterns for git index cleanup.
|
||||
|
|
@ -104,10 +106,22 @@ export function hasGitTrackedGsdFiles(basePath: string): boolean {
|
|||
// Check if git tracks any files under .gsd/
|
||||
try {
|
||||
const tracked = nativeLsFiles(basePath, ".gsd");
|
||||
return tracked.length > 0;
|
||||
} catch {
|
||||
// Not a git repo or git not available — safe to proceed
|
||||
if (tracked.length > 0) return true;
|
||||
|
||||
// nativeLsFiles swallows git failures and returns []. An empty result
|
||||
// could mean "nothing tracked" OR "git failed silently". Verify git is
|
||||
// reachable before trusting the empty result — if it isn't, fail safe
|
||||
// by assuming files ARE tracked to prevent data loss.
|
||||
execFileSync("git", ["rev-parse", "--git-dir"], {
|
||||
cwd: basePath,
|
||||
stdio: "pipe",
|
||||
env: GIT_NO_PROMPT_ENV,
|
||||
});
|
||||
|
||||
return false;
|
||||
} catch {
|
||||
// git unavailable, index locked, or repo corrupt — fail safe
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@g
|
|||
import { showNextAction } from "../shared/mod.js";
|
||||
import { loadFile, parseRoadmap } from "./files.js";
|
||||
import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
|
||||
import { buildSkillActivationBlock } from "./auto-prompts.js";
|
||||
import { deriveState } from "./state.js";
|
||||
import { invalidateAllCaches } from "./cache.js";
|
||||
import { startAuto } from "./auto.js";
|
||||
|
|
@ -1124,7 +1125,16 @@ export async function showSmartEntry(
|
|||
].join("\n\n---\n\n");
|
||||
const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
|
||||
milestoneId, milestoneTitle, secretsOutputPath, inlinedTemplates: planMilestoneTemplates,
|
||||
milestoneId,
|
||||
milestoneTitle,
|
||||
secretsOutputPath,
|
||||
inlinedTemplates: planMilestoneTemplates,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
milestoneTitle,
|
||||
extraContext: [planMilestoneTemplates],
|
||||
}),
|
||||
}), "gsd-run", ctx, "plan-milestone");
|
||||
} else if (choice === "discuss") {
|
||||
const discussMilestoneTemplates = inlineTemplate("context", "Context");
|
||||
|
|
@ -1254,14 +1264,34 @@ export async function showSmartEntry(
|
|||
inlineTemplate("task-plan", "Task Plan"),
|
||||
].join("\n\n---\n\n");
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
|
||||
milestoneId, sliceId, sliceTitle, inlinedTemplates: planSliceTemplates,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
inlinedTemplates: planSliceTemplates,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
extraContext: [planSliceTemplates],
|
||||
}),
|
||||
}), "gsd-run", ctx, "plan-slice");
|
||||
} else if (choice === "discuss") {
|
||||
await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }), "gsd-run", ctx, "plan-slice");
|
||||
} else if (choice === "research") {
|
||||
const researchTemplates = inlineTemplate("research", "Research");
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
|
||||
milestoneId, sliceId, sliceTitle, inlinedTemplates: researchTemplates,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
inlinedTemplates: researchTemplates,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
extraContext: [researchTemplates],
|
||||
}),
|
||||
}), "gsd-run", ctx, "research-slice");
|
||||
} else if (choice === "status") {
|
||||
const { fireStatusViaCommand } = await import("./commands.js");
|
||||
|
|
@ -1305,7 +1335,18 @@ export async function showSmartEntry(
|
|||
inlineTemplate("uat", "UAT"),
|
||||
].join("\n\n---\n\n");
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
|
||||
workingDirectory: basePath, milestoneId, sliceId, sliceTitle, inlinedTemplates: completeSliceTemplates,
|
||||
workingDirectory: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
inlinedTemplates: completeSliceTemplates,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
sliceTitle,
|
||||
extraContext: [completeSliceTemplates],
|
||||
}),
|
||||
}), "gsd-run", ctx, "complete-slice");
|
||||
} else if (choice === "status") {
|
||||
const { fireStatusViaCommand } = await import("./commands.js");
|
||||
|
|
@ -1370,12 +1411,32 @@ export async function showSmartEntry(
|
|||
if (choice === "execute") {
|
||||
if (hasInterrupted) {
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
|
||||
milestoneId, sliceId,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
taskId,
|
||||
taskTitle,
|
||||
}),
|
||||
}), "gsd-run", ctx, "execute-task");
|
||||
} else {
|
||||
const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
|
||||
await dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
|
||||
milestoneId, sliceId, taskId, taskTitle, inlinedTemplates: executeTaskTemplates,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
taskId,
|
||||
taskTitle,
|
||||
inlinedTemplates: executeTaskTemplates,
|
||||
skillActivation: buildSkillActivationBlock({
|
||||
base: basePath,
|
||||
milestoneId,
|
||||
sliceId,
|
||||
taskId,
|
||||
taskTitle,
|
||||
extraContext: [executeTaskTemplates],
|
||||
}),
|
||||
}), "gsd-run", ctx, "execute-task");
|
||||
}
|
||||
} else if (choice === "status") {
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ export function initHealthWidget(ctx: ExtensionContext): void {
|
|||
const basePath = projectRoot();
|
||||
|
||||
// String-array fallback — used in RPC mode (factory is a no-op there)
|
||||
const initialData = loadBaseHealthWidgetData(basePath);
|
||||
const initialData = loadHealthWidgetData(basePath);
|
||||
ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
|
||||
|
||||
// Factory-based widget for TUI mode — replaces the string-array above
|
||||
|
|
@ -95,8 +95,7 @@ export function initHealthWidget(ctx: ExtensionContext): void {
|
|||
if (refreshInFlight) return;
|
||||
refreshInFlight = true;
|
||||
try {
|
||||
const baseData = loadBaseHealthWidgetData(basePath);
|
||||
data = await enrichHealthWidgetData(basePath, baseData);
|
||||
data = loadHealthWidgetData(basePath);
|
||||
cachedLines = undefined;
|
||||
_tui.requestRender();
|
||||
} catch { /* non-fatal */ } finally {
|
||||
|
|
|
|||
|
|
@ -6,11 +6,13 @@
|
|||
* symlink replaces the original directory so all paths remain valid.
|
||||
*/
|
||||
|
||||
import { execFileSync } from "node:child_process";
|
||||
import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
import { externalGsdRoot } from "./repo-identity.js";
|
||||
import { getErrorMessage } from "./error-utils.js";
|
||||
import { hasGitTrackedGsdFiles } from "./gitignore.js";
|
||||
import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
|
||||
|
||||
export interface MigrationResult {
|
||||
migrated: boolean;
|
||||
|
|
@ -144,7 +146,22 @@ export function migrateToExternalState(basePath: string): MigrationResult {
|
|||
return { migrated: false, error: `Migration verification failed: ${getErrorMessage(verifyErr)}` };
|
||||
}
|
||||
|
||||
// Remove .gsd.migrating only after symlink is verified
|
||||
// Clean the git index — any .gsd/* files tracked before migration now
|
||||
// sit behind the symlink and git can't follow it, causing them to show
|
||||
// as deleted. Remove them from the index so the working tree stays clean.
|
||||
// --ignore-unmatch makes this a no-op on fresh projects with no tracked .gsd/.
|
||||
try {
|
||||
execFileSync("git", ["rm", "-r", "--cached", "--ignore-unmatch", ".gsd"], {
|
||||
cwd: basePath,
|
||||
stdio: ["ignore", "pipe", "ignore"],
|
||||
env: GIT_NO_PROMPT_ENV,
|
||||
timeout: 10_000,
|
||||
});
|
||||
} catch {
|
||||
// Non-fatal — git may be unavailable or nothing was tracked
|
||||
}
|
||||
|
||||
// Remove .gsd.migrating only after symlink is verified and index is clean
|
||||
rmSync(migratingPath, { recursive: true, force: true });
|
||||
|
||||
return { migrated: true };
|
||||
|
|
|
|||
|
|
@ -356,6 +356,10 @@ export function milestonesDir(basePath: string): string {
|
|||
return join(gsdRoot(basePath), "milestones");
|
||||
}
|
||||
|
||||
export function resolveRuntimeFile(basePath: string): string {
|
||||
return join(gsdRoot(basePath), "RUNTIME.md");
|
||||
}
|
||||
|
||||
export function resolveGsdRootFile(basePath: string, key: GSDRootFileKey): string {
|
||||
const root = gsdRoot(basePath);
|
||||
const canonical = join(root, GSD_ROOT_FILES[key]);
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ import { existsSync, readFileSync } from "node:fs";
|
|||
import { homedir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
import { gsdRoot } from "./paths.js";
|
||||
import { parse as parseYaml } from "yaml";
|
||||
import type { PostUnitHookConfig, PreDispatchHookConfig, TokenProfile } from "./types.js";
|
||||
|
|
@ -83,24 +82,36 @@ export {
|
|||
|
||||
// ─── Path Constants & Getters ───────────────────────────────────────────────
|
||||
|
||||
const GLOBAL_PREFERENCES_PATH = join(gsdHome, "preferences.md");
|
||||
const LEGACY_GLOBAL_PREFERENCES_PATH = join(homedir(), ".pi", "agent", "gsd-preferences.md");
|
||||
function gsdHome(): string {
|
||||
return process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
}
|
||||
|
||||
function globalPreferencesPath(): string {
|
||||
return join(gsdHome(), "preferences.md");
|
||||
}
|
||||
|
||||
function legacyGlobalPreferencesPath(): string {
|
||||
return join(homedir(), ".pi", "agent", "gsd-preferences.md");
|
||||
}
|
||||
|
||||
function projectPreferencesPath(): string {
|
||||
return join(gsdRoot(process.cwd()), "preferences.md");
|
||||
}
|
||||
// Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
|
||||
// Check uppercase as a fallback so those files aren't silently ignored.
|
||||
const GLOBAL_PREFERENCES_PATH_UPPERCASE = join(gsdHome, "PREFERENCES.md");
|
||||
function globalPreferencesPathUppercase(): string {
|
||||
return join(gsdHome(), "PREFERENCES.md");
|
||||
}
|
||||
function projectPreferencesPathUppercase(): string {
|
||||
return join(gsdRoot(process.cwd()), "PREFERENCES.md");
|
||||
}
|
||||
|
||||
export function getGlobalGSDPreferencesPath(): string {
|
||||
return GLOBAL_PREFERENCES_PATH;
|
||||
return globalPreferencesPath();
|
||||
}
|
||||
|
||||
export function getLegacyGlobalGSDPreferencesPath(): string {
|
||||
return LEGACY_GLOBAL_PREFERENCES_PATH;
|
||||
return legacyGlobalPreferencesPath();
|
||||
}
|
||||
|
||||
export function getProjectGSDPreferencesPath(): string {
|
||||
|
|
@ -110,9 +121,9 @@ export function getProjectGSDPreferencesPath(): string {
|
|||
// ─── Loading ────────────────────────────────────────────────────────────────
|
||||
|
||||
export function loadGlobalGSDPreferences(): LoadedGSDPreferences | null {
|
||||
return loadPreferencesFile(GLOBAL_PREFERENCES_PATH, "global")
|
||||
?? loadPreferencesFile(GLOBAL_PREFERENCES_PATH_UPPERCASE, "global")
|
||||
?? loadPreferencesFile(LEGACY_GLOBAL_PREFERENCES_PATH, "global");
|
||||
return loadPreferencesFile(globalPreferencesPath(), "global")
|
||||
?? loadPreferencesFile(globalPreferencesPathUppercase(), "global")
|
||||
?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
|
||||
}
|
||||
|
||||
export function loadProjectGSDPreferences(): LoadedGSDPreferences | null {
|
||||
|
|
|
|||
|
|
@ -78,6 +78,11 @@ export function loadPrompt(name: string, vars: Record<string, string> = {}): str
|
|||
templateCache.set(name, content);
|
||||
}
|
||||
|
||||
const effectiveVars = {
|
||||
skillActivation: "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.",
|
||||
...vars,
|
||||
};
|
||||
|
||||
// Check BEFORE substitution: find all {{varName}} placeholders the template
|
||||
// declares and verify every one has a value in vars. Checking after substitution
|
||||
// would also flag {{...}} patterns injected by inlined content (e.g. template
|
||||
|
|
@ -86,7 +91,7 @@ export function loadPrompt(name: string, vars: Record<string, string> = {}): str
|
|||
if (declared) {
|
||||
const missing = [...new Set(declared)]
|
||||
.map(m => m.slice(2, -2))
|
||||
.filter(key => !(key in vars));
|
||||
.filter(key => !(key in effectiveVars));
|
||||
if (missing.length > 0) {
|
||||
throw new GSDError(
|
||||
GSD_PARSE_ERROR,
|
||||
|
|
@ -97,7 +102,7 @@ export function loadPrompt(name: string, vars: Record<string, string> = {}): str
|
|||
}
|
||||
}
|
||||
|
||||
for (const [key, value] of Object.entries(vars)) {
|
||||
for (const [key, value] of Object.entries(effectiveVars)) {
|
||||
content = content.replaceAll(`{{${key}}}`, value);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ All relevant context has been preloaded below — the roadmap, all slice summari
|
|||
|
||||
Then:
|
||||
1. Use the **Milestone Summary** output template from the inlined context above
|
||||
2. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during completion, without relaxing required verification or artifact rules
|
||||
2. {{skillActivation}}
|
||||
3. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. List any criterion that was NOT met.
|
||||
4. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly.
|
||||
5. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ All relevant context has been preloaded below — the slice plan, all task summa
|
|||
|
||||
Then:
|
||||
1. Use the **Slice Summary** and **UAT** output templates from the inlined context above
|
||||
2. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during completion, without relaxing required verification or artifact rules
|
||||
2. {{skillActivation}}
|
||||
3. Run all slice-level verification checks defined in the slice plan. All must pass before marking the slice done. If any fail, fix them first.
|
||||
4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
|
||||
5. If `.gsd/REQUIREMENTS.md` exists, update it based on what this slice actually proved. Move requirements between Active, Validated, Deferred, Blocked, or Out of Scope only when the evidence from execution supports that change.
|
||||
|
|
|
|||
|
|
@ -10,6 +10,8 @@ A researcher explored the codebase and a planner decomposed the work — you are
|
|||
|
||||
{{overridesSection}}
|
||||
|
||||
{{runtimeContext}}
|
||||
|
||||
{{resumeSection}}
|
||||
|
||||
{{carryForwardSection}}
|
||||
|
|
@ -26,7 +28,7 @@ A researcher explored the codebase and a planner decomposed the work — you are
|
|||
|
||||
Then:
|
||||
0. Narrate step transitions, key implementation decisions, and verification outcomes as you work. Keep it terse — one line between tool-call clusters, not between every call — but write complete sentences in user-facing prose, not shorthand notes or scratchpad fragments.
|
||||
1. **Load relevant skills before writing code.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. For each skill that matches this task's technology stack (e.g., React, Next.js, accessibility, component design), `read` its SKILL.md file now. Skills contain implementation rules and patterns that should guide your code. If no skills match this task, skip this step.
|
||||
1. {{skillActivation}} Follow any activated skills before writing code. If no skills match this task, skip this step.
|
||||
2. Execute the steps in the inlined task plan, adapting minor local mismatches when the surrounding code differs from the planner's snapshot
|
||||
3. Build the real thing. If the task plan says "create login endpoint", build an endpoint that actually authenticates against a real store, not one that returns a hardcoded success response. If the task plan says "create dashboard page", build a page that renders real data from the API, not a component with hardcoded props. Stubs and mocks are for tests, not for the shipped feature.
|
||||
4. Write or update tests as part of execution — tests are verification, not an afterthought. If the slice plan defines test files in its Verification section and this is the first task, create them (they should initially fail).
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
Complete slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Your working directory is `{{workingDirectory}}` — all file operations must use this path. All tasks are done. Your slice summary is the primary record of what was built — downstream agents (reassess-roadmap, future slice researchers) read it to understand what this slice delivered and what to watch out for. Use the **Slice Summary** and **UAT** output templates below. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during completion, without relaxing required verification or artifact rules. Write `{{sliceId}}-SUMMARY.md` (compress task summaries), write `{{sliceId}}-UAT.md`, and fill the `UAT Type` plus `Not Proven By This UAT` sections explicitly so the artifact states what class of acceptance it covers and what still remains unproven. Review task summaries for `key_decisions` and ensure any significant ones are in `.gsd/DECISIONS.md`. Mark the slice checkbox done in the roadmap, update milestone summary, Do not commit or merge manually — the system handles this after the unit completes.
|
||||
Complete slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Your working directory is `{{workingDirectory}}` — all file operations must use this path. All tasks are done. Your slice summary is the primary record of what was built — downstream agents (reassess-roadmap, future slice researchers) read it to understand what this slice delivered and what to watch out for. Use the **Slice Summary** and **UAT** output templates below. {{skillActivation}} Write `{{sliceId}}-SUMMARY.md` (compress task summaries), write `{{sliceId}}-UAT.md`, and fill the `UAT Type` plus `Not Proven By This UAT` sections explicitly so the artifact states what class of acceptance it covers and what still remains unproven. Review task summaries for `key_decisions` and ensure any significant ones are in `.gsd/DECISIONS.md`. Mark the slice checkbox done in the roadmap, update milestone summary, Do not commit or merge manually — the system handles this after the unit completes.
|
||||
|
||||
{{inlinedTemplates}}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
Execute the next task: {{taskId}} ("{{taskTitle}}") in slice {{sliceId}} of milestone {{milestoneId}}. Read the task plan (`{{taskId}}-PLAN.md`), load relevant summaries from prior tasks, and execute each step. Verify must-haves when done. If the task touches UI, browser flows, DOM behavior, or user-visible web state, exercise the real flow in the browser, prefer `browser_batch` for obvious sequences, prefer `browser_assert` for explicit pass/fail verification, use `browser_diff` when an action's effect is ambiguous, and use browser diagnostics when validating async or failure-prone UI. If you made an architectural, pattern, or library decision, append it to `.gsd/DECISIONS.md`. Use the **Task Summary** output template below. Write `{{taskId}}-SUMMARY.md`, mark it done, commit, and advance. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during execution, without relaxing required verification or artifact rules. If running long and not all steps are finished, stop implementing and prioritize writing a clean partial summary over attempting one more step — a recoverable handoff is more valuable than a half-finished step with no documentation. If verification fails, debug methodically: form a hypothesis and test that specific theory before changing anything, change one variable at a time, read entire functions not just the suspect line, distinguish observable facts from assumptions, and if 3+ fixes fail without progress stop and reassess your mental model — list what you know for certain, what you've ruled out, and form fresh hypotheses. Don't fix symptoms — understand why something fails before changing code.
|
||||
Execute the next task: {{taskId}} ("{{taskTitle}}") in slice {{sliceId}} of milestone {{milestoneId}}. Read the task plan (`{{taskId}}-PLAN.md`), load relevant summaries from prior tasks, and execute each step. Verify must-haves when done. If the task touches UI, browser flows, DOM behavior, or user-visible web state, exercise the real flow in the browser, prefer `browser_batch` for obvious sequences, prefer `browser_assert` for explicit pass/fail verification, use `browser_diff` when an action's effect is ambiguous, and use browser diagnostics when validating async or failure-prone UI. If you made an architectural, pattern, or library decision, append it to `.gsd/DECISIONS.md`. Use the **Task Summary** output template below. Write `{{taskId}}-SUMMARY.md`, mark it done, commit, and advance. {{skillActivation}} If running long and not all steps are finished, stop implementing and prioritize writing a clean partial summary over attempting one more step — a recoverable handoff is more valuable than a half-finished step with no documentation. If verification fails, debug methodically: form a hypothesis and test that specific theory before changing anything, change one variable at a time, read entire functions not just the suspect line, distinguish observable facts from assumptions, and if 3+ fixes fail without progress stop and reassess your mental model — list what you know for certain, what you've ruled out, and form fresh hypotheses. Don't fix symptoms — understand why something fails before changing code.
|
||||
|
||||
{{inlinedTemplates}}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists and treat Active requirements as the capability contract. If `REQUIREMENTS.md` is missing, continue in legacy compatibility mode but explicitly note missing requirement coverage. Use the **Roadmap** output template below. Create `{{milestoneId}}-ROADMAP.md` in the milestone directory with slices, risk levels, dependencies, demo sentences, verification classes, milestone definition of done, requirement coverage, and a boundary map. Write success criteria as observable truths, not implementation tasks. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during planning, without overriding required roadmap formatting.
|
||||
Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists and treat Active requirements as the capability contract. If `REQUIREMENTS.md` is missing, continue in legacy compatibility mode but explicitly note missing requirement coverage. Use the **Roadmap** output template below. Create `{{milestoneId}}-ROADMAP.md` in the milestone directory with slices, risk levels, dependencies, demo sentences, verification classes, milestone definition of done, requirement coverage, and a boundary map. Write success criteria as observable truths, not implementation tasks. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. {{skillActivation}}
|
||||
|
||||
## Requirement Rules
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
Plan slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements the roadmap says this slice owns or supports, and ensure the plan delivers them. Read the roadmap boundary map, any existing context/research files, and dependency summaries. Use the **Slice Plan** and **Task Plan** output templates below. Decompose into tasks with must-haves. Fill the `Proof Level` and `Integration Closure` sections truthfully so the plan says what class of proof this slice really delivers and what end-to-end wiring still remains. Write `{{sliceId}}-PLAN.md` and individual `T##-PLAN.md` files in the `tasks/` subdirectory. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during planning, without overriding required plan formatting. Before committing, self-audit the plan: every must-have maps to at least one task, every task has complete sections (steps, must-haves, verification, observability impact, inputs, and expected output), task ordering is consistent with no circular references, every pair of artifacts that must connect has an explicit wiring step, task scope targets 2–5 steps and 3–8 files (6–8 steps or 8–10 files — consider splitting; 10+ steps or 12+ files — must split), the plan honors locked decisions from context/research/decisions artifacts, the proof-level wording does not overclaim live integration if only fixture/contract proof is planned, every Active requirement this slice owns has at least one task with verification that proves it is met, and every task produces real user-facing progress — if the slice has a UI surface at least one task builds the real UI, if it has an API at least one task connects it to a real data source, and showing the completed result to a non-technical stakeholder would demonstrate real product progress rather than developer artifacts.
|
||||
Plan slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements the roadmap says this slice owns or supports, and ensure the plan delivers them. Read the roadmap boundary map, any existing context/research files, and dependency summaries. Use the **Slice Plan** and **Task Plan** output templates below. Decompose into tasks with must-haves. Fill the `Proof Level` and `Integration Closure` sections truthfully so the plan says what class of proof this slice really delivers and what end-to-end wiring still remains. Write `{{sliceId}}-PLAN.md` and individual `T##-PLAN.md` files in the `tasks/` subdirectory. If planning produces structural decisions, append them to `.gsd/DECISIONS.md`. {{skillActivation}} Before committing, self-audit the plan: every must-have maps to at least one task, every task has complete sections (steps, must-haves, verification, observability impact, inputs, and expected output), task ordering is consistent with no circular references, every pair of artifacts that must connect has an explicit wiring step, task scope targets 2–5 steps and 3–8 files (6–8 steps or 8–10 files — consider splitting; 10+ steps or 12+ files — must split), the plan honors locked decisions from context/research/decisions artifacts, the proof-level wording does not overclaim live integration if only fixture/contract proof is planned, every Active requirement this slice owns has at least one task with verification that proves it is met, and every task produces real user-facing progress — if the slice has a UI surface at least one task builds the real UI, if it has an API at least one task connects it to a real data source, and showing the completed result to a non-technical stakeholder would demonstrate real product progress rather than developer artifacts.
|
||||
|
||||
{{inlinedTemplates}}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
Research slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions, don't contradict them. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements this slice owns or supports and target research toward risks, unknowns, and constraints that could affect delivery of those requirements. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during research, without relaxing required verification or artifact rules. Explore the relevant code — use `rg`/`find` for targeted reads, or `scout` if the area is broad or unfamiliar. Check libraries with `resolve_library`/`get_library_docs` — skip this for libraries already used in the codebase. Use the **Research** output template below. Write `{{sliceId}}-RESEARCH.md` in the slice directory.
|
||||
Research slice {{sliceId}} ("{{sliceTitle}}") of milestone {{milestoneId}}. Read `.gsd/DECISIONS.md` if it exists — respect existing decisions, don't contradict them. Read `.gsd/REQUIREMENTS.md` if it exists — identify which Active requirements this slice owns or supports and target research toward risks, unknowns, and constraints that could affect delivery of those requirements. {{skillActivation}} Explore the relevant code — use `rg`/`find` for targeted reads, or `scout` if the area is broad or unfamiliar. Check libraries with `resolve_library`/`get_library_docs` — skip this for libraries already used in the codebase. Use the **Research** output template below. Write `{{sliceId}}-RESEARCH.md` in the slice directory.
|
||||
|
||||
**You are the scout.** A planner agent reads your output in a fresh context to decompose this slice into tasks. Write for the planner — surface key files, where the work divides naturally, what to build first, and how to verify. If the research doc is vague, the planner re-explores code you already read. If it's precise, the planner decomposes immediately.
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Resume interrupted work. Find the continue file (`{{sliceId}}-CONTINUE.md` or `continue.md`) in slice {{sliceId}} of milestone {{milestoneId}}, read it, and use it as the recovery contract for where to pick up. Do **not** delete the continue file immediately. Keep it until the task is successfully completed or you have written a newer summary/continue artifact that clearly supersedes it. If the resumed attempt fails again, update or replace the continue file so no recovery context is lost. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during execution, without relaxing required verification or artifact rules.
|
||||
Resume interrupted work. Find the continue file (`{{sliceId}}-CONTINUE.md` or `continue.md`) in slice {{sliceId}} of milestone {{milestoneId}}, read it, and use it as the recovery contract for where to pick up. Do **not** delete the continue file immediately. Keep it until the task is successfully completed or you have written a newer summary/continue artifact that clearly supersedes it. If the resumed attempt fails again, update or replace the continue file so no recovery context is lost. {{skillActivation}}
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ Narrate your decomposition reasoning — why you're grouping work this way, what
|
|||
|
||||
Then:
|
||||
1. Use the **Roadmap** output template from the inlined context above
|
||||
2. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during planning, without overriding required roadmap formatting
|
||||
2. {{skillActivation}}
|
||||
3. Create the roadmap: decompose into demoable vertical slices — as many as the work genuinely needs, no more. A simple feature might be 1 slice. Don't decompose for decomposition's sake.
|
||||
4. Order by risk (high-risk first)
|
||||
5. Write `{{outputPath}}` with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, **requirement coverage**, and a boundary map. Write success criteria as observable truths, not implementation tasks. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ Then:
|
|||
1. Read the templates:
|
||||
- `~/.gsd/agent/extensions/gsd/templates/plan.md`
|
||||
- `~/.gsd/agent/extensions/gsd/templates/task-plan.md`
|
||||
2. **Load relevant skills.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. `read` any skill files relevant to this slice's technology stack before decomposing. When writing task plans, note which installed skills are relevant in the task description so executors know which to load.
|
||||
2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
|
||||
3. Define slice-level verification — the objective stopping condition for this slice:
|
||||
- For non-trivial slices: plan actual test files with real assertions. Name the files.
|
||||
- For simple slices: executable commands or script assertions are fine.
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ The following user thoughts were captured during execution and deferred to futur
|
|||
|
||||
{{deferredCaptures}}
|
||||
|
||||
If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during reassessment, without relaxing required verification or artifact rules.
|
||||
{{skillActivation}}
|
||||
|
||||
Then assess whether the remaining roadmap still makes sense given what was just built.
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ Write for the roadmap planner. It needs to understand: what exists in the codeba
|
|||
A milestone adding a small feature to an established codebase needs targeted research — check the relevant code, confirm the approach, note constraints. A milestone introducing new technology, building a new system, or spanning multiple unfamiliar subsystems needs deep research — explore broadly, look up docs, investigate alternatives. Match your effort to the actual uncertainty, not the template's section count. Include only sections that have real content.
|
||||
|
||||
Then research the codebase and relevant technologies. Narrate key findings and surprises as you go — what exists, what's missing, what constrains the approach.
|
||||
1. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during research, without relaxing required verification or artifact rules
|
||||
1. {{skillActivation}}
|
||||
2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
|
||||
3. Explore relevant code. For small/familiar codebases, use `rg`, `find`, and targeted reads. For large or unfamiliar codebases, use `scout` to build a broad map efficiently before diving in.
|
||||
4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ An honest "this is straightforward, here's the pattern to follow" is more valuab
|
|||
|
||||
Research what this slice needs. Narrate key findings and surprises as you go — what exists, what's missing, what constrains the approach.
|
||||
0. If `REQUIREMENTS.md` was preloaded above, identify which Active requirements this slice owns or supports. Research should target these requirements — surfacing risks, unknowns, and implementation constraints that could affect whether the slice actually delivers them.
|
||||
1. **Load relevant skills.** Check the `GSD Skill Preferences` block in system context and the `<available_skills>` catalog in your system prompt. `read` any skill files relevant to this slice's technology stack before exploring code. Reference specific rules from loaded skills in your findings where they inform the implementation approach.
|
||||
1. {{skillActivation}} Reference specific rules from loaded skills in your findings where they inform the implementation approach.
|
||||
2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
|
||||
3. Explore relevant code for this slice's scope. For targeted exploration, use `rg`, `find`, and reads. For broad or unfamiliar subsystems, use `scout` to map the relevant area first.
|
||||
4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ All relevant context has been preloaded below. Start working immediately without
|
|||
|
||||
{{inlinedContext}}
|
||||
|
||||
If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow during UAT execution, without relaxing required verification or artifact rules.
|
||||
{{skillActivation}}
|
||||
|
||||
---
|
||||
|
||||
|
|
|
|||
|
|
@ -126,7 +126,12 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
|
|||
// A draft milestone is still "active" — this function only determines which milestone is current.
|
||||
}
|
||||
const roadmap = parseRoadmap(content);
|
||||
if (!isMilestoneComplete(roadmap)) return mid;
|
||||
if (!isMilestoneComplete(roadmap)) {
|
||||
// Summary is the terminal artifact — if it exists, the milestone is
|
||||
// complete even when roadmap checkboxes weren't ticked (#864).
|
||||
const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
|
||||
if (!summaryFile) return mid;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
|
@ -258,7 +263,13 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
|
|||
}
|
||||
const rmap = parseRoadmap(rc);
|
||||
roadmapCache.set(mid, rmap);
|
||||
if (!isMilestoneComplete(rmap)) continue;
|
||||
if (!isMilestoneComplete(rmap)) {
|
||||
// Summary is the terminal artifact — if it exists, the milestone is
|
||||
// complete even when roadmap checkboxes weren't ticked (#864).
|
||||
const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
|
||||
if (sf) completeMilestoneIds.add(mid);
|
||||
continue;
|
||||
}
|
||||
const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
|
||||
if (sf) completeMilestoneIds.add(mid);
|
||||
}
|
||||
|
|
@ -357,26 +368,33 @@ async function _deriveStateImpl(basePath: string): Promise<GSDState> {
|
|||
} else {
|
||||
registry.push({ id: mid, title, status: 'complete' });
|
||||
}
|
||||
} else if (!activeMilestoneFound) {
|
||||
// Check milestone-level dependencies before promoting to active
|
||||
const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
|
||||
const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
|
||||
const deps = parseContextDependsOn(contextContent);
|
||||
const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
|
||||
if (depsUnmet) {
|
||||
registry.push({ id: mid, title, status: 'pending', dependsOn: deps });
|
||||
// Do NOT set activeMilestoneFound — let the loop continue to the next milestone
|
||||
} else {
|
||||
activeMilestone = { id: mid, title };
|
||||
activeRoadmap = roadmap;
|
||||
activeMilestoneFound = true;
|
||||
registry.push({ id: mid, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
|
||||
}
|
||||
} else {
|
||||
const contextFile2 = resolveMilestoneFile(basePath, mid, "CONTEXT");
|
||||
const contextContent2 = contextFile2 ? await cachedLoadFile(contextFile2) : null;
|
||||
const deps2 = parseContextDependsOn(contextContent2);
|
||||
registry.push({ id: mid, title, status: 'pending', ...(deps2.length > 0 ? { dependsOn: deps2 } : {}) });
|
||||
// Roadmap slices not all checked — but if a summary exists, the milestone
|
||||
// is still complete. The summary is the terminal artifact (#864).
|
||||
const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
|
||||
if (summaryFile) {
|
||||
registry.push({ id: mid, title, status: 'complete' });
|
||||
} else if (!activeMilestoneFound) {
|
||||
// Check milestone-level dependencies before promoting to active
|
||||
const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
|
||||
const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
|
||||
const deps = parseContextDependsOn(contextContent);
|
||||
const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
|
||||
if (depsUnmet) {
|
||||
registry.push({ id: mid, title, status: 'pending', dependsOn: deps });
|
||||
// Do NOT set activeMilestoneFound — let the loop continue to the next milestone
|
||||
} else {
|
||||
activeMilestone = { id: mid, title };
|
||||
activeRoadmap = roadmap;
|
||||
activeMilestoneFound = true;
|
||||
registry.push({ id: mid, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
|
||||
}
|
||||
} else {
|
||||
const contextFile2 = resolveMilestoneFile(basePath, mid, "CONTEXT");
|
||||
const contextContent2 = contextFile2 ? await cachedLoadFile(contextFile2) : null;
|
||||
const deps2 = parseContextDependsOn(contextContent2);
|
||||
registry.push({ id: mid, title, status: 'pending', ...(deps2.length > 0 ? { dependsOn: deps2 } : {}) });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
21
src/resources/extensions/gsd/templates/runtime.md
Normal file
21
src/resources/extensions/gsd/templates/runtime.md
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
# Runtime Context
|
||||
|
||||
## Stack
|
||||
- **Language:** (e.g., TypeScript, Python, Go)
|
||||
- **Framework:** (e.g., Next.js, FastAPI, Gin)
|
||||
- **Build:** (e.g., npm run build, cargo build)
|
||||
- **Test:** (e.g., npm run test, pytest)
|
||||
- **Lint:** (e.g., npm run lint, ruff check)
|
||||
|
||||
## Environment
|
||||
- **Node version:** (e.g., 20.x)
|
||||
- **Package manager:** (e.g., npm, pnpm, yarn)
|
||||
- **Required env vars:** (list any needed for local dev)
|
||||
|
||||
## Dev Server
|
||||
- **Start command:** (e.g., npm run dev)
|
||||
- **Default port:** (e.g., 3000)
|
||||
- **Health check:** (e.g., curl http://localhost:3000/health)
|
||||
|
||||
## Notes
|
||||
(Any runtime-specific context the executor needs to know)
|
||||
|
|
@ -3,6 +3,9 @@
|
|||
# Tasks with 10+ estimated steps or 12+ estimated files trigger a warning to consider splitting.
|
||||
estimated_steps: {{estimatedSteps}}
|
||||
estimated_files: {{estimatedFiles}}
|
||||
# Installed skills the planner expects the executor to load before coding.
|
||||
skills_used:
|
||||
- {{skillName}}
|
||||
---
|
||||
|
||||
# {{taskId}}: {{taskTitle}}
|
||||
|
|
|
|||
|
|
@ -242,9 +242,10 @@ async function main(): Promise<void> {
|
|||
const remoteLog = run("git log --oneline main", bareDir);
|
||||
assertTrue(remoteLog.includes("feat(M040)"), "milestone commit reachable on remote after manual push");
|
||||
|
||||
// result.pushed will be false since prefs aren't loadable in temp repos
|
||||
// (module-level const limitation) — that's expected
|
||||
assertEq(result.pushed, false, "pushed is false without discoverable prefs");
|
||||
// Temp-repo prefs may or may not be discoverable depending on process cwd and
|
||||
// current preference-loading behavior. The important contract is that remote
|
||||
// push mechanics work and the returned value reflects what happened.
|
||||
assertTrue(typeof result.pushed === "boolean", "pushed flag remains boolean");
|
||||
}
|
||||
|
||||
// ─── Test 5: Auto-resolve .gsd/ state file conflicts (#530) ───────
|
||||
|
|
|
|||
|
|
@ -779,6 +779,49 @@ slice: S01
|
|||
}
|
||||
}
|
||||
|
||||
// ─── Test: unchecked roadmap slices + summary → complete (summary is terminal) ────
|
||||
console.log('\n=== unchecked roadmap slices + summary → complete (summary is terminal) ===');
|
||||
{
|
||||
const base = createFixtureBase();
|
||||
try {
|
||||
// M001: roadmap has unchecked slices but a summary exists — should be complete
|
||||
writeRoadmap(base, 'M001', `# M001: First Milestone\n\n**Vision:** Already done.\n\n## Slices\n\n- [ ] **S01: Unchecked slice** \`risk:low\` \`depends:[]\`\n > Work was done but checkbox never ticked.\n- [ ] **S02: Another unchecked** \`risk:low\` \`depends:[]\`\n > Same.\n`);
|
||||
writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: First Milestone\n\n**Completed despite unchecked roadmap.**');
|
||||
// M002: genuinely incomplete — should be the active milestone
|
||||
writeRoadmap(base, 'M002', `# M002: Active Milestone\n\n**Vision:** Do stuff.\n\n## Slices\n\n- [ ] **S01: Work slice** \`risk:low\` \`depends:[]\`\n > Needs work.\n`);
|
||||
|
||||
const state = await deriveState(base);
|
||||
const m001Entry = state.registry.find(e => e.id === 'M001');
|
||||
assertEq(m001Entry?.status, 'complete', 'M001 with unchecked roadmap + summary is complete');
|
||||
assertEq(state.activeMilestone?.id, 'M002', 'active milestone is M002, not M001');
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Test: unchecked roadmap + summary counts toward completeMilestoneIds (deps) ────
|
||||
console.log('\n=== unchecked roadmap + summary satisfies dependency ===');
|
||||
{
|
||||
const base = createFixtureBase();
|
||||
try {
|
||||
// M001: unchecked roadmap + summary → complete
|
||||
writeRoadmap(base, 'M001', `# M001: Foundation\n\n**Vision:** Done.\n\n## Slices\n\n- [ ] **S01: Setup** \`risk:low\` \`depends:[]\`\n > Done.\n`);
|
||||
writeMilestoneSummary(base, 'M001', '---\nid: M001\n---\n\n# M001: Foundation\n\n**Done.**');
|
||||
// M002: depends on M001 — should be active since M001 is complete
|
||||
writeRoadmap(base, 'M002', `# M002: Dependent\n\n**Vision:** Depends on M001.\n\n## Slices\n\n- [ ] **S01: Work** \`risk:low\` \`depends:[]\`\n > Work.\n`);
|
||||
const contextDir = join(base, '.gsd', 'milestones', 'M002');
|
||||
mkdirSync(contextDir, { recursive: true });
|
||||
writeFileSync(join(contextDir, 'M002-CONTEXT.md'), '---\ndepends_on:\n - M001\n---\n\n# M002 Context\n\nDepends on M001.');
|
||||
|
||||
const state = await deriveState(base);
|
||||
assertEq(state.activeMilestone?.id, 'M002', 'M002 is active — M001 dependency satisfied via summary');
|
||||
const m002Entry = state.registry.find(e => e.id === 'M002');
|
||||
assertEq(m002Entry?.status, 'active', 'M002 status is active, not pending');
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
}
|
||||
|
||||
report();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -183,6 +183,28 @@ test("ensureGitignore with tracked .gsd/ does not cause git to see files as dele
|
|||
}
|
||||
});
|
||||
|
||||
test("hasGitTrackedGsdFiles returns true (fail-safe) when git is not available", () => {
|
||||
const dir = makeTempRepo();
|
||||
try {
|
||||
// Create and track .gsd/ files
|
||||
mkdirSync(join(dir, ".gsd"), { recursive: true });
|
||||
writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Project\n");
|
||||
git(dir, "add", ".gsd/");
|
||||
git(dir, "commit", "-m", "track gsd");
|
||||
|
||||
// Corrupt the git index to simulate git failure
|
||||
const indexPath = join(dir, ".git", "index.lock");
|
||||
writeFileSync(indexPath, "locked");
|
||||
|
||||
// Should fail safe — assume tracked rather than silently returning false
|
||||
// (The index lock causes git ls-files to fail; rev-parse also fails → true)
|
||||
const result = hasGitTrackedGsdFiles(dir);
|
||||
assert.equal(result, true, "Should return true (fail-safe) when git is unavailable");
|
||||
} finally {
|
||||
cleanup(dir);
|
||||
}
|
||||
});
|
||||
|
||||
// ─── migrateToExternalState — tracked .gsd/ protection ──────────────
|
||||
|
||||
test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", () => {
|
||||
|
|
@ -212,3 +234,31 @@ test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", () =>
|
|||
cleanup(dir);
|
||||
}
|
||||
});
|
||||
|
||||
test("migrateToExternalState cleans git index so tracked files don't show as deleted (#1364 path 2)", () => {
|
||||
const dir = makeTempRepo();
|
||||
try {
|
||||
// Track .gsd/ files, then untrack them so migration proceeds
|
||||
mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
|
||||
writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Project\n");
|
||||
writeFileSync(join(dir, ".gsd", "milestones", "M001", "PLAN.md"), "# Plan\n");
|
||||
git(dir, "add", ".gsd/");
|
||||
git(dir, "commit", "-m", "track gsd state");
|
||||
git(dir, "rm", "-r", "--cached", ".gsd/");
|
||||
git(dir, "commit", "-m", "untrack gsd (simulates pre-migration project)");
|
||||
|
||||
const result = migrateToExternalState(dir);
|
||||
assert.equal(result.migrated, true, "Migration should succeed");
|
||||
|
||||
// git status must show NO deleted files after migration
|
||||
const status = git(dir, "status", "--porcelain");
|
||||
const deletions = status.split("\n").filter((l) => /^\s*D\s/.test(l) || /^D\s/.test(l));
|
||||
assert.equal(
|
||||
deletions.length,
|
||||
0,
|
||||
`Expected no deleted files after migration, but found:\n${deletions.join("\n")}`,
|
||||
);
|
||||
} finally {
|
||||
cleanup(dir);
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
import { parseRoadmap, parsePlan, parseSummary, parseContinue, parseRequirementCounts, parseSecretsManifest, formatSecretsManifest } from '../files.ts';
|
||||
import { parseRoadmap, parsePlan, parseTaskPlanFile, parseSummary, parseContinue, parseRequirementCounts, parseSecretsManifest, formatSecretsManifest } from '../files.ts';
|
||||
import { createTestContext } from './test-helpers.ts';
|
||||
|
||||
const { assertEq, assertTrue, report } = createTestContext();
|
||||
|
|
@ -241,7 +241,15 @@ console.log('\n=== parseRoadmap: missing risk defaults to low ===');
|
|||
|
||||
console.log('\n=== parsePlan: full plan ===');
|
||||
{
|
||||
const content = `# S01: Parser Test Suite
|
||||
const content = `---
|
||||
estimated_steps: 6
|
||||
estimated_files: 3
|
||||
skills_used:
|
||||
- typescript
|
||||
- testing
|
||||
---
|
||||
|
||||
# S01: Parser Test Suite
|
||||
|
||||
**Goal:** All 5 parsers have test coverage with edge cases.
|
||||
**Demo:** \`node --test tests/parsers.test.ts\` passes with zero failures.
|
||||
|
|
@ -267,6 +275,13 @@ console.log('\n=== parsePlan: full plan ===');
|
|||
- \`files.ts\` — update parseSummary
|
||||
`;
|
||||
|
||||
const taskPlan = parseTaskPlanFile(content);
|
||||
assertEq(taskPlan.frontmatter.estimated_steps, 6, 'task plan frontmatter estimated_steps');
|
||||
assertEq(taskPlan.frontmatter.estimated_files, 3, 'task plan frontmatter estimated_files');
|
||||
assertEq(taskPlan.frontmatter.skills_used.length, 2, 'task plan frontmatter skills_used count');
|
||||
assertEq(taskPlan.frontmatter.skills_used[0], 'typescript', 'first task plan skill');
|
||||
assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second task plan skill');
|
||||
|
||||
const p = parsePlan(content);
|
||||
|
||||
assertEq(p.id, 'S01', 'plan id');
|
||||
|
|
@ -295,6 +310,97 @@ console.log('\n=== parsePlan: full plan ===');
|
|||
assertTrue(p.filesLikelyTouched[0].includes('tests/parsers.test.ts'), 'first file');
|
||||
}
|
||||
|
||||
console.log('\n=== parseTaskPlanFile: defaults missing frontmatter fields ===');
|
||||
{
|
||||
const content = `# T01: Minimal task plan
|
||||
|
||||
## Description
|
||||
|
||||
No frontmatter here.
|
||||
`;
|
||||
|
||||
const taskPlan = parseTaskPlanFile(content);
|
||||
assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'estimated_steps defaults undefined');
|
||||
assertEq(taskPlan.frontmatter.estimated_files, undefined, 'estimated_files defaults undefined');
|
||||
assertEq(taskPlan.frontmatter.skills_used.length, 0, 'skills_used defaults empty array');
|
||||
}
|
||||
|
||||
console.log('\n=== parseTaskPlanFile: accepts scalar skills_used and numeric strings ===');
|
||||
{
|
||||
const content = `---
|
||||
estimated_steps: "9"
|
||||
estimated_files: "4"
|
||||
skills_used: react-best-practices
|
||||
---
|
||||
|
||||
# T02: Scalar skill handoff
|
||||
`;
|
||||
|
||||
const taskPlan = parseTaskPlanFile(content);
|
||||
assertEq(taskPlan.frontmatter.estimated_steps, 9, 'string estimated_steps parsed');
|
||||
assertEq(taskPlan.frontmatter.estimated_files, 4, 'string estimated_files parsed');
|
||||
assertEq(taskPlan.frontmatter.skills_used.length, 1, 'scalar skills_used normalized to array');
|
||||
assertEq(taskPlan.frontmatter.skills_used[0], 'react-best-practices', 'scalar skill preserved');
|
||||
}
|
||||
|
||||
console.log('\n=== parseTaskPlanFile: filters blank skills_used items ===');
|
||||
{
|
||||
const content = `---
|
||||
skills_used:
|
||||
- react
|
||||
-
|
||||
- testing
|
||||
---
|
||||
|
||||
# T03: Blank skills filtered
|
||||
`;
|
||||
|
||||
const taskPlan = parseTaskPlanFile(content);
|
||||
assertEq(taskPlan.frontmatter.skills_used.length, 2, 'blank skill entries removed');
|
||||
assertEq(taskPlan.frontmatter.skills_used[0], 'react', 'first remaining skill');
|
||||
assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second remaining skill');
|
||||
}
|
||||
|
||||
console.log('\n=== parseTaskPlanFile: invalid numeric frontmatter ignored ===');
|
||||
{
|
||||
const content = `---
|
||||
estimated_steps: many
|
||||
estimated_files: unknown
|
||||
---
|
||||
|
||||
# T04: Invalid estimates
|
||||
`;
|
||||
|
||||
const taskPlan = parseTaskPlanFile(content);
|
||||
assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'invalid estimated_steps ignored');
|
||||
assertEq(taskPlan.frontmatter.estimated_files, undefined, 'invalid estimated_files ignored');
|
||||
}
|
||||
|
||||
console.log('\n=== parseTaskPlanFile: parsePlan ignores task-plan frontmatter ===');
|
||||
{
|
||||
const content = `---
|
||||
estimated_steps: 2
|
||||
estimated_files: 1
|
||||
skills_used:
|
||||
- react
|
||||
---
|
||||
|
||||
# S11: Frontmatter Compatible
|
||||
|
||||
**Goal:** Plan parser ignores task-plan handoff metadata.
|
||||
**Demo:** Slice content still parses.
|
||||
|
||||
## Tasks
|
||||
|
||||
- [ ] **T01: Compatible task** \`est:5m\`
|
||||
Description.
|
||||
`;
|
||||
|
||||
const p = parsePlan(content);
|
||||
assertEq(p.id, 'S11', 'plan id still parsed with frontmatter');
|
||||
assertEq(p.tasks.length, 1, 'task still parsed with frontmatter');
|
||||
}
|
||||
|
||||
console.log('\n=== parsePlan: multi-line task description concatenation ===');
|
||||
{
|
||||
const content = `# S02: Multi-line Test
|
||||
|
|
@ -324,16 +430,36 @@ console.log('\n=== parsePlan: multi-line task description concatenation ===');
|
|||
const p = parsePlan(content);
|
||||
|
||||
assertEq(p.tasks.length, 2, 'two tasks');
|
||||
// Multi-line descriptions should be concatenated with spaces
|
||||
assertTrue(p.tasks[0].description.includes('First line'), 'T01 desc has first line');
|
||||
assertTrue(p.tasks[0].description.includes('Second line'), 'T01 desc has second line');
|
||||
assertTrue(p.tasks[0].description.includes('Third line'), 'T01 desc has third line');
|
||||
// Verify concatenation with space separator
|
||||
assertTrue(p.tasks[0].description.includes('description. Second'), 'lines joined with space');
|
||||
|
||||
assertEq(p.tasks[1].description, 'Just one line.', 'T02 single-line desc');
|
||||
}
|
||||
|
||||
console.log('\n=== parsePlan: frontmatter does not pollute task descriptions ===');
|
||||
{
|
||||
const content = `---
|
||||
estimated_steps: 2
|
||||
estimated_files: 1
|
||||
skills_used:
|
||||
- react
|
||||
---
|
||||
|
||||
# S12: Frontmatter + multiline
|
||||
|
||||
## Tasks
|
||||
|
||||
- [ ] **T01: Multi-line Task** \`est:30m\`
|
||||
First line of description.
|
||||
Second line of description.
|
||||
`;
|
||||
|
||||
const p = parsePlan(content);
|
||||
assertEq(p.tasks.length, 1, 'one task parsed with frontmatter');
|
||||
assertEq(p.tasks[0].description, 'First line of description. Second line of description.', 'frontmatter excluded from description');
|
||||
}
|
||||
|
||||
console.log('\n=== parsePlan: task with missing estimate ===');
|
||||
{
|
||||
const content = `# S03: No Estimate
|
||||
|
|
@ -351,12 +477,10 @@ console.log('\n=== parsePlan: task with missing estimate ===');
|
|||
`;
|
||||
|
||||
const p = parsePlan(content);
|
||||
|
||||
assertEq(p.tasks.length, 2, 'two tasks parsed');
|
||||
assertEq(p.tasks[0].id, 'T01', 'T01 id');
|
||||
assertEq(p.tasks[0].title, 'No Estimate Task', 'T01 title without estimate');
|
||||
assertEq(p.tasks[0].done, false, 'T01 not done');
|
||||
// The estimate backtick text appears in description if present, but parser doesn't crash without it
|
||||
assertEq(p.tasks[1].id, 'T02', 'T02 id');
|
||||
}
|
||||
|
||||
|
|
@ -379,7 +503,6 @@ console.log('\n=== parsePlan: empty tasks section ===');
|
|||
`;
|
||||
|
||||
const p = parsePlan(content);
|
||||
|
||||
assertEq(p.id, 'S04', 'plan id with empty tasks');
|
||||
assertEq(p.tasks.length, 0, 'no tasks');
|
||||
assertEq(p.mustHaves.length, 1, 'one must-have');
|
||||
|
|
@ -398,7 +521,6 @@ console.log('\n=== parsePlan: no H1 ===');
|
|||
`;
|
||||
|
||||
const p = parsePlan(content);
|
||||
|
||||
assertEq(p.id, '', 'empty id without H1');
|
||||
assertEq(p.title, '', 'empty title without H1');
|
||||
assertEq(p.goal, 'A plan without a heading.', 'goal still parsed');
|
||||
|
|
@ -408,8 +530,6 @@ console.log('\n=== parsePlan: no H1 ===');
|
|||
|
||||
console.log('\n=== parsePlan: task estimate backtick in description ===');
|
||||
{
|
||||
// The `est:45m` text appears after the bold closing but before the description lines
|
||||
// It should end up as part of the description or be ignored gracefully
|
||||
const content = `# S05: Estimate Handling
|
||||
|
||||
**Goal:** Test estimate text handling.
|
||||
|
|
@ -425,9 +545,6 @@ console.log('\n=== parsePlan: task estimate backtick in description ===');
|
|||
assertEq(p.tasks.length, 1, 'one task');
|
||||
assertEq(p.tasks[0].id, 'T01', 'task id');
|
||||
assertEq(p.tasks[0].title, 'With Estimate', 'title excludes estimate');
|
||||
// The `est:45m` backtick text after ** is not part of the title or description
|
||||
// It's on the same line after the regex match captures, so it's in the remainder
|
||||
// The description should be the continuation lines
|
||||
assertTrue(p.tasks[0].description.includes('Main description'), 'description from continuation line');
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,8 +26,21 @@ const BASE_VARS = {
|
|||
inlinedContext: "--- test inlined context ---",
|
||||
dependencySummaries: "", executorContextConstraints: "",
|
||||
sourceFilePaths: "- **Requirements**: `.gsd/REQUIREMENTS.md`",
|
||||
skillActivation: "Load the relevant skills.",
|
||||
};
|
||||
|
||||
const DEFAULT_SKILL_ACTIVATION = "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.";
|
||||
|
||||
function loadPromptWithDefaultSkillActivation(name: string, vars: Record<string, string> = {}): string {
|
||||
return loadPrompt(name, { skillActivation: DEFAULT_SKILL_ACTIVATION, ...vars });
|
||||
}
|
||||
|
||||
function promptUsesSkillActivation(name: string): boolean {
|
||||
const path = join(worktreePromptsDir, `${name}.md`);
|
||||
const content = readFileSync(path, "utf-8");
|
||||
return content.includes("{{skillActivation}}");
|
||||
}
|
||||
|
||||
test("plan-slice prompt: commit instruction says do not commit (external state)", () => {
|
||||
const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally." });
|
||||
assert.ok(result.includes("Do not commit planning artifacts"));
|
||||
|
|
@ -40,3 +53,199 @@ test("plan-slice prompt: all variables substituted", () => {
|
|||
assert.ok(result.includes("M001"));
|
||||
assert.ok(result.includes("S01"));
|
||||
});
|
||||
|
||||
test("domain-work prompts use skillActivation placeholder", () => {
|
||||
const prompts = [
|
||||
"research-milestone",
|
||||
"plan-milestone",
|
||||
"research-slice",
|
||||
"plan-slice",
|
||||
"execute-task",
|
||||
"guided-research-slice",
|
||||
"guided-plan-milestone",
|
||||
"guided-plan-slice",
|
||||
"guided-execute-task",
|
||||
"guided-resume-task",
|
||||
];
|
||||
|
||||
for (const name of prompts) {
|
||||
assert.ok(promptUsesSkillActivation(name), `${name}.md should contain {{skillActivation}}`);
|
||||
}
|
||||
});
|
||||
|
||||
test("skillActivation default leaves no unresolved placeholder", () => {
|
||||
const result = loadPromptWithDefaultSkillActivation("execute-task", {
|
||||
workingDirectory: "/tmp/test-project",
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
sliceTitle: "Test Slice",
|
||||
taskId: "T01",
|
||||
taskTitle: "Implement feature",
|
||||
planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md",
|
||||
taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
|
||||
taskPlanInline: "Task plan",
|
||||
slicePlanExcerpt: "Slice excerpt",
|
||||
carryForwardSection: "Carry forward",
|
||||
resumeSection: "Resume",
|
||||
priorTaskLines: "- (no prior tasks)",
|
||||
taskSummaryPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
|
||||
inlinedTemplates: "Template",
|
||||
verificationBudget: "~10K chars",
|
||||
overridesSection: "",
|
||||
});
|
||||
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
assert.ok(result.includes(DEFAULT_SKILL_ACTIVATION));
|
||||
});
|
||||
|
||||
test("custom skillActivation is substituted into execute-task", () => {
|
||||
const result = loadPrompt("execute-task", {
|
||||
workingDirectory: "/tmp/test-project",
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
sliceTitle: "Test Slice",
|
||||
taskId: "T01",
|
||||
taskTitle: "Implement feature",
|
||||
planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md",
|
||||
taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
|
||||
taskPlanInline: "Task plan",
|
||||
slicePlanExcerpt: "Slice excerpt",
|
||||
carryForwardSection: "Carry forward",
|
||||
resumeSection: "Resume",
|
||||
priorTaskLines: "- (no prior tasks)",
|
||||
taskSummaryPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
|
||||
inlinedTemplates: "Template",
|
||||
verificationBudget: "~10K chars",
|
||||
overridesSection: "",
|
||||
skillActivation: "Load React and accessibility skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load React and accessibility skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("guided execute prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("guided-execute-task", {
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
taskId: "T01",
|
||||
taskTitle: "Implement feature",
|
||||
inlinedTemplates: "Template",
|
||||
skillActivation: "Load React skill first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load React skill first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("guided resume prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("guided-resume-task", {
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
skillActivation: "Load debugging skill first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load debugging skill first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("research-milestone prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("research-milestone", {
|
||||
workingDirectory: "/tmp/test-project",
|
||||
milestoneId: "M001",
|
||||
milestoneTitle: "Test Milestone",
|
||||
milestonePath: ".gsd/milestones/M001",
|
||||
contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
|
||||
outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
|
||||
inlinedContext: "Context",
|
||||
skillDiscoveryMode: "manual",
|
||||
skillDiscoveryInstructions: " Discover skills manually.",
|
||||
skillActivation: "Load research skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load research skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("research-slice prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("research-slice", {
|
||||
workingDirectory: "/tmp/test-project",
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
sliceTitle: "Test Slice",
|
||||
slicePath: ".gsd/milestones/M001/slices/S01",
|
||||
roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
|
||||
contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
|
||||
milestoneResearchPath: ".gsd/milestones/M001/M001-RESEARCH.md",
|
||||
outputPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/S01-RESEARCH.md",
|
||||
inlinedContext: "Context",
|
||||
dependencySummaries: "",
|
||||
skillDiscoveryMode: "manual",
|
||||
skillDiscoveryInstructions: " Discover skills manually.",
|
||||
skillActivation: "Load slice research skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load slice research skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("plan-milestone prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("plan-milestone", {
|
||||
workingDirectory: "/tmp/test-project",
|
||||
milestoneId: "M001",
|
||||
milestoneTitle: "Test Milestone",
|
||||
milestonePath: ".gsd/milestones/M001",
|
||||
contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
|
||||
researchPath: ".gsd/milestones/M001/M001-RESEARCH.md",
|
||||
researchOutputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
|
||||
outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-ROADMAP.md",
|
||||
secretsOutputPath: "/tmp/test-project/.gsd/milestones/M001/M001-SECRETS.md",
|
||||
inlinedContext: "Context",
|
||||
sourceFilePaths: "- source",
|
||||
skillDiscoveryMode: "manual",
|
||||
skillDiscoveryInstructions: " Discover skills manually.",
|
||||
skillActivation: "Load milestone planning skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load milestone planning skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("guided plan milestone prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("guided-plan-milestone", {
|
||||
milestoneId: "M001",
|
||||
milestoneTitle: "Test Milestone",
|
||||
secretsOutputPath: ".gsd/milestones/M001/M001-SECRETS.md",
|
||||
inlinedTemplates: "Templates",
|
||||
skillActivation: "Load guided planning skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load guided planning skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("guided plan slice prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("guided-plan-slice", {
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
sliceTitle: "Test Slice",
|
||||
inlinedTemplates: "Templates",
|
||||
skillActivation: "Load guided slice planning skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load guided slice planning skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
||||
test("guided research slice prompt substitutes skillActivation", () => {
|
||||
const result = loadPrompt("guided-research-slice", {
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
sliceTitle: "Test Slice",
|
||||
inlinedTemplates: "Templates",
|
||||
skillActivation: "Load guided research skills first.",
|
||||
});
|
||||
|
||||
assert.ok(result.includes("Load guided research skills first."));
|
||||
assert.ok(!result.includes("{{skillActivation}}"));
|
||||
});
|
||||
|
|
|
|||
|
|
@ -29,7 +29,11 @@ const worktreePromptsDir = join(__dirname, '..', 'prompts');
|
|||
function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
|
||||
const path = join(worktreePromptsDir, `${name}.md`);
|
||||
let content = readFileSync(path, 'utf-8');
|
||||
for (const [key, value] of Object.entries(vars)) {
|
||||
const effectiveVars = {
|
||||
skillActivation: 'If no installed skill clearly matches this unit, skip explicit skill activation and continue with the required workflow.',
|
||||
...vars,
|
||||
};
|
||||
for (const [key, value] of Object.entries(effectiveVars)) {
|
||||
content = content.replaceAll(`{{${key}}}`, value);
|
||||
}
|
||||
return content.trim();
|
||||
|
|
|
|||
140
src/resources/extensions/gsd/tests/skill-activation.test.ts
Normal file
140
src/resources/extensions/gsd/tests/skill-activation.test.ts
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
import test from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
|
||||
import { join } from "node:path";
|
||||
import { tmpdir } from "node:os";
|
||||
import { loadSkills } from "@gsd/pi-coding-agent";
|
||||
import { buildSkillActivationBlock } from "../auto-prompts.js";
|
||||
import type { GSDPreferences } from "../preferences.js";
|
||||
|
||||
function makeTempBase(): string {
|
||||
return mkdtempSync(join(tmpdir(), "gsd-skill-activation-"));
|
||||
}
|
||||
|
||||
function cleanup(base: string): void {
|
||||
rmSync(base, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
function writeSkill(base: string, name: string, description: string): void {
|
||||
const dir = join(base, "skills", name);
|
||||
mkdirSync(dir, { recursive: true });
|
||||
writeFileSync(join(dir, "SKILL.md"), `---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`);
|
||||
}
|
||||
|
||||
function loadOnlyTestSkills(base: string): void {
|
||||
loadSkills({ cwd: base, includeDefaults: false, skillPaths: [join(base, "skills")] });
|
||||
}
|
||||
|
||||
function buildBlock(
|
||||
base: string,
|
||||
params: Partial<Parameters<typeof buildSkillActivationBlock>[0]> = {},
|
||||
preferences: GSDPreferences = {},
|
||||
): string {
|
||||
return buildSkillActivationBlock({
|
||||
base,
|
||||
milestoneId: "M001",
|
||||
sliceId: "S01",
|
||||
...params,
|
||||
preferences,
|
||||
});
|
||||
}
|
||||
|
||||
test("buildSkillActivationBlock matches installed skills from task context", () => {
|
||||
const base = makeTempBase();
|
||||
try {
|
||||
writeSkill(base, "react", "Use for React components, hooks, JSX, and frontend UI work.");
|
||||
writeSkill(base, "swiftui", "Use for SwiftUI views, iOS layout, and Apple platform UI work.");
|
||||
loadOnlyTestSkills(base);
|
||||
|
||||
const result = buildBlock(base, {
|
||||
sliceTitle: "Build React dashboard",
|
||||
taskId: "T01",
|
||||
taskTitle: "Implement React settings panel",
|
||||
});
|
||||
|
||||
assert.match(result, /<skill_activation>/);
|
||||
assert.match(result, /Call Skill\('react'\)/);
|
||||
assert.doesNotMatch(result, /swiftui/);
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
});
|
||||
|
||||
test("buildSkillActivationBlock includes always_use_skills from preferences", () => {
|
||||
const base = makeTempBase();
|
||||
try {
|
||||
writeSkill(base, "testing", "Use for test setup, assertions, and verification patterns.");
|
||||
loadOnlyTestSkills(base);
|
||||
|
||||
const result = buildBlock(base, { taskTitle: "Unrelated task title" }, {
|
||||
always_use_skills: ["testing"],
|
||||
});
|
||||
|
||||
assert.match(result, /Call Skill\('testing'\)/);
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
});
|
||||
|
||||
test("buildSkillActivationBlock includes skill_rules matches and task-plan skills_used", () => {
|
||||
const base = makeTempBase();
|
||||
try {
|
||||
writeSkill(base, "prisma", "Use for Prisma schema, migrations, and ORM queries.");
|
||||
writeSkill(base, "accessibility", "Use for accessibility, aria attributes, and keyboard support.");
|
||||
loadOnlyTestSkills(base);
|
||||
|
||||
const taskPlan = [
|
||||
"---",
|
||||
"skills_used:",
|
||||
" - accessibility",
|
||||
"---",
|
||||
"# T01: Example",
|
||||
].join("\n");
|
||||
|
||||
const result = buildBlock(base, {
|
||||
taskTitle: "Update prisma schema",
|
||||
taskPlanContent: taskPlan,
|
||||
}, {
|
||||
skill_rules: [{ when: "prisma database schema", use: ["prisma"] }],
|
||||
});
|
||||
|
||||
assert.match(result, /Call Skill\('accessibility'\)/);
|
||||
assert.match(result, /Call Skill\('prisma'\)/);
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
});
|
||||
|
||||
test("buildSkillActivationBlock honors avoid_skills", () => {
|
||||
const base = makeTempBase();
|
||||
try {
|
||||
writeSkill(base, "react", "Use for React components and frontend UI work.");
|
||||
loadOnlyTestSkills(base);
|
||||
|
||||
const result = buildBlock(base, {
|
||||
taskTitle: "Implement React settings panel",
|
||||
}, {
|
||||
avoid_skills: ["react"],
|
||||
});
|
||||
|
||||
assert.equal(result, "");
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
});
|
||||
|
||||
test("buildSkillActivationBlock falls back cleanly when nothing matches", () => {
|
||||
const base = makeTempBase();
|
||||
try {
|
||||
writeSkill(base, "swiftui", "Use for SwiftUI apps.");
|
||||
loadOnlyTestSkills(base);
|
||||
|
||||
const result = buildBlock(base, {
|
||||
taskTitle: "Plain text docs task",
|
||||
});
|
||||
|
||||
assert.equal(result, "");
|
||||
} finally {
|
||||
cleanup(base);
|
||||
}
|
||||
});
|
||||
|
|
@ -61,6 +61,16 @@ export interface TaskPlanEntry {
|
|||
verify?: string; // e.g. "run tests" — extracted from "- Verify:" subline
|
||||
}
|
||||
|
||||
export interface TaskPlanFrontmatter {
|
||||
estimated_steps?: number; // optional scope estimate for plan quality validator
|
||||
estimated_files?: number; // optional file-count estimate for scope warning heuristics
|
||||
skills_used: string[]; // installed skill slugs/names to hand off to execute-task prompts
|
||||
}
|
||||
|
||||
export interface TaskPlanFile {
|
||||
frontmatter: TaskPlanFrontmatter;
|
||||
}
|
||||
|
||||
// ─── Verification Gate ─────────────────────────────────────────────────────
|
||||
|
||||
/** Result of a single verification command execution */
|
||||
|
|
@ -478,3 +488,11 @@ export interface ReactiveExecutionState {
|
|||
};
|
||||
updatedAt: string;
|
||||
}
|
||||
|
||||
export interface BrowserFlowResult {
|
||||
url: string;
|
||||
passed: boolean;
|
||||
checksTotal: number;
|
||||
checksPassed: number;
|
||||
duration: number;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -37,6 +37,21 @@ export interface AuditWarningJSON {
|
|||
fixAvailable: boolean;
|
||||
}
|
||||
|
||||
export interface BrowserEvidenceCheckJSON {
|
||||
description: string;
|
||||
passed: boolean;
|
||||
actual?: string;
|
||||
evidence?: string;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export interface BrowserEvidenceJSON {
|
||||
url: string;
|
||||
passed: boolean;
|
||||
checks: BrowserEvidenceCheckJSON[];
|
||||
duration: number;
|
||||
}
|
||||
|
||||
export interface EvidenceJSON {
|
||||
schemaVersion: 1;
|
||||
taskId: string;
|
||||
|
|
@ -49,6 +64,7 @@ export interface EvidenceJSON {
|
|||
maxRetries?: number;
|
||||
runtimeErrors?: RuntimeErrorJSON[];
|
||||
auditWarnings?: AuditWarningJSON[];
|
||||
browser?: BrowserEvidenceJSON;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -7,7 +7,9 @@ import { join } from "node:path";
|
|||
import { homedir } from "node:os";
|
||||
import { readPromptRecord } from "./store.js";
|
||||
|
||||
const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
function getGsdHome(): string {
|
||||
return process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
}
|
||||
|
||||
export interface LatestPromptSummary {
|
||||
id: string;
|
||||
|
|
@ -16,7 +18,7 @@ export interface LatestPromptSummary {
|
|||
}
|
||||
|
||||
export function getLatestPromptSummary(): LatestPromptSummary | null {
|
||||
const runtimeDir = join(gsdHome, "runtime", "remote-questions");
|
||||
const runtimeDir = join(getGsdHome(), "runtime", "remote-questions");
|
||||
if (!existsSync(runtimeDir)) return null;
|
||||
const files = readdirSync(runtimeDir).filter((f) => f.endsWith(".json"));
|
||||
if (files.length === 0) return null;
|
||||
|
|
|
|||
|
|
@ -7,10 +7,12 @@ import { join } from "node:path";
|
|||
import { homedir } from "node:os";
|
||||
import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
|
||||
|
||||
const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
function getGsdHome(): string {
|
||||
return process.env.GSD_HOME || join(homedir(), ".gsd");
|
||||
}
|
||||
|
||||
function runtimeDir(): string {
|
||||
return join(gsdHome, "runtime", "remote-questions");
|
||||
return join(getGsdHome(), "runtime", "remote-questions");
|
||||
}
|
||||
|
||||
function recordPath(id: string): string {
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ export function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
|
|||
}
|
||||
|
||||
// Array item (2-space indent)
|
||||
const arrayMatch = line.match(/^ - (.*)$/);
|
||||
const arrayMatch = line.match(/^ - ?(.*)$/);
|
||||
if (arrayMatch && currentKey) {
|
||||
// If there's a pending nested object, push it
|
||||
if (currentObj && Object.keys(currentObj).length > 0) {
|
||||
|
|
|
|||
|
|
@ -100,24 +100,33 @@ test("buildResourceLoader excludes duplicate top-level pi extensions when bundle
|
|||
}
|
||||
});
|
||||
|
||||
test("initResources prunes stale top-level .ts siblings next to bundled compiled extensions", async () => {
|
||||
test("initResources prunes stale top-level extension siblings next to bundled compiled extensions", async () => {
|
||||
const { initResources } = await import("../resource-loader.ts");
|
||||
const tmp = mkdtempSync(join(tmpdir(), "gsd-resource-loader-sync-"));
|
||||
const fakeAgentDir = join(tmp, "agent");
|
||||
const staleTsPath = join(fakeAgentDir, "extensions", "ask-user-questions.ts");
|
||||
const bundledTsPath = join(fakeAgentDir, "extensions", "ask-user-questions.ts");
|
||||
const bundledJsPath = join(fakeAgentDir, "extensions", "ask-user-questions.js");
|
||||
|
||||
try {
|
||||
initResources(fakeAgentDir);
|
||||
assert.equal(existsSync(bundledJsPath), true, "compiled bundled top-level extension should exist");
|
||||
|
||||
writeFileSync(staleTsPath, "export {};\n");
|
||||
assert.equal(existsSync(staleTsPath), true);
|
||||
const bundledPath = existsSync(bundledJsPath)
|
||||
? bundledJsPath
|
||||
: bundledTsPath;
|
||||
const staleSiblingPath = bundledPath.endsWith(".js")
|
||||
? bundledTsPath
|
||||
: bundledJsPath;
|
||||
|
||||
assert.equal(existsSync(bundledPath), true, "bundled top-level extension should exist");
|
||||
|
||||
// Simulate a stale opposite-format sibling left from a previous sync/build mismatch.
|
||||
writeFileSync(staleSiblingPath, "export {};\n");
|
||||
assert.equal(existsSync(staleSiblingPath), true);
|
||||
|
||||
initResources(fakeAgentDir);
|
||||
|
||||
assert.equal(existsSync(staleTsPath), false, "stale .ts sibling should be removed during sync");
|
||||
assert.equal(existsSync(bundledJsPath), true, "bundled .js extension should remain after cleanup");
|
||||
assert.equal(existsSync(staleSiblingPath), false, "stale top-level sibling should be removed during sync");
|
||||
assert.equal(existsSync(bundledPath), true, "bundled extension should remain after cleanup");
|
||||
} finally {
|
||||
rmSync(tmp, { recursive: true, force: true });
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue