sdd-cli 0.1.0

package/dist/commands/req-start.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqStart = runReqStart;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const flags_1 = require("../context/flags");
+const index_1 = require("../workspace/index");
+const render_1 = require("../templates/render");
+const list_1 = require("../utils/list");
+const validate_1 = require("../validation/validate");
+function findRequirementDir(workspaceRoot, project, reqId) {
+    const backlog = path_1.default.join(workspaceRoot, project, "requirements", "backlog", reqId);
+    const wip = path_1.default.join(workspaceRoot, project, "requirements", "wip", reqId);
+    const inProgress = path_1.default.join(workspaceRoot, project, "requirements", "in-progress", reqId);
+    if (fs_1.default.existsSync(backlog))
+        return backlog;
+    if (fs_1.default.existsSync(wip))
+        return wip;
+    if (fs_1.default.existsSync(inProgress))
+        return inProgress;
+    return null;
+}
+async function runReqStart() {
+    const projectName = await (0, prompt_1.ask)("Project name: ");
+    const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
+    if (!projectName || !reqId) {
+        console.log("Project name and requirement ID are required.");
+        return;
+    }
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    const requirementDir = findRequirementDir(workspace.root, projectName, reqId);
+    if (!requirementDir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const requiredSpecs = [
+        { file: "functional-spec.json", schema: "functional-spec.schema.json" },
+        { file: "technical-spec.json", schema: "technical-spec.schema.json" },
+        { file: "architecture.json", schema: "architecture.schema.json" },
+        { file: "test-plan.json", schema: "test-plan.schema.json" }
+    ];
+    const missing = requiredSpecs.filter((spec) => !fs_1.default.existsSync(path_1.default.join(requirementDir, spec.file)));
+    if (missing.length > 0) {
+        console.log("Cannot start. Missing specs:");
+        missing.forEach((spec) => console.log(`- ${spec.file}`));
+        return;
+    }
+    for (const spec of requiredSpecs) {
+        const data = JSON.parse(fs_1.default.readFileSync(path_1.default.join(requirementDir, spec.file), "utf-8"));
+        const result = (0, validate_1.validateJson)(spec.schema, data);
+        if (!result.valid) {
+            console.log(`Spec validation failed for ${spec.file}:`);
+            result.errors.forEach((error) => console.log(`- ${error}`));
+            return;
+        }
+    }
+    const inProgressDir = path_1.default.join(workspace.root, projectName, "requirements", "in-progress", reqId);
+    if (!requirementDir.includes(path_1.default.join("requirements", "in-progress"))) {
+        fs_1.default.mkdirSync(path_1.default.dirname(inProgressDir), { recursive: true });
+        fs_1.default.renameSync(requirementDir, inProgressDir);
+        (0, index_1.updateProjectStatus)(workspace, projectName, "in-progress");
+    }
+    const targetDir = fs_1.default.existsSync(inProgressDir) ? inProgressDir : requirementDir;
+    const milestones = await (0, prompt_1.ask)("Milestones - comma separated: ");
+    const tasks = await (0, prompt_1.ask)("Tasks - comma separated: ");
+    const dependencies = await (0, prompt_1.ask)("Dependencies - comma separated: ");
+    const risks = await (0, prompt_1.ask)("Risks - comma separated: ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const implementationTemplate = (0, render_1.loadTemplate)("implementation-plan");
+    const rendered = (0, render_1.renderTemplate)(implementationTemplate, {
+        title: projectName,
+        milestones: (0, list_1.formatList)(milestones),
+        tasks: (0, list_1.formatList)(tasks),
+        dependencies: (0, list_1.formatList)(dependencies),
+        risks: (0, list_1.formatList)(risks)
+    });
+    const qualityPath = path_1.default.join(targetDir, "quality.yml");
+    if (!fs_1.default.existsSync(qualityPath)) {
+        const qualityTemplate = (0, render_1.loadTemplate)("quality");
+        fs_1.default.writeFileSync(qualityPath, qualityTemplate, "utf-8");
+    }
+    const qualityJson = {
+        rules: ["single-responsibility", "tests-for-critical-flows"],
+        thresholds: { coverage: "80%", complexity: "10" },
+        profiles: {}
+    };
+    const validation = (0, validate_1.validateJson)("quality.schema.json", qualityJson);
+    if (!validation.valid) {
+        console.log("Quality validation failed:");
+        validation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    fs_1.default.writeFileSync(path_1.default.join(targetDir, "implementation-plan.md"), rendered, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(targetDir, "quality.json"), JSON.stringify(qualityJson, null, 2), "utf-8");
+    const decisionTemplate = (0, render_1.loadTemplate)("decision-log");
+    const decisionRendered = (0, render_1.renderTemplate)(decisionTemplate, {
+        id: "ADR-0001",
+        title: "Initial implementation plan",
+        status: "accepted",
+        context: "Implementation kickoff",
+        decision: "Proceed with planned milestones",
+        consequences: "Defines first iteration scope",
+        date: new Date().toISOString()
+    });
+    const decisionDir = path_1.default.join(targetDir, "decision-log");
+    fs_1.default.mkdirSync(decisionDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(decisionDir, "ADR-0001.md"), decisionRendered, "utf-8");
+    const progressLog = path_1.default.join(targetDir, "progress-log.md");
+    if (!fs_1.default.existsSync(progressLog)) {
+        fs_1.default.writeFileSync(progressLog, "# Progress Log\n\n", "utf-8");
+    }
+    const logEntry = `\n- ${new Date().toISOString()} started implementation for ${reqId}\n`;
+    fs_1.default.appendFileSync(progressLog, logEntry, "utf-8");
+    if (flags.improve) {
+        const improveEntry = `\n- ${new Date().toISOString()} improve: ${improveNote || "refinement requested"}\n`;
+        fs_1.default.appendFileSync(progressLog, improveEntry, "utf-8");
+    }
+    const changelog = path_1.default.join(targetDir, "changelog.md");
+    if (!fs_1.default.existsSync(changelog)) {
+        fs_1.default.writeFileSync(changelog, "# Changelog\n\n", "utf-8");
+    }
+    const changeEntry = `\n- ${new Date().toISOString()} started implementation for ${reqId}\n`;
+    fs_1.default.appendFileSync(changelog, changeEntry, "utf-8");
+    console.log(`Implementation plan generated in ${targetDir}`);
+    console.log(`Status updated to in-progress for ${projectName}`);
+}

package/dist/commands/req-status.d.ts

@@ -0,0 +1 @@
+export declare function runReqStatus(): Promise<void>;

package/dist/commands/req-status.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqStatus = runReqStatus;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const index_1 = require("../workspace/index");
+async function runReqStatus() {
+    const projectName = await (0, prompt_1.ask)("Project name: ");
+    const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
+    if (!projectName || !reqId) {
+        console.log("Project name and requirement ID are required.");
+        return;
+    }
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    const base = path_1.default.join(workspace.root, projectName, "requirements");
+    const statuses = ["backlog", "wip", "in-progress", "done", "archived"];
+    for (const status of statuses) {
+        const candidate = path_1.default.join(base, status, reqId);
+        if (fs_1.default.existsSync(candidate)) {
+            console.log(`${reqId} is in ${status}`);
+            return;
+        }
+    }
+    console.log("Requirement not found.");
+}

package/dist/commands/route.d.ts

@@ -0,0 +1 @@
+export declare function runRoute(input: string): void;

package/dist/commands/route.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRoute = runRoute;
+const intent_1 = require("../router/intent");
+const flow_1 = require("../router/flow");
+const prompt_packs_1 = require("../router/prompt-packs");
+function runRoute(input) {
+    const intent = (0, intent_1.classifyIntent)(input);
+    const flow = (0, flow_1.loadFlow)(intent.flow);
+    const packs = (0, prompt_packs_1.loadPromptPacks)();
+    const packIds = intent_1.FLOW_PROMPT_PACKS[intent.flow] ?? [];
+    console.log(JSON.stringify(intent, null, 2));
+    if (flow) {
+        console.log("\n--- Flow script ---\n");
+        console.log(flow);
+    }
+    else {
+        console.log("\nNo flow script found.");
+    }
+    if (packIds.length > 0) {
+        console.log("\n--- Prompt packs ---\n");
+        for (const packId of packIds) {
+            const pack = (0, prompt_packs_1.getPromptPackById)(packs, packId);
+            if (!pack)
+                continue;
+            console.log(`Pack: ${pack.id}`);
+            pack.questions.forEach((question) => console.log(`- ${question}`));
+        }
+    }
+}

package/dist/commands/test-plan.d.ts

@@ -0,0 +1 @@
+export declare function runTestPlan(): Promise<void>;

package/dist/commands/test-plan.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTestPlan = runTestPlan;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const index_1 = require("../workspace/index");
+const render_1 = require("../templates/render");
+const list_1 = require("../utils/list");
+const validate_1 = require("../validation/validate");
+const flags_1 = require("../context/flags");
+function findRequirementDir(workspaceRoot, project, reqId) {
+    const base = path_1.default.join(workspaceRoot, project, "requirements");
+    const statuses = ["backlog", "wip", "in-progress", "done", "archived"];
+    for (const status of statuses) {
+        const candidate = path_1.default.join(base, status, reqId);
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function runTestPlan() {
+    const projectName = await (0, prompt_1.ask)("Project name: ");
+    const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
+    if (!projectName || !reqId) {
+        console.log("Project name and requirement ID are required.");
+        return;
+    }
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    const requirementDir = findRequirementDir(workspace.root, projectName, reqId);
+    if (!requirementDir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const criticalPaths = await (0, prompt_1.ask)("Test critical paths - comma separated: ");
+    const edgeCases = await (0, prompt_1.ask)("Test edge cases - comma separated: ");
+    const acceptanceTests = await (0, prompt_1.ask)("Acceptance tests - comma separated: ");
+    const regressions = await (0, prompt_1.ask)("Regression tests - comma separated: ");
+    const coverageTarget = await (0, prompt_1.ask)("Coverage target: ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const testPlanJson = {
+        criticalPaths: (0, list_1.parseList)(criticalPaths),
+        edgeCases: (0, list_1.parseList)(edgeCases),
+        coverageTarget: coverageTarget || "N/A",
+        acceptanceTests: (0, list_1.parseList)(acceptanceTests),
+        regressions: (0, list_1.parseList)(regressions)
+    };
+    const validation = (0, validate_1.validateJson)("test-plan.schema.json", testPlanJson);
+    if (!validation.valid) {
+        console.log("Test plan validation failed:");
+        validation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    const template = (0, render_1.loadTemplate)("test-plan");
+    const rendered = (0, render_1.renderTemplate)(template, {
+        title: projectName,
+        critical_paths: (0, list_1.formatList)(criticalPaths),
+        edge_cases: (0, list_1.formatList)(edgeCases),
+        acceptance_tests: (0, list_1.formatList)(acceptanceTests),
+        regressions: (0, list_1.formatList)(regressions),
+        coverage_target: coverageTarget || "N/A"
+    });
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "test-plan.md"), rendered, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "test-plan.json"), JSON.stringify(testPlanJson, null, 2), "utf-8");
+    const progressLog = path_1.default.join(requirementDir, "progress-log.md");
+    if (!fs_1.default.existsSync(progressLog)) {
+        fs_1.default.writeFileSync(progressLog, "# Progress Log\n\n", "utf-8");
+    }
+    const logEntry = `\n- ${new Date().toISOString()} updated test plan for ${reqId}\n`;
+    fs_1.default.appendFileSync(progressLog, logEntry, "utf-8");
+    if (flags.improve) {
+        const improveEntry = `\n- ${new Date().toISOString()} improve: ${improveNote || "refinement requested"}\n`;
+        fs_1.default.appendFileSync(progressLog, improveEntry, "utf-8");
+    }
+    console.log(`Test plan updated in ${requirementDir}`);
+}

package/dist/context/flags.d.ts

@@ -0,0 +1,7 @@
+export type RuntimeFlags = {
+    approve: boolean;
+    improve: boolean;
+    parallel: boolean;
+};
+export declare function setFlags(next: Partial<RuntimeFlags>): void;
+export declare function getFlags(): RuntimeFlags;

package/dist/context/flags.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFlags = setFlags;
+exports.getFlags = getFlags;
+const flags = {
+    approve: false,
+    improve: false,
+    parallel: false
+};
+function setFlags(next) {
+    flags.approve = Boolean(next.approve);
+    flags.improve = Boolean(next.improve);
+    flags.parallel = Boolean(next.parallel);
+}
+function getFlags() {
+    return { ...flags };
+}

package/dist/paths.d.ts

@@ -0,0 +1 @@
+export declare function getRepoRoot(): string;

package/dist/paths.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepoRoot = getRepoRoot;
+const path_1 = __importDefault(require("path"));
+function getRepoRoot() {
+    return path_1.default.resolve(__dirname, "..");
+}

package/dist/providers/codex.d.ts

@@ -0,0 +1,7 @@
+export type CodexResult = {
+    ok: boolean;
+    output: string;
+    error?: string;
+};
+export declare function codexVersion(): CodexResult;
+export declare function codexExec(prompt: string): CodexResult;

package/dist/providers/codex.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexVersion = codexVersion;
+exports.codexExec = codexExec;
+const child_process_1 = require("child_process");
+function codexVersion() {
+    const result = (0, child_process_1.spawnSync)("codex --version", { encoding: "utf-8", shell: true });
+    if (result.status !== 0) {
+        return { ok: false, output: "", error: result.stderr || "codex not available" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}
+function codexExec(prompt) {
+    const result = (0, child_process_1.spawnSync)(`codex exec "${prompt}"`, { encoding: "utf-8", shell: true });
+    if (result.status !== 0) {
+        return { ok: false, output: result.stdout || "", error: result.stderr || "codex exec failed" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}

package/dist/router/flow.d.ts

@@ -0,0 +1 @@
+export declare function loadFlow(flowId: string): string | null;

package/dist/router/flow.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFlow = loadFlow;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+function loadFlow(flowId) {
+    const root = (0, paths_1.getRepoRoot)();
+    const flowPath = path_1.default.join(root, "router", `${flowId}.flow.md`);
+    if (!fs_1.default.existsSync(flowPath)) {
+        return null;
+    }
+    return fs_1.default.readFileSync(flowPath, "utf-8");
+}

package/dist/router/intent.d.ts

@@ -0,0 +1,3 @@
+import { RouterIntent } from "../types";
+export declare const FLOW_PROMPT_PACKS: Record<string, string[]>;
+export declare function classifyIntent(input: string): RouterIntent;

package/dist/router/intent.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLOW_PROMPT_PACKS = void 0;
+exports.classifyIntent = classifyIntent;
+const SIGNALS = [
+    { intent: "bug_fix", flow: "BUG_FIX", domain: "bug_fix", keywords: ["bug", "issue", "error", "crash", "stack"] },
+    { intent: "pr_review", flow: "PR_REVIEW", domain: "pr_review", keywords: ["pr", "pull request", "review"] },
+    {
+        intent: "learning",
+        flow: "HUMANITIES",
+        domain: "humanities",
+        keywords: ["history", "sociology", "anthropology", "philosophy", "literature", "humanities"]
+    },
+    {
+        intent: "learning",
+        flow: "LEARN",
+        domain: "learning",
+        keywords: ["learn", "explain", "teach me", "what is", "course", "syllabus", "lesson", "student", "teacher"]
+    },
+    { intent: "design", flow: "DESIGN", domain: "design", keywords: ["logo", "brand", "layout", "visual", "design"] },
+    { intent: "data_science", flow: "DATA_SCIENCE", domain: "data_science", keywords: ["model", "dataset", "prediction", "ml"] },
+    { intent: "business", flow: "BUSINESS", domain: "business", keywords: ["pricing", "market", "forecast", "economics"] },
+    { intent: "business", flow: "BUSINESS", domain: "business", keywords: ["ecommerce", "retail", "inventory", "checkout"] },
+    {
+        intent: "legal",
+        flow: "LEGAL",
+        domain: "legal",
+        keywords: ["court", "law", "policy", "compliance", "lawyer", "tax", "audit", "regulation"]
+    },
+    {
+        intent: "software",
+        flow: "SOFTWARE_FEATURE",
+        domain: "software",
+        keywords: ["feature", "api", "backend", "frontend", "implement", "developer", "refactor", "code"]
+    }
+];
+exports.FLOW_PROMPT_PACKS = {
+    BUG_FIX: ["discovery.core", "bug_fix.core"],
+    PR_REVIEW: ["pr_review.core", "review.severity"],
+    SOFTWARE_FEATURE: ["discovery.core", "release.rollout"],
+    DATA_SCIENCE: ["discovery.core", "data.monitoring"],
+    DESIGN: ["discovery.core", "design.accessibility"],
+    HUMANITIES: ["discovery.core", "humanities.sources"],
+    BUSINESS: ["discovery.core", "business.sensitivity"],
+    LEGAL: ["discovery.core", "legal.compliance"],
+    LEARN: ["discovery.core", "learn.format"],
+    GENERIC: ["discovery.core"]
+};
+function classifyIntent(input) {
+    const normalized = input.toLowerCase();
+    for (const rule of SIGNALS) {
+        if (rule.keywords.some((keyword) => normalized.includes(keyword))) {
+            return {
+                intent: rule.intent,
+                confidence: 0.7,
+                flow: rule.flow,
+                domain: rule.domain,
+                signals: rule.keywords.filter((keyword) => normalized.includes(keyword))
+            };
+        }
+    }
+    return {
+        intent: "generic",
+        confidence: 0.3,
+        flow: "GENERIC",
+        domain: "generic",
+        signals: []
+    };
+}

package/dist/router/prompt-map.d.ts

@@ -0,0 +1 @@
+export declare function mapAnswersToRequirement(answers: Record<string, string>): Record<string, string>;

package/dist/router/prompt-map.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAnswersToRequirement = mapAnswersToRequirement;
+function mapAnswersToRequirement(answers) {
+    const objective = answers["What is the objective?"] ?? "N/A";
+    const actors = answers["Who are the users and actors?"] ?? "";
+    const scope = answers["What is in scope and out of scope?"] ?? "";
+    const acceptance = answers["What are the acceptance criteria?"] ?? "";
+    const nfrs = answers["What NFRs apply (security, performance, availability)?"] ?? "";
+    return {
+        objective,
+        actors,
+        scope_in: scope,
+        scope_out: "",
+        acceptance_criteria: acceptance,
+        nfr_security: nfrs,
+        nfr_performance: nfrs,
+        nfr_availability: nfrs
+    };
+}

package/dist/router/prompt-packs.d.ts

@@ -0,0 +1,8 @@
+export type PromptPack = {
+    id: string;
+    questions: string[];
+    gates: string[];
+    followUps?: string[];
+};
+export declare function loadPromptPacks(): PromptPack[];
+export declare function getPromptPackById(packs: PromptPack[], id: string): PromptPack | undefined;

package/dist/router/prompt-packs.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPromptPacks = loadPromptPacks;
+exports.getPromptPackById = getPromptPackById;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+function loadPromptPacks() {
+    const root = (0, paths_1.getRepoRoot)();
+    const packPath = path_1.default.join(root, "templates", "prompt-pack-index.json");
+    const raw = fs_1.default.readFileSync(packPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.packs ?? [];
+}
+function getPromptPackById(packs, id) {
+    return packs.find((pack) => pack.id === id);
+}

package/dist/router/validate-prompt-packs.d.ts

@@ -0,0 +1,4 @@
+export declare function validatePromptPacks(): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/router/validate-prompt-packs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePromptPacks = validatePromptPacks;
+const validate_1 = require("../validation/validate");
+const prompt_packs_1 = require("./prompt-packs");
+function validatePromptPacks() {
+    const packs = (0, prompt_packs_1.loadPromptPacks)();
+    const errors = [];
+    for (const pack of packs) {
+        const result = (0, validate_1.validateJson)("prompt-pack.schema.json", pack);
+        if (!result.valid) {
+            errors.push(...result.errors.map((error) => `${pack.id}: ${error}`));
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/templates/render.d.ts

@@ -0,0 +1,2 @@
+export declare function loadTemplate(name: string): string;
+export declare function renderTemplate(template: string, data: Record<string, string>): string;

package/dist/templates/render.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplate = loadTemplate;
+exports.renderTemplate = renderTemplate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+function loadTemplate(name) {
+    const root = (0, paths_1.getRepoRoot)();
+    const mdPath = path_1.default.join(root, "templates", `${name}.md`);
+    const ymlPath = path_1.default.join(root, "templates", `${name}.yml`);
+    const filePath = fs_1.default.existsSync(mdPath) ? mdPath : ymlPath;
+    return fs_1.default.readFileSync(filePath, "utf-8");
+}
+function renderTemplate(template, data) {
+    let output = template;
+    for (const [key, value] of Object.entries(data)) {
+        const token = `{{${key}}}`;
+        output = output.split(token).join(value);
+    }
+    return output;
+}

package/dist/templates/validate.d.ts

@@ -0,0 +1,4 @@
+export declare function validateTemplates(): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/templates/validate.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTemplates = validateTemplates;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+function extractPlaceholders(template) {
+    const matches = template.matchAll(/{{\s*([a-zA-Z0-9_]+)\s*}}/g);
+    const placeholders = new Set();
+    for (const match of matches) {
+        placeholders.add(match[1]);
+    }
+    return Array.from(placeholders);
+}
+function normalize(values) {
+    return Array.from(new Set(values)).sort();
+}
+function validateTemplates() {
+    const errors = [];
+    const root = (0, paths_1.getRepoRoot)();
+    const templatesDir = path_1.default.join(root, "templates");
+    const indexPath = path_1.default.join(templatesDir, "template-index.json");
+    if (!fs_1.default.existsSync(indexPath)) {
+        return { valid: false, errors: ["Missing templates/template-index.json"] };
+    }
+    const index = JSON.parse(fs_1.default.readFileSync(indexPath, "utf-8"));
+    const indexByName = new Map(index.templates.map((entry) => [entry.name, entry]));
+    const templateFiles = fs_1.default
+        .readdirSync(templatesDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".yml")))
+        .map((entry) => entry.name);
+    const fileByName = new Map(templateFiles.map((file) => [path_1.default.parse(file).name, path_1.default.join(templatesDir, file)]));
+    for (const entry of index.templates) {
+        if (!fileByName.has(entry.name)) {
+            errors.push(`Template index entry missing file: ${entry.name}`);
+        }
+    }
+    for (const [name, filePath] of fileByName.entries()) {
+        const content = fs_1.default.readFileSync(filePath, "utf-8");
+        const placeholders = normalize(extractPlaceholders(content));
+        if (placeholders.length === 0) {
+            continue;
+        }
+        const entry = indexByName.get(name);
+        if (!entry) {
+            errors.push(`Template file missing index entry: ${name}`);
+            continue;
+        }
+        const indexed = normalize(entry.placeholders);
+        if (indexed.join("|") !== placeholders.join("|")) {
+            errors.push(`Template placeholder mismatch: ${name} (index=${indexed.join(", ")} file=${placeholders.join(", ")})`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type RouterIntent = {
+    intent: "bug_fix" | "pr_review" | "learning" | "design" | "data_science" | "business" | "legal" | "software" | "generic";
+    confidence: number;
+    flow: string;
+    domain: "bug_fix" | "pr_review" | "learning" | "humanities" | "design" | "data_science" | "business" | "legal" | "software" | "generic";
+    signals: string[];
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function ask(question: string): Promise<string>;
+export declare function confirm(question: string): Promise<boolean>;