gswd 1.0.1 → 1.1.0

package/dist/lib/imagine-input.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * GSWD Imagine Input Module — Input collection with file parsing and intake building
+ *
+ * Two input paths converge to a single StarterBrief interface:
+ * 1. parseIdeaFile: Parse @idea.md into a starter brief
+ * 2. buildFromIntake: Build from 3-question intake answers
+ *
+ * Schema: GSWD_SPEC.md Section 8.2, Steps 1-2
+ */
+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 });
+exports.parseIdeaFile = parseIdeaFile;
+exports.buildFromIntake = buildFromIntake;
+exports.validateBrief = validateBrief;
+const fs = __importStar(require("node:fs"));
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Find the first sentence containing any of the given keywords.
+ * Returns the full sentence or null if no match.
+ */
+function findSentenceWithKeywords(content, keywords) {
+    // Split into sentences (rough: split on . ! ? followed by space or end)
+    const sentences = content.split(/(?<=[.!?])\s+/);
+    const lowerKeywords = keywords.map(k => k.toLowerCase());
+    for (const sentence of sentences) {
+        const lower = sentence.toLowerCase();
+        for (const keyword of lowerKeywords) {
+            if (lower.includes(keyword)) {
+                return sentence.trim();
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract the first meaningful paragraph (>20 chars, not a heading).
+ */
+function extractFirstParagraph(content) {
+    const lines = content.split('\n');
+    let paragraph = '';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip headings and empty lines
+        if (trimmed.startsWith('#') || trimmed === '') {
+            if (paragraph.length > 20)
+                return paragraph.trim();
+            paragraph = '';
+            continue;
+        }
+        paragraph += (paragraph ? ' ' : '') + trimmed;
+    }
+    return paragraph.length > 20 ? paragraph.trim() : '';
+}
+/**
+ * Extract raw themes from content: headings, bullets, bold text.
+ * Deduplicates and limits to 20 items.
+ */
+function extractThemes(content) {
+    const themes = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Headings (strip # prefix)
+        if (trimmed.startsWith('#')) {
+            const heading = trimmed.replace(/^#+\s*/, '').trim();
+            if (heading.length > 2)
+                themes.add(heading);
+        }
+        // Bullet points (strip - or * prefix)
+        if (/^[-*]\s+/.test(trimmed)) {
+            const bullet = trimmed.replace(/^[-*]\s+/, '').trim();
+            if (bullet.length > 2)
+                themes.add(bullet);
+        }
+        // Numbered items
+        if (/^\d+[.)]\s+/.test(trimmed)) {
+            const item = trimmed.replace(/^\d+[.)]\s+/, '').trim();
+            if (item.length > 2)
+                themes.add(item);
+        }
+    }
+    // Also extract bold text (**text**)
+    const boldRegex = /\*\*([^*]+)\*\*/g;
+    let match;
+    while ((match = boldRegex.exec(content)) !== null) {
+        const bold = match[1].trim();
+        if (bold.length > 2)
+            themes.add(bold);
+    }
+    return Array.from(themes).slice(0, 20);
+}
+/**
+ * Extract themes from intake answers by splitting on delimiters.
+ */
+function extractIntakeThemes(combined) {
+    const themes = new Set();
+    // Split on commas, semicolons, and " and " conjunctions
+    const parts = combined.split(/[,;]|\s+and\s+/i);
+    for (const part of parts) {
+        const trimmed = part.trim();
+        // Filter out very short fragments and common filler words
+        if (trimmed.length > 3) {
+            themes.add(trimmed);
+        }
+    }
+    return Array.from(themes).slice(0, 20);
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Parse an @idea.md file into a StarterBrief.
+ *
+ * Extracts vision, target user, timing, and themes from freeform markdown.
+ * Falls back to first 200 chars if specific fields can't be extracted.
+ * Throws on empty or non-existent files.
+ */
+function parseIdeaFile(filePath) {
+    // Read file
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Cannot read idea file "${filePath}": ${message}`);
+    }
+    // Check for empty file
+    if (content.trim().length < 10) {
+        throw new Error(`Idea file "${filePath}" is too short (< 10 chars). Provide a more detailed description.`);
+    }
+    const fallback = content.trim().slice(0, 200);
+    // Extract vision: first heading content or first paragraph
+    const headingMatch = content.match(/^#+\s+(.+)$/m);
+    let vision = headingMatch ? headingMatch[1].trim() : '';
+    if (!vision || vision.length <= 20) {
+        const para = extractFirstParagraph(content);
+        vision = para || fallback;
+    }
+    // Extract target user
+    const userKeywords = ['for', 'target', 'customer', 'audience', 'users', 'people who', 'designed for', 'built for'];
+    let target_user = findSentenceWithKeywords(content, userKeywords) || '';
+    if (!target_user) {
+        target_user = fallback;
+    }
+    // Extract why now
+    const whyNowKeywords = ['because', 'opportunity', 'problem', 'pain', 'frustration', 'gap', 'trend', 'growing', 'increasing'];
+    let why_now = findSentenceWithKeywords(content, whyNowKeywords) || '';
+    if (!why_now) {
+        why_now = fallback;
+    }
+    // Extract themes
+    const raw_themes = extractThemes(content);
+    return {
+        vision,
+        target_user,
+        why_now,
+        raw_themes,
+        source: 'file',
+    };
+}
+/**
+ * Build a StarterBrief from 3-question intake answers.
+ *
+ * Maps: vision -> vision, user -> target_user, whyNow -> why_now.
+ * Extracts themes by splitting answers on delimiters.
+ */
+function buildFromIntake(answers) {
+    const combined = `${answers.vision}, ${answers.user}, ${answers.whyNow}`;
+    const raw_themes = extractIntakeThemes(combined);
+    return {
+        vision: answers.vision.trim(),
+        target_user: answers.user.trim(),
+        why_now: answers.whyNow.trim(),
+        raw_themes,
+        source: 'intake',
+    };
+}
+/**
+ * Validate that a StarterBrief has sufficient signal for research agents.
+ *
+ * Checks: vision > 10 chars, target_user > 5 chars, why_now > 5 chars, raw_themes >= 1.
+ */
+function validateBrief(brief) {
+    const missing = [];
+    if (!brief.vision || brief.vision.length <= 10) {
+        missing.push('vision');
+    }
+    if (!brief.target_user || brief.target_user.length <= 5) {
+        missing.push('target_user');
+    }
+    if (!brief.why_now || brief.why_now.length <= 5) {
+        missing.push('why_now');
+    }
+    if (!brief.raw_themes || brief.raw_themes.length < 1) {
+        missing.push('raw_themes');
+    }
+    return {
+        valid: missing.length === 0,
+        missing,
+    };
+}

package/dist/lib/imagine-synthesis.d.ts

@@ -0,0 +1,90 @@
+/**
+ * GSWD Imagine Synthesis Module — Direction synthesis and auto-mode scoring
+ *
+ * Combines research from 5 agents into 3 direction options.
+ * Provides auto-mode scoring (pain x willingness-to-pay x reachability)
+ * for unattended decision-making per GSWD_SPEC Section 8.2 Step 4 and Section 10.
+ *
+ * Schema: GSWD_SPEC.md Section 8.2 Steps 4-5, Section 10
+ */
+import type { AgentResult } from './imagine-agents.js';
+import type { StarterBrief } from './imagine-input.js';
+export interface Direction {
+    label: string;
+    icp_summary: string;
+    problem_framing: string;
+    wedge: string;
+    differentiator: string;
+    risks: string[];
+    rationale?: string[];
+}
+/**
+ * Research summary section for post-agent display.
+ * Produced by buildResearchSummary(), consumed by renderResearchSummary().
+ */
+export interface ResearchSummarySection {
+    agentName: string;
+    displayName: string;
+    takeaways: string[];
+    bridge: string;
+}
+/**
+ * User-friendly display names for imagine agents.
+ */
+export declare const AGENT_DISPLAY_NAMES: Record<string, string>;
+export interface AutoDecision {
+    type: string;
+    chosen: string;
+    rationale: string;
+    score?: number;
+    recorded_at: string;
+}
+export interface SynthesisResult {
+    proposed: Direction;
+    alternatives: Direction[];
+    agent_warnings: string[];
+    raw_agent_outputs: Record<string, string>;
+}
+export interface ScoreEntry {
+    label: string;
+    score: number;
+    rationale: string;
+}
+export interface ScoreResult {
+    index: number;
+    scores: ScoreEntry[];
+}
+/**
+ * Synthesize 5 agent results into 3 direction options.
+ *
+ * Handles missing agent data gracefully — failed agents produce degraded
+ * output with warnings, not crashes.
+ */
+export declare function synthesizeDirections(agentResults: AgentResult[]): SynthesisResult;
+/**
+ * Score directions using pain x willingness-to-pay x reachability heuristic.
+ *
+ * Uses keyword counting as a proxy since these are text-derived signals.
+ * Formula: pain * 0.4 + wtp * 0.3 + reachability * 0.3
+ *
+ * Per GSWD_SPEC: "choose ICP with highest pain x willingness-to-pay x reachability score"
+ */
+export declare function scoreIcpOptions(directions: Direction[]): ScoreResult;
+/**
+ * Build structured research summary from agent results.
+ * Each section: agent display name, 3-5 takeaway bullets, bridging paragraph.
+ * Product-contextualized using brief.vision and brief.target_user.
+ */
+export declare function buildResearchSummary(agentResults: AgentResult[], brief: StarterBrief): ResearchSummarySection[];
+/**
+ * Auto-select the best direction and generate decision records.
+ *
+ * Per GSWD_SPEC Section 8.2 Auto behavior:
+ * - Choose ICP with highest pain x WTP x reachability score
+ * - Choose wedge with smallest scope that still hits an "aha"
+ * - Record decisions as Auto-chosen with rationale
+ */
+export declare function autoSelectDirection(synthesis: SynthesisResult): {
+    selected: Direction;
+    decisions: AutoDecision[];
+};