gswd 1.0.0 → 1.1.0

package/dist/tests/imagine.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for GSWD Imagine Workflow Orchestrator
+ *
+ * Integration-level tests using mock spawnFn and temp directories.
+ * Covers: full workflow, gate enforcement, auto mode, error handling.
+ * Minimum 10 test cases per Plan 02-05.
+ */
+export {};

package/dist/tests/imagine.test.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Tests for GSWD Imagine Workflow Orchestrator
+ *
+ * Integration-level tests using mock spawnFn and temp directories.
+ * Covers: full workflow, gate enforcement, auto mode, error handling.
+ * Minimum 10 test cases per Plan 02-05.
+ */
+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 imagine_js_1 = require("../lib/imagine.js");
+const state_js_1 = require("../lib/state.js");
+const config_js_1 = require("../lib/config.js");
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+/** Realistic mock agent outputs for a complete workflow */
+const MOCK_AGENT_OUTPUTS = {
+    'market-researcher': `## Market Overview
+The developer tools market is expanding rapidly. Specification tools remain a gap.
+
+## Competitors
+- Notion AI: General-purpose doc editing
+- Linear: Project management
+- Coda AI: Document automation
+
+## Market Gaps
+No tool converts ideas into execution-grade specs automatically.
+
+## Opportunities
+Open source community adoption through GitHub and Discord channels.`,
+    'icp-persona': `## ICP Profile
+Solo SaaS founders who code but skip specifications. Technical enough for CLI tools but struggle with product thinking.
+
+## Pain Points
+- Pain of manual spec writing: tedious, slow, frustrating
+- Waste time building wrong features
+- Struggle to think through edge cases
+
+## Willingness to Pay
+Early-stage founders have limited budget but will pay for tools that save time. Price point $29-49/mo for premium subscription.
+
+## Reachability
+Active on Indie Hackers, Twitter, Hacker News. Attend virtual meetups and subscribe to community newsletters.`,
+    'positioning': `## Value Proposition
+For solo founders who struggle with specifications, GSWD is a CLI tool that turns fuzzy ideas into execution-grade specs.
+
+## Positioning Statement
+Category: Developer productivity
+Differentiation: AI-powered spec generation vs manual templates
+
+## Key Differentiators
+- Automated research agents vs manual brainstorming
+- Deterministic compilation to project plans
+
+## Go-to-Market Angle
+Channel: Indie Hackers, open source GitHub community
+Wedge: Free CLI that generates DECISIONS.md from 3-question intake`,
+    'brainstorm-alternatives': `## Direction 1: CLI Spec Generator
+**ICP:** Solo SaaS founders who code but don't spec
+**Problem:** Founders skip specs, leading to painful rework and wasted build cycles
+**Wedge:** 3-question CLI intake that produces DECISIONS.md in 5 minutes
+**Differentiator:** AI agents do the research a PM would do
+**MVP scope:** Imagine stage only (intake to decisions)
+**Risk:** Founders may not trust AI-generated specs
+
+## Direction 2: Team Alignment Tool
+**ICP:** Small engineering teams (2-5) at early startups who pay for premium tools
+**Problem:** Misalignment between founder vision and dev execution is expensive and frustrating
+**Wedge:** Shared spec generated from async inputs
+**Differentiator:** Bridges business thinking and technical execution
+**MVP scope:** Collaborative editing with conflict detection
+**Risk:** Multi-user features are slow and complex to build
+
+## Direction 3: Idea Validator
+**ICP:** Pre-revenue founders exploring ideas via community forums and Reddit
+**Problem:** Founders invest months building products nobody wants — a tedious manual waste
+**Wedge:** Instant market viability score from one-paragraph idea
+**Differentiator:** Transparent scoring algorithm, not a black box
+**MVP scope:** Input to score to risks to go/no-go
+**Risk:** Scoring without real data feels unreliable`,
+    'devils-advocate': `## Assumptions Challenged
+- Assumption: Founders want CLI tools — Plausible but niche
+
+## Risks
+- **Risk:** AI specs may be too generic
+  - **Likelihood:** Medium
+  - **Impact:** High
+- **Risk:** Solo founders may not pay — expensive alternatives exist
+  - **Likelihood:** High
+  - **Impact:** High
+- **Risk:** LLM quality degrades over time
+  - **Likelihood:** Low
+  - **Impact:** Medium
+- **Risk:** Manual spec habit is hard to break — struggle to change
+  - **Likelihood:** Medium
+  - **Impact:** Medium
+- **Risk:** Competitors add spec features to existing tools
+  - **Likelihood:** Medium
+  - **Impact:** High
+
+## Mitigations
+- Validate with 10 user interviews before premium features
+- Open source core to reduce friction via community channels
+
+## Red Flags
+- If no one completes intake in beta, rethink UX`,
+};
+/** Mock spawn function returning realistic agent outputs */
+function createMockSpawnFn() {
+    return async (prompt) => {
+        for (const [agentName, output] of Object.entries(MOCK_AGENT_OUTPUTS)) {
+            if (prompt.includes(`name: ${agentName}`) || prompt.includes(agentName)) {
+                return output;
+            }
+        }
+        return '## Output\nGeneric agent output.';
+    };
+}
+/** Create a temporary test directory with initialized state + config */
+function createTestEnv() {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-imagine-test-'));
+    const planningDir = tmpDir;
+    const gswdDir = path.join(planningDir, 'gswd');
+    fs.mkdirSync(gswdDir, { recursive: true });
+    // Initialize STATE.json
+    const state = (0, state_js_1.createDefaultState)('test-project');
+    const statePath = path.join(gswdDir, 'STATE.json');
+    (0, state_js_1.safeWriteJson)(statePath, state);
+    // Initialize config.json
+    const configPath = path.join(planningDir, 'config.json');
+    (0, config_js_1.mergeGswdConfig)(configPath);
+    return {
+        planningDir,
+        configPath,
+        cleanup: () => {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        },
+    };
+}
+/** Create a test idea file in the given directory */
+function createIdeaFile(dir) {
+    const ideaPath = path.join(dir, 'idea.md');
+    const content = `# GSWD — Get Shit Well Done
+
+A CLI tool that turns unstructured founder ideas into execution-grade specifications.
+
+## Target Audience
+Built for solo founders building SaaS products who are technical enough to use terminal tools but struggle with product thinking and specification writing.
+
+## Why Now
+LLMs can now understand product requirements deeply. The gap between idea and execution is the biggest problem founders face — there's a growing frustration with manual spec writing.
+
+## Key Themes
+- CLI-first developer experience
+- Automated research and brainstorming
+- Deterministic spec compilation
+- Zero-dependency Node.js tooling
+`;
+    fs.writeFileSync(ideaPath, content, 'utf-8');
+    return ideaPath;
+}
+// ─── Tests ───────────────────────────────────────────────────────────────────
+(0, node_test_1.describe)('Imagine workflow with mock agents', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('runImagine with ideaFilePath and mock spawnFn produces all 5 artifacts', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        assert.strictEqual(result.status, 'complete', `Expected complete but got: ${result.error || result.gate_result?.summary}`);
+        assert.strictEqual(result.artifacts_written.length, 5, 'Should write 5 artifacts');
+    });
+    (0, node_test_1.it)('runImagine with intakeAnswers and mock spawnFn produces all 5 artifacts', async () => {
+        const result = await (0, imagine_js_1.runImagine)({
+            intakeAnswers: {
+                vision: 'A CLI tool that turns ideas into execution-grade specifications',
+                user: 'Solo SaaS founders who code but skip product specs',
+                whyNow: 'LLMs now understand product requirements — growing frustration with manual specs',
+            },
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        assert.strictEqual(result.status, 'complete', `Expected complete but got: ${result.error || result.gate_result?.summary}`);
+        assert.strictEqual(result.artifacts_written.length, 5);
+    });
+    (0, node_test_1.it)('artifacts exist on disk after successful run', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        assert.strictEqual(result.status, 'complete');
+        const expectedFiles = ['IMAGINE.md', 'ICP.md', 'GTM.md', 'COMPETITION.md', 'DECISIONS.md'];
+        for (const file of expectedFiles) {
+            const filePath = path.join(env.planningDir, file);
+            assert.ok(fs.existsSync(filePath), `${file} should exist on disk`);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            assert.ok(content.length > 0, `${file} should have content`);
+        }
+    });
+    (0, node_test_1.it)('STATE.json shows imagine: done after successful run', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        assert.strictEqual(state.stage_status.imagine, 'done');
+    });
+});
+(0, node_test_1.describe)('Decision gate enforcement', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('skipResearch with minimal brief still produces gate-passing output', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            skipResearch: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+        });
+        // skipResearch produces minimal agent data — the orchestrator should still
+        // build valid DECISIONS.md with enough frozen decisions to pass the gate
+        assert.strictEqual(result.status, 'complete', `Expected complete but got: ${result.error || result.gate_result?.summary}`);
+    });
+    (0, node_test_1.it)('gate result details are included in ImagineResult', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        assert.ok(result.gate_result, 'Should include gate result');
+        assert.ok(typeof result.gate_result.passed === 'boolean', 'Gate result should have passed field');
+        assert.ok(result.gate_result.summary, 'Gate result should have summary');
+    });
+});
+(0, node_test_1.describe)('Auto mode', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('runImagine with autoMode=true produces AutoDecision[] in result', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        assert.strictEqual(result.status, 'complete');
+        assert.ok(result.auto_decisions, 'Should have auto_decisions');
+        assert.ok(result.auto_decisions.length >= 3, 'Should have at least 3 auto decisions');
+        const types = result.auto_decisions.map(d => d.type);
+        assert.ok(types.includes('direction'), 'Should have direction decision');
+        assert.ok(types.includes('icp'), 'Should have ICP decision');
+        assert.ok(types.includes('wedge'), 'Should have wedge decision');
+    });
+    (0, node_test_1.it)('STATE.json auto.decisions is populated after auto run', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        const statePath = path.join(env.planningDir, 'gswd', 'STATE.json');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+        assert.ok(state.auto.decisions, 'State should have auto.decisions');
+        assert.ok(Array.isArray(state.auto.decisions), 'auto.decisions should be an array');
+        assert.ok(state.auto.decisions.length >= 3, 'Should have at least 3 decisions');
+    });
+    (0, node_test_1.it)('DECISIONS.md contains Auto-chosen markers in auto mode', async () => {
+        const ideaPath = createIdeaFile(env.planningDir);
+        await (0, imagine_js_1.runImagine)({
+            ideaFilePath: ideaPath,
+            autoMode: true,
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+            spawnFn: createMockSpawnFn(),
+        });
+        const decisionsPath = path.join(env.planningDir, 'DECISIONS.md');
+        const content = fs.readFileSync(decisionsPath, 'utf-8');
+        assert.ok(content.includes('Auto-chosen'), 'DECISIONS.md should contain Auto-chosen markers');
+    });
+});
+(0, node_test_1.describe)('Error handling', () => {
+    let env;
+    (0, node_test_1.beforeEach)(() => {
+        env = createTestEnv();
+    });
+    (0, node_test_1.afterEach)(() => {
+        env.cleanup();
+    });
+    (0, node_test_1.it)('no input (no file, no answers) returns error result', async () => {
+        const result = await (0, imagine_js_1.runImagine)({
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+        });
+        assert.strictEqual(result.status, 'error');
+        assert.ok(result.error, 'Should have error message');
+        assert.ok(result.error.includes('No input'), 'Error should mention missing input');
+    });
+    (0, node_test_1.it)('non-existent idea file returns error result', async () => {
+        const result = await (0, imagine_js_1.runImagine)({
+            ideaFilePath: '/nonexistent/idea.md',
+            planningDir: env.planningDir,
+            configPath: env.configPath,
+        });
+        assert.strictEqual(result.status, 'error');
+        assert.ok(result.error, 'Should have error message');
+    });
+    (0, node_test_1.it)('missing STATE.json returns error result', async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gswd-imagine-nostate-'));
+        const gswdDir = path.join(tmpDir, 'gswd');
+        fs.mkdirSync(gswdDir, { recursive: true });
+        const result = await (0, imagine_js_1.runImagine)({
+            intakeAnswers: {
+                vision: 'A test product for testing purposes',
+                user: 'Test users who test things',
+                whyNow: 'Testing is important right now',
+            },
+            planningDir: tmpDir,
+            configPath: path.join(tmpDir, 'config.json'),
+        });
+        assert.strictEqual(result.status, 'error');
+        assert.ok(result.error?.includes('STATE.json'), 'Error should mention STATE.json');
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    });
+});

package/dist/tests/parse.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parse module tests — ID extraction, normalization, heading validation
+ */
+export {};