sdd-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const hello_1 = require("./commands/hello");
+const init_1 = require("./commands/init");
+const route_1 = require("./commands/route");
+const doctor_1 = require("./commands/doctor");
+const paths_1 = require("./paths");
+const flags_1 = require("./context/flags");
+const program = new commander_1.Command();
+function getVersion() {
+    try {
+        const pkgPath = path_1.default.join((0, paths_1.getRepoRoot)(), "package.json");
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+program
+    .name("sdd-tool")
+    .description("SDD-first, AI-native CLI")
+    .version(getVersion())
+    .option("--approve", "Skip confirmations if gates pass")
+    .option("--improve", "Trigger self-audit and regenerate")
+    .option("--parallel", "Generate in parallel when supported");
+program.hook("preAction", (thisCommand, actionCommand) => {
+    const opts = typeof actionCommand.optsWithGlobals === "function" ? actionCommand.optsWithGlobals() : thisCommand.opts();
+    (0, flags_1.setFlags)({
+        approve: Boolean(opts.approve),
+        improve: Boolean(opts.improve),
+        parallel: Boolean(opts.parallel)
+    });
+});
+program
+    .command("hello")
+    .description("Start an interactive session and route intent")
+    .argument("[input...]", "Optional input to classify")
+    .option("--questions", "Run prompt questions for detected intent")
+    .option("--auto", "Generate a requirement draft after questions")
+    .action((input, options) => (0, hello_1.runHello)(input.join(" ").trim(), options.questions || options.auto));
+program
+    .command("init")
+    .description("Initialize workspace and config")
+    .action(() => (0, init_1.runInit)());
+program
+    .command("list")
+    .description("List flows, templates, and projects")
+    .action(async () => {
+    const { runList } = await Promise.resolve().then(() => __importStar(require("./commands/list")));
+    runList();
+});
+const req = program.command("req").description("Requirement lifecycle commands");
+req
+    .command("create")
+    .description("Create a new requirement")
+    .action(async () => {
+    const { runReqCreate } = await Promise.resolve().then(() => __importStar(require("./commands/req-create")));
+    await runReqCreate();
+});
+req
+    .command("plan")
+    .description("Generate specs for a requirement")
+    .action(async () => {
+    const { runReqPlan } = await Promise.resolve().then(() => __importStar(require("./commands/req-plan")));
+    await runReqPlan();
+});
+req
+    .command("refine")
+    .description("Refine an existing requirement")
+    .action(async () => {
+    const { runReqRefine } = await Promise.resolve().then(() => __importStar(require("./commands/req-refine")));
+    await runReqRefine();
+});
+req
+    .command("start")
+    .description("Generate implementation plan and quality contract")
+    .action(async () => {
+    const { runReqStart } = await Promise.resolve().then(() => __importStar(require("./commands/req-start")));
+    await runReqStart();
+});
+req
+    .command("finish")
+    .description("Finalize and archive a requirement")
+    .action(async () => {
+    const { runReqFinish } = await Promise.resolve().then(() => __importStar(require("./commands/req-finish")));
+    await runReqFinish();
+});
+req
+    .command("archive")
+    .description("Archive a completed requirement")
+    .action(async () => {
+    const { runReqArchive } = await Promise.resolve().then(() => __importStar(require("./commands/req-archive")));
+    await runReqArchive();
+});
+req
+    .command("list")
+    .description("List requirements by status")
+    .option("--status <status>", "Filter by status")
+    .action(async (options) => {
+    const { runReqList } = await Promise.resolve().then(() => __importStar(require("./commands/req-list")));
+    await runReqList(options.status);
+});
+req
+    .command("status")
+    .description("Show a requirement status")
+    .action(async () => {
+    const { runReqStatus } = await Promise.resolve().then(() => __importStar(require("./commands/req-status")));
+    await runReqStatus();
+});
+req
+    .command("lint")
+    .description("Validate artifacts for a requirement")
+    .action(async () => {
+    const { runReqLint } = await Promise.resolve().then(() => __importStar(require("./commands/req-lint")));
+    await runReqLint();
+});
+req
+    .command("report")
+    .description("Show completeness report for a requirement")
+    .action(async () => {
+    const { runReqReport } = await Promise.resolve().then(() => __importStar(require("./commands/req-report")));
+    await runReqReport();
+});
+req
+    .command("export")
+    .description("Export requirement artifacts to a directory")
+    .action(async () => {
+    const { runReqExport } = await Promise.resolve().then(() => __importStar(require("./commands/req-export")));
+    await runReqExport();
+});
+const pr = program.command("pr").description("PR review workflow commands");
+pr
+    .command("start")
+    .description("Initialize PR review artifacts")
+    .action(async () => {
+    const { runPrStart } = await Promise.resolve().then(() => __importStar(require("./commands/pr-start")));
+    await runPrStart();
+});
+pr
+    .command("audit")
+    .description("Update PR comment audit")
+    .action(async () => {
+    const { runPrAudit } = await Promise.resolve().then(() => __importStar(require("./commands/pr-audit")));
+    await runPrAudit();
+});
+pr
+    .command("respond")
+    .description("Generate a response for a PR comment")
+    .action(async () => {
+    const { runPrRespond } = await Promise.resolve().then(() => __importStar(require("./commands/pr-respond")));
+    await runPrRespond();
+});
+pr
+    .command("finish")
+    .description("Finalize PR review summary")
+    .action(async () => {
+    const { runPrFinish } = await Promise.resolve().then(() => __importStar(require("./commands/pr-finish")));
+    await runPrFinish();
+});
+pr
+    .command("report")
+    .description("Generate PR review report")
+    .action(async () => {
+    const { runPrReport } = await Promise.resolve().then(() => __importStar(require("./commands/pr-report")));
+    await runPrReport();
+});
+const test = program.command("test").description("Test planning commands");
+test
+    .command("plan")
+    .description("Generate or update a test plan")
+    .action(async () => {
+    const { runTestPlan } = await Promise.resolve().then(() => __importStar(require("./commands/test-plan")));
+    await runTestPlan();
+});
+const gen = program.command("gen").description("Artifact generation commands");
+gen
+    .command("requirements")
+    .description("Generate a requirement")
+    .action(async () => {
+    const { runGenRequirements } = await Promise.resolve().then(() => __importStar(require("./commands/gen-requirements")));
+    await runGenRequirements();
+});
+gen
+    .command("functional-spec")
+    .description("Generate a functional spec")
+    .action(async () => {
+    const { runGenFunctionalSpec } = await Promise.resolve().then(() => __importStar(require("./commands/gen-functional-spec")));
+    await runGenFunctionalSpec();
+});
+gen
+    .command("technical-spec")
+    .description("Generate a technical spec")
+    .action(async () => {
+    const { runGenTechnicalSpec } = await Promise.resolve().then(() => __importStar(require("./commands/gen-technical-spec")));
+    await runGenTechnicalSpec();
+});
+gen
+    .command("architecture")
+    .description("Generate an architecture spec")
+    .action(async () => {
+    const { runGenArchitecture } = await Promise.resolve().then(() => __importStar(require("./commands/gen-architecture")));
+    await runGenArchitecture();
+});
+gen
+    .command("best-practices")
+    .description("Generate quality contract")
+    .action(async () => {
+    const { runGenBestPractices } = await Promise.resolve().then(() => __importStar(require("./commands/gen-best-practices")));
+    await runGenBestPractices();
+});
+gen
+    .command("project-readme")
+    .description("Generate project README")
+    .action(async () => {
+    const { runGenProjectReadme } = await Promise.resolve().then(() => __importStar(require("./commands/gen-project-readme")));
+    await runGenProjectReadme();
+});
+const learn = program.command("learn").description("Learning mode commands");
+learn
+    .command("start")
+    .description("Start a learning session")
+    .action(async () => {
+    const { runLearnStart } = await Promise.resolve().then(() => __importStar(require("./commands/learn-start")));
+    await runLearnStart();
+});
+learn
+    .command("refine")
+    .description("Refine a learning session")
+    .action(async () => {
+    const { runLearnRefine } = await Promise.resolve().then(() => __importStar(require("./commands/learn-refine")));
+    await runLearnRefine();
+});
+learn
+    .command("deliver")
+    .description("Deliver learning outputs")
+    .action(async () => {
+    const { runLearnDeliver } = await Promise.resolve().then(() => __importStar(require("./commands/learn-deliver")));
+    await runLearnDeliver();
+});
+program
+    .command("route")
+    .description("Classify intent and select a flow")
+    .argument("<input...>", "Input text to classify")
+    .action((input) => (0, route_1.runRoute)(input.join(" ").trim()));
+program
+    .command("doctor")
+    .description("Validate workspace artifacts and schemas")
+    .argument("[project]", "Optional project name to validate")
+    .argument("[requirementId]", "Optional requirement ID to validate")
+    .action((project, requirementId) => (0, doctor_1.runDoctor)(project, requirementId));
+const ai = program.command("ai").description("Codex provider commands");
+ai
+    .command("status")
+    .description("Check Codex CLI availability")
+    .action(async () => {
+    const { runAiStatus } = await Promise.resolve().then(() => __importStar(require("./commands/ai-status")));
+    runAiStatus();
+});
+ai
+    .command("exec")
+    .description("Run Codex non-interactively")
+    .argument("[prompt...]", "Prompt to execute")
+    .action(async (prompt) => {
+    const { runAiExec } = await Promise.resolve().then(() => __importStar(require("./commands/ai-exec")));
+    await runAiExec(prompt.join(" ").trim());
+});
+program.parse(process.argv);

package/dist/commands/ai-exec.d.ts

@@ -0,0 +1 @@
+export declare function runAiExec(promptArg?: string): Promise<void>;

package/dist/commands/ai-exec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAiExec = runAiExec;
+const codex_1 = require("../providers/codex");
+const prompt_1 = require("../ui/prompt");
+async function runAiExec(promptArg) {
+    const prompt = promptArg || (await (0, prompt_1.ask)("Prompt: "));
+    if (!prompt) {
+        console.log("Prompt is required.");
+        return;
+    }
+    const result = (0, codex_1.codexExec)(prompt);
+    if (!result.ok) {
+        console.log(`Codex error: ${result.error}`);
+        return;
+    }
+    console.log(result.output);
+}

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

@@ -0,0 +1 @@
+export declare function runAiStatus(): void;

package/dist/commands/ai-status.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAiStatus = runAiStatus;
+const codex_1 = require("../providers/codex");
+function runAiStatus() {
+    const result = (0, codex_1.codexVersion)();
+    if (!result.ok) {
+        console.log(`Codex not available: ${result.error}`);
+        return;
+    }
+    console.log(`Codex available: ${result.output}`);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(projectName?: string, reqId?: string): void;

package/dist/commands/doctor.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("../workspace/index");
+const validate_1 = require("../validation/validate");
+const validate_prompt_packs_1 = require("../router/validate-prompt-packs");
+const validate_2 = require("../templates/validate");
+function collectJsonFiles(dir) {
+    if (!fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectJsonFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".json")) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+function inferSchema(filePath) {
+    if (filePath.endsWith("requirement.json"))
+        return "requirement.schema.json";
+    if (filePath.endsWith("technical-spec.json"))
+        return "technical-spec.schema.json";
+    if (filePath.endsWith("functional-spec.json"))
+        return "functional-spec.schema.json";
+    if (filePath.endsWith("architecture.json"))
+        return "architecture.schema.json";
+    if (filePath.endsWith("test-plan.json"))
+        return "test-plan.schema.json";
+    if (filePath.endsWith("quality.json"))
+        return "quality.schema.json";
+    if (filePath.endsWith("project-readme.json"))
+        return "project-readme.schema.json";
+    return null;
+}
+function runDoctor(projectName, reqId) {
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    let root = projectName ? path_1.default.join(workspace.root, projectName) : workspace.root;
+    if (projectName && reqId) {
+        const base = path_1.default.join(workspace.root, projectName, "requirements");
+        const candidates = [
+            path_1.default.join(base, "backlog", reqId),
+            path_1.default.join(base, "wip", reqId),
+            path_1.default.join(base, "in-progress", reqId),
+            path_1.default.join(base, "done", reqId),
+            path_1.default.join(base, "archived", reqId)
+        ];
+        root = candidates.find((candidate) => fs_1.default.existsSync(candidate)) ?? root;
+    }
+    const jsonFiles = collectJsonFiles(root);
+    if (jsonFiles.length === 0) {
+        console.log("No JSON artifacts found in workspace.");
+        return;
+    }
+    let failures = 0;
+    const promptResult = (0, validate_prompt_packs_1.validatePromptPacks)();
+    if (!promptResult.valid) {
+        failures += promptResult.errors.length;
+        console.log("Prompt pack validation failed:");
+        promptResult.errors.forEach((error) => console.log(`- ${error}`));
+    }
+    const templateResult = (0, validate_2.validateTemplates)();
+    if (!templateResult.valid) {
+        failures += templateResult.errors.length;
+        console.log("Template validation failed:");
+        templateResult.errors.forEach((error) => console.log(`- ${error}`));
+    }
+    for (const filePath of jsonFiles) {
+        const schema = inferSchema(filePath);
+        if (!schema) {
+            continue;
+        }
+        const data = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        const result = (0, validate_1.validateJson)(schema, data);
+        if (!result.valid) {
+            failures += 1;
+            console.log(`Invalid: ${filePath}`);
+            result.errors.forEach((error) => console.log(`- ${error}`));
+        }
+        else {
+            console.log(`Valid: ${filePath}`);
+        }
+    }
+    if (failures === 0) {
+        console.log("All JSON artifacts are valid.");
+    }
+    else {
+        console.log(`Validation failed for ${failures} artifact(s).`);
+    }
+}

package/dist/commands/gen-architecture.d.ts

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

package/dist/commands/gen-architecture.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenArchitecture = runGenArchitecture;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const render_1 = require("../templates/render");
+const list_1 = require("../utils/list");
+const validate_1 = require("../validation/validate");
+const gen_utils_1 = require("./gen-utils");
+const flags_1 = require("../context/flags");
+async function runGenArchitecture() {
+    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 requirementDir = (0, gen_utils_1.findRequirementDir)(projectName, reqId);
+    if (!requirementDir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const context = await (0, prompt_1.ask)("Architecture context: ");
+    const containers = await (0, prompt_1.ask)("Containers - comma separated: ");
+    const components = await (0, prompt_1.ask)("Components - comma separated: ");
+    const deployment = await (0, prompt_1.ask)("Deployment - comma separated: ");
+    const diagrams = await (0, prompt_1.ask)("Diagrams - comma separated: ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const architectureJson = {
+        context: context || "N/A",
+        containers: (0, list_1.parseList)(containers),
+        components: (0, list_1.parseList)(components),
+        deployment: (0, list_1.parseList)(deployment),
+        diagrams: (0, list_1.parseList)(diagrams)
+    };
+    const validation = (0, validate_1.validateJson)("architecture.schema.json", architectureJson);
+    if (!validation.valid) {
+        console.log("Architecture validation failed:");
+        validation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    const template = (0, render_1.loadTemplate)("architecture");
+    const rendered = (0, render_1.renderTemplate)(template, {
+        title: projectName,
+        context: context || "N/A",
+        containers: (0, list_1.formatList)(containers),
+        components: (0, list_1.formatList)(components),
+        deployment: (0, list_1.formatList)(deployment),
+        diagrams: (0, list_1.formatList)(diagrams)
+    });
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "architecture.md"), rendered, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "architecture.json"), JSON.stringify(architectureJson, null, 2), "utf-8");
+    (0, gen_utils_1.appendProgress)(requirementDir, `generated architecture for ${reqId}`);
+    (0, gen_utils_1.appendImprove)(requirementDir, improveNote);
+    console.log(`Architecture generated in ${requirementDir}`);
+}

package/dist/commands/gen-best-practices.d.ts

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

package/dist/commands/gen-best-practices.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenBestPractices = runGenBestPractices;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const validate_1 = require("../validation/validate");
+const gen_utils_1 = require("./gen-utils");
+const flags_1 = require("../context/flags");
+function renderQualityYaml(rules, coverage, complexity) {
+    const ruleLines = rules.length > 0 ? rules.map((rule) => `  - ${rule}`).join("\n") : "  - N/A";
+    return [
+        "rules:",
+        ruleLines,
+        "thresholds:",
+        `  coverage: \"${coverage}\"`,
+        `  complexity: \"${complexity}\"`,
+        "profiles:",
+        "  default: []"
+    ].join("\n");
+}
+async function runGenBestPractices() {
+    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 requirementDir = (0, gen_utils_1.findRequirementDir)(projectName, reqId);
+    if (!requirementDir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const rules = await (0, prompt_1.ask)("Quality rules - comma separated: ");
+    const coverage = await (0, prompt_1.ask)("Coverage threshold (e.g., 80%): ");
+    const complexity = await (0, prompt_1.ask)("Complexity threshold (e.g., 10): ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const qualityJson = {
+        rules: rules ? rules.split(",").map((rule) => rule.trim()).filter((rule) => rule) : [],
+        thresholds: {
+            coverage: coverage || "80%",
+            complexity: complexity || "10"
+        },
+        profiles: {
+            default: []
+        }
+    };
+    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;
+    }
+    const qualityYaml = renderQualityYaml(qualityJson.rules, qualityJson.thresholds.coverage, qualityJson.thresholds.complexity);
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "quality.yml"), qualityYaml, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "quality.json"), JSON.stringify(qualityJson, null, 2), "utf-8");
+    (0, gen_utils_1.appendProgress)(requirementDir, `generated quality contract for ${reqId}`);
+    (0, gen_utils_1.appendImprove)(requirementDir, improveNote);
+    console.log(`Quality contract generated in ${requirementDir}`);
+}

