gswd 1.0.1 → 1.1.0

package/dist/tests/state.test.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * State module tests — atomic writes, STATE.json CRUD, idempotent init, ID registry
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const assert = __importStar(require("node:assert"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const state_js_1 = require("../lib/state.js");
+let tmpDir;
+(0, node_test_1.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-test-'));
+});
+(0, node_test_1.afterEach)(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// ─── safeWriteFile ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('safeWriteFile', () => {
+    (0, node_test_1.it)('writes file atomically with correct content', () => {
+        const filePath = path.join(tmpDir, 'test.txt');
+        (0, state_js_1.safeWriteFile)(filePath, 'hello world');
+        assert.strictEqual(fs.readFileSync(filePath, 'utf-8'), 'hello world');
+    });
+    (0, node_test_1.it)('leaves no .tmp file after successful write', () => {
+        const filePath = path.join(tmpDir, 'test.txt');
+        (0, state_js_1.safeWriteFile)(filePath, 'content');
+        assert.strictEqual(fs.existsSync(filePath + '.tmp'), false);
+    });
+    (0, node_test_1.it)('creates parent directories if missing', () => {
+        const filePath = path.join(tmpDir, 'deep', 'nested', 'dir', 'test.txt');
+        (0, state_js_1.safeWriteFile)(filePath, 'nested content');
+        assert.strictEqual(fs.readFileSync(filePath, 'utf-8'), 'nested content');
+    });
+    (0, node_test_1.it)('overwrites existing file atomically', () => {
+        const filePath = path.join(tmpDir, 'test.txt');
+        (0, state_js_1.safeWriteFile)(filePath, 'first');
+        (0, state_js_1.safeWriteFile)(filePath, 'second');
+        assert.strictEqual(fs.readFileSync(filePath, 'utf-8'), 'second');
+    });
+});
+// ─── safeWriteJson ───────────────────────────────────────────────────────────
+(0, node_test_1.describe)('safeWriteJson', () => {
+    (0, node_test_1.it)('writes valid JSON with 2-space indent and trailing newline', () => {
+        const filePath = path.join(tmpDir, 'test.json');
+        (0, state_js_1.safeWriteJson)(filePath, { key: 'value' });
+        const content = fs.readFileSync(filePath, 'utf-8');
+        assert.strictEqual(content, '{\n  "key": "value"\n}\n');
+    });
+    (0, node_test_1.it)('round-trips: write then read produces identical object', () => {
+        const filePath = path.join(tmpDir, 'test.json');
+        const data = { a: 1, b: [2, 3], c: { nested: true } };
+        (0, state_js_1.safeWriteJson)(filePath, data);
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        assert.deepStrictEqual(parsed, data);
+    });
+});
+// ─── createDefaultState ──────────────────────────────────────────────────────
+(0, node_test_1.describe)('createDefaultState', () => {
+    (0, node_test_1.it)('returns object with all required top-level keys', () => {
+        const state = (0, state_js_1.createDefaultState)('my-project');
+        const keys = Object.keys(state);
+        assert.ok(keys.includes('version'));
+        assert.ok(keys.includes('project_slug'));
+        assert.ok(keys.includes('created_at'));
+        assert.ok(keys.includes('updated_at'));
+        assert.ok(keys.includes('stage'));
+        assert.ok(keys.includes('stage_status'));
+        assert.ok(keys.includes('last_checkpoint'));
+        assert.ok(keys.includes('auto'));
+        assert.ok(keys.includes('approvals'));
+    });
+    (0, node_test_1.it)('sets version to 1', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        assert.strictEqual(state.version, 1);
+    });
+    (0, node_test_1.it)('sets project_slug from argument', () => {
+        const state = (0, state_js_1.createDefaultState)('my-project');
+        assert.strictEqual(state.project_slug, 'my-project');
+    });
+    (0, node_test_1.it)('sets all four stages to not_started', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        assert.strictEqual(state.stage_status.imagine, 'not_started');
+        assert.strictEqual(state.stage_status.specify, 'not_started');
+        assert.strictEqual(state.stage_status.audit, 'not_started');
+        assert.strictEqual(state.stage_status.compile, 'not_started');
+    });
+    (0, node_test_1.it)('sets auto.policy to balanced', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        assert.strictEqual(state.auto.policy, 'balanced');
+    });
+    (0, node_test_1.it)('sets last_checkpoint to null', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        assert.strictEqual(state.last_checkpoint, null);
+    });
+    (0, node_test_1.it)('sets stage to init', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        assert.strictEqual(state.stage, 'init');
+    });
+});
+// ─── readState ───────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('readState', () => {
+    (0, node_test_1.it)('returns null for missing file', () => {
+        const result = (0, state_js_1.readState)(path.join(tmpDir, 'nonexistent.json'));
+        assert.strictEqual(result, null);
+    });
+    (0, node_test_1.it)('returns null for invalid JSON', () => {
+        const filePath = path.join(tmpDir, 'bad.json');
+        fs.writeFileSync(filePath, 'not json');
+        assert.strictEqual((0, state_js_1.readState)(filePath), null);
+    });
+    (0, node_test_1.it)('returns null for JSON missing required fields', () => {
+        const filePath = path.join(tmpDir, 'incomplete.json');
+        fs.writeFileSync(filePath, JSON.stringify({ foo: 'bar' }));
+        assert.strictEqual((0, state_js_1.readState)(filePath), null);
+    });
+    (0, node_test_1.it)('returns parsed state for valid STATE.json', () => {
+        const state = (0, state_js_1.createDefaultState)('test');
+        const filePath = path.join(tmpDir, 'STATE.json');
+        (0, state_js_1.safeWriteJson)(filePath, state);
+        const read = (0, state_js_1.readState)(filePath);
+        assert.deepStrictEqual(read, state);
+    });
+});
+// ─── initState (idempotent) ──────────────────────────────────────────────────
+(0, node_test_1.describe)('initState', () => {
+    (0, node_test_1.it)('creates STATE.json when missing', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        const state = (0, state_js_1.initState)(stateDir, 'new-project');
+        assert.strictEqual(state.project_slug, 'new-project');
+        assert.ok(fs.existsSync(path.join(stateDir, 'STATE.json')));
+    });
+    (0, node_test_1.it)('returns existing state unchanged when valid STATE.json exists', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        const first = (0, state_js_1.initState)(stateDir, 'project');
+        const second = (0, state_js_1.initState)(stateDir, 'project');
+        assert.deepStrictEqual(first, second);
+    });
+    (0, node_test_1.it)('does NOT update timestamps on existing valid state', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        const first = (0, state_js_1.initState)(stateDir, 'project');
+        // Wait a tick to ensure timestamp would differ
+        const second = (0, state_js_1.initState)(stateDir, 'project');
+        assert.strictEqual(first.created_at, second.created_at);
+        assert.strictEqual(first.updated_at, second.updated_at);
+    });
+    (0, node_test_1.it)('creates directory if missing', () => {
+        const stateDir = path.join(tmpDir, 'deep', 'nested', 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        assert.ok(fs.existsSync(path.join(stateDir, 'STATE.json')));
+    });
+    (0, node_test_1.it)('handles corrupt JSON by creating fresh state', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        fs.mkdirSync(stateDir, { recursive: true });
+        fs.writeFileSync(path.join(stateDir, 'STATE.json'), 'corrupt!!!');
+        const state = (0, state_js_1.initState)(stateDir, 'recovered');
+        assert.strictEqual(state.project_slug, 'recovered');
+        assert.strictEqual(state.version, 1);
+    });
+});
+// ─── updateStageStatus ───────────────────────────────────────────────────────
+(0, node_test_1.describe)('updateStageStatus', () => {
+    (0, node_test_1.it)('updates specific stage to new status', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.updateStageStatus)(statePath, 'imagine', 'in_progress');
+        const state = (0, state_js_1.readState)(statePath);
+        assert.strictEqual(state.stage_status.imagine, 'in_progress');
+    });
+    (0, node_test_1.it)('preserves all other fields', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.updateStageStatus)(statePath, 'imagine', 'done');
+        const state = (0, state_js_1.readState)(statePath);
+        assert.strictEqual(state.project_slug, 'project');
+        assert.strictEqual(state.stage_status.specify, 'not_started');
+        assert.strictEqual(state.stage_status.audit, 'not_started');
+        assert.strictEqual(state.stage_status.compile, 'not_started');
+    });
+});
+// ─── writeCheckpoint ─────────────────────────────────────────────────────────
+(0, node_test_1.describe)('writeCheckpoint', () => {
+    (0, node_test_1.it)('sets last_checkpoint with workflow, checkpoint_id, timestamp', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.writeCheckpoint)(statePath, 'gswd/imagine', 'step-1');
+        const state = (0, state_js_1.readState)(statePath);
+        assert.ok(state.last_checkpoint);
+        assert.strictEqual(state.last_checkpoint.workflow, 'gswd/imagine');
+        assert.strictEqual(state.last_checkpoint.checkpoint_id, 'step-1');
+        assert.ok(state.last_checkpoint.timestamp);
+    });
+    (0, node_test_1.it)('preserves all other state fields', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.writeCheckpoint)(statePath, 'gswd/specify', 'mid-point');
+        const state = (0, state_js_1.readState)(statePath);
+        assert.strictEqual(state.project_slug, 'project');
+        assert.strictEqual(state.version, 1);
+    });
+});
+// ─── ID Registry ─────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('allocateIdRange', () => {
+    (0, node_test_1.it)('first allocation returns range starting at 1', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        const range = (0, state_js_1.allocateIdRange)(statePath, 'FR', 'agent-1');
+        assert.strictEqual(range.start, 1);
+        assert.strictEqual(range.end, 50);
+    });
+    (0, node_test_1.it)('second allocation continues from previous end', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.allocateIdRange)(statePath, 'FR', 'agent-1');
+        const range2 = (0, state_js_1.allocateIdRange)(statePath, 'FR', 'agent-2');
+        assert.strictEqual(range2.start, 51);
+        assert.strictEqual(range2.end, 100);
+    });
+    (0, node_test_1.it)('different ID types have independent ranges', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        const fr = (0, state_js_1.allocateIdRange)(statePath, 'FR', 'agent-1');
+        const j = (0, state_js_1.allocateIdRange)(statePath, 'J', 'agent-1');
+        assert.strictEqual(fr.start, 1);
+        assert.strictEqual(j.start, 1);
+    });
+    (0, node_test_1.it)('respects custom range size', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        const range = (0, state_js_1.allocateIdRange)(statePath, 'FR', 'agent-1', 25);
+        assert.strictEqual(range.start, 1);
+        assert.strictEqual(range.end, 25);
+    });
+});
+(0, node_test_1.describe)('getIdRanges', () => {
+    (0, node_test_1.it)('returns empty object when no registry exists', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        const ranges = (0, state_js_1.getIdRanges)(statePath);
+        assert.deepStrictEqual(ranges, {});
+    });
+    (0, node_test_1.it)('returns all ranges when no type filter', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.allocateIdRange)(statePath, 'FR', 'a1');
+        (0, state_js_1.allocateIdRange)(statePath, 'J', 'a1');
+        const ranges = (0, state_js_1.getIdRanges)(statePath);
+        assert.ok(ranges.FR);
+        assert.ok(ranges.J);
+    });
+    (0, node_test_1.it)('filters by type when specified', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.allocateIdRange)(statePath, 'FR', 'a1');
+        (0, state_js_1.allocateIdRange)(statePath, 'J', 'a1');
+        const ranges = (0, state_js_1.getIdRanges)(statePath, 'FR');
+        assert.ok(ranges.FR);
+        assert.strictEqual(ranges.J, undefined);
+    });
+});
+(0, node_test_1.describe)('resetIdRegistry', () => {
+    (0, node_test_1.it)('clears all ranges', () => {
+        const stateDir = path.join(tmpDir, 'gswd');
+        (0, state_js_1.initState)(stateDir, 'project');
+        const statePath = path.join(stateDir, 'STATE.json');
+        (0, state_js_1.allocateIdRange)(statePath, 'FR', 'a1');
+        (0, state_js_1.resetIdRegistry)(statePath);
+        const ranges = (0, state_js_1.getIdRanges)(statePath);
+        assert.deepStrictEqual(ranges, {});
+    });
+});

package/lib/bootstrap.ts

@@ -20,7 +20,8 @@ import { initState, readState, writeState, writeCheckpoint } from './state.js';
 import type { StageStatus } from './state.js';
 import { getGswdConfig } from './config.js';
 import type { GswdConfig } from './config.js';
-import { renderBanner, renderCheckpoint, renderNextUp } from './render.js';
+import { renderBanner, renderCheckpoint, renderNextUp, renderFileInventory, renderContextBanner, extractProductContext, STAGE_CONTEXT_TEMPLATES } from './render.js';
+import type { ProductContext } from './render.js';
 import type { AutoDecision } from './imagine-synthesis.js';
 import { runImagine } from './imagine.js';
 import type { ImagineResult } from './imagine.js';
@@ -330,9 +331,9 @@ export function handleInterrupt(
   // Step 2: Render checkpoint box
   const box = renderCheckpoint(
     'Auto Mode Interrupted',
-    'Bootstrap cannot continue automatically. Resolve:',
+    'Pipeline cannot continue automatically. Resolve:',
     reasons.map(r => r.length > 50 ? r.slice(0, 47) + '...' : r),
-    'Resolve issues above, then re-run bootstrap'
+    'Resolve issues above, then re-run /gswd:start'
   );
   console.log(box);
 
@@ -446,13 +447,17 @@ export async function runBootstrap(options: BootstrapOptions): Promise<Bootstrap
     writeState(statePath, initStateObj);
   }
 