package/dist/commands/gen-functional-spec.d.ts

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

package/dist/commands/gen-functional-spec.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenFunctionalSpec = runGenFunctionalSpec;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../ui/prompt");
+const render_1 = require("../templates/render");
+const list_1 = require("../utils/list");
+const validate_1 = require("../validation/validate");
+const gen_utils_1 = require("./gen-utils");
+const flags_1 = require("../context/flags");
+async function runGenFunctionalSpec() {
+    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 requirementDir = (0, gen_utils_1.findRequirementDir)(projectName, reqId);
+    if (!requirementDir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const overview = await (0, prompt_1.ask)("Functional overview: ");
+    const actors = await (0, prompt_1.ask)("Actors - comma separated: ");
+    const useCases = await (0, prompt_1.ask)("Use cases - comma separated: ");
+    const flows = await (0, prompt_1.ask)("Flows - comma separated: ");
+    const rules = await (0, prompt_1.ask)("Business rules - comma separated: ");
+    const errors = await (0, prompt_1.ask)("Errors - comma separated: ");
+    const acceptance = await (0, prompt_1.ask)("Acceptance criteria - comma separated: ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const functionalJson = {
+        overview: overview || "N/A",
+        actors: (0, list_1.parseList)(actors),
+        useCases: (0, list_1.parseList)(useCases),
+        flows: (0, list_1.parseList)(flows),
+        rules: (0, list_1.parseList)(rules),
+        errors: (0, list_1.parseList)(errors),
+        acceptanceCriteria: (0, list_1.parseList)(acceptance)
+    };
+    const validation = (0, validate_1.validateJson)("functional-spec.schema.json", functionalJson);
+    if (!validation.valid) {
+        console.log("Functional spec validation failed:");
+        validation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    const template = (0, render_1.loadTemplate)("functional-spec");
+    const rendered = (0, render_1.renderTemplate)(template, {
+        title: projectName,
+        overview: overview || "N/A",
+        actors: (0, list_1.formatList)(actors),
+        use_cases: (0, list_1.formatList)(useCases),
+        flows: (0, list_1.formatList)(flows),
+        rules: (0, list_1.formatList)(rules),
+        errors: (0, list_1.formatList)(errors),
+        acceptance_criteria: (0, list_1.formatList)(acceptance)
+    });
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "functional-spec.md"), rendered, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(requirementDir, "functional-spec.json"), JSON.stringify(functionalJson, null, 2), "utf-8");
+    (0, gen_utils_1.appendProgress)(requirementDir, `generated functional spec for ${reqId}`);
+    (0, gen_utils_1.appendImprove)(requirementDir, improveNote);
+    console.log(`Functional spec generated in ${requirementDir}`);
+}

package/dist/commands/gen-project-readme.d.ts

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