-  console.log(renderBanner('BOOTSTRAP'));
+  console.log(renderBanner('PIPELINE'));
+
+  // Extract product context for contextual banners
+  const productCtx = extractProductContext(planningDir);
 
   // ── IMAGINE ──────────────────────────────────────────────────────────
   const imagineState = readState(statePath)!;
   if (!shouldSkipStage('imagine', imagineState, planningDir, options.resume ?? false)) {
     writeCheckpoint(statePath, 'gswd/bootstrap', 'imagine-start');
-    console.log(renderBanner('IMAGINE'));
+    const imagineCtxLine = STAGE_CONTEXT_TEMPLATES.imagine?.(productCtx) || '';
+    console.log(renderContextBanner('IMAGINE', imagineCtxLine));
     // runImagine is ASYNC — MUST await
     const imagineResult: ImagineResult = await runImagine({
       ideaFilePath: options.ideaFilePath,
@@ -502,7 +507,10 @@ export async function runBootstrap(options: BootstrapOptions): Promise<Bootstrap
   const specifyState = readState(statePath)!;
   if (!shouldSkipStage('specify', specifyState, planningDir, options.resume ?? false)) {
     writeCheckpoint(statePath, 'gswd/bootstrap', 'specify-start');
-    console.log(renderBanner('SPECIFY'));
+    // Re-extract after imagine (DECISIONS.md now exists with precise data)
+    const specifyCtx = extractProductContext(planningDir);
+    const specifyCtxLine = STAGE_CONTEXT_TEMPLATES.specify?.(specifyCtx) || '';
+    console.log(renderContextBanner('SPECIFY', specifyCtxLine));
     // runSpecify is ASYNC — MUST await
     // When no spawnFn provided, set skipAgents: true (Pitfall 1)
     const specifyResult: SpecifyResult = await runSpecify({
@@ -542,7 +550,9 @@ export async function runBootstrap(options: BootstrapOptions): Promise<Bootstrap
   const auditState = readState(statePath)!;
   if (!shouldSkipStage('audit', auditState, planningDir, options.resume ?? false)) {
     writeCheckpoint(statePath, 'gswd/bootstrap', 'audit-start');
-    console.log(renderBanner('AUDIT'));
+    const auditCtx = extractProductContext(planningDir);
+    const auditCtxLine = STAGE_CONTEXT_TEMPLATES.audit?.(auditCtx) || '';
+    console.log(renderContextBanner('AUDIT', auditCtxLine));
     // runAuditWorkflow is SYNC — no await (Pitfall 7)
     const auditResult: AuditWorkflowResult = runAuditWorkflow({
       planningDir,
@@ -602,10 +612,26 @@ export async function runBootstrap(options: BootstrapOptions): Promise<Bootstrap
     console.log(renderAutoDecisionSummary(allAutoDecisions));
   }
 
-  console.log(renderNextUp(
-    ['PROJECT.md', 'REQUIREMENTS.md', 'ROADMAP.md', 'STATE.md'],
-    '/gsd:plan-phase 01'
-  ));
+  // Display dynamic file inventory (matches manual mode output)
+  const inventoryFiles = [
+    { path: '.planning/IMAGINE.md', description: 'Product vision, target user, and direction' },
+    { path: '.planning/DECISIONS.md', description: 'Frozen decisions, success metrics, risks' },
+    { path: '.planning/SPEC.md', description: 'Functional requirements with acceptance criteria' },
+    { path: '.planning/NFR.md', description: 'Non-functional requirements with thresholds' },
+    { path: '.planning/JOURNEYS.md', description: 'User journeys with FR and integration linkages' },
+    { path: '.planning/INTEGRATIONS.md', description: 'External integrations with status and fallbacks' },
+    { path: '.planning/PROJECT.md', description: 'GSD project context (compiled)' },
+    { path: '.planning/REQUIREMENTS.md', description: 'GSD requirements with traceability (compiled)' },
+    { path: '.planning/ROADMAP.md', description: 'GSD roadmap with phased journeys (compiled)' },
+    { path: '.planning/STATE.md', description: 'GSD project state and decisions (compiled)' },
+    { path: '.planning/research/gswd/SUMMARY.md', description: 'GSD-format research bridge (compiled)' },
+  ].filter(f => {
+    try { fs.accessSync(path.join(process.cwd(), f.path)); return true; }
+    catch { return false; }
+  });
+
+  console.log(renderFileInventory(inventoryFiles));
+  console.log('\nNext up:\n  /gsd:plan-phase 01\n\nTip:\n  If context is getting crowded, run /clear first.');
 
   return {
     status: 'done',