sdd-cli 0.1.0

package/dist/commands/req-finish.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqFinish = runReqFinish;
+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 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 runReqFinish() {
+    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 jsonFiles = fs_1.default.readdirSync(requirementDir).filter((file) => file.endsWith(".json"));
+    const schemaMap = {
+        "requirement.json": "requirement.schema.json",
+        "functional-spec.json": "functional-spec.schema.json",
+        "technical-spec.json": "technical-spec.schema.json",
+        "architecture.json": "architecture.schema.json",
+        "test-plan.json": "test-plan.schema.json",
+        "quality.json": "quality.schema.json"
+    };
+    for (const file of jsonFiles) {
+        const schema = schemaMap[file];
+        if (!schema)
+            continue;
+        const data = JSON.parse(fs_1.default.readFileSync(path_1.default.join(requirementDir, file), "utf-8"));
+        const result = (0, validate_1.validateJson)(schema, data);
+        if (!result.valid) {
+            console.log(`Validation failed for ${file}:`);
+            result.errors.forEach((error) => console.log(`- ${error}`));
+            return;
+        }
+    }
+    const doneDir = path_1.default.join(workspace.root, projectName, "requirements", "done", reqId);
+    fs_1.default.mkdirSync(path_1.default.dirname(doneDir), { recursive: true });
+    fs_1.default.renameSync(requirementDir, doneDir);
+    (0, index_1.updateProjectStatus)(workspace, projectName, "done");
+    const overview = await (0, prompt_1.ask)("Project overview (for README): ");
+    const howToRun = await (0, prompt_1.ask)("How to run (for README): ");
+    const archSummary = await (0, prompt_1.ask)("Architecture summary (for README): ");
+    const testingNotes = await (0, prompt_1.ask)("Testing notes (for README): ");
+    const readmeTemplate = (0, render_1.loadTemplate)("project-readme");
+    const readmeRendered = (0, render_1.renderTemplate)(readmeTemplate, {
+        project_name: projectName,
+        overview: overview || "N/A",
+        how_to_run: howToRun || "N/A",
+        architecture_summary: archSummary || "N/A",
+        requirements_link: `requirements/done/${reqId}/requirement.md`,
+        functional_spec_link: `requirements/done/${reqId}/functional-spec.md`,
+        technical_spec_link: `requirements/done/${reqId}/technical-spec.md`,
+        architecture_link: `requirements/done/${reqId}/architecture.md`,
+        testing_notes: testingNotes || "N/A"
+    });
+    const readmeJson = {
+        projectName,
+        overview: overview || "N/A",
+        howToRun: howToRun || "N/A",
+        architectureSummary: archSummary || "N/A",
+        specs: {
+            requirements: `requirements/done/${reqId}/requirement.md`,
+            functionalSpec: `requirements/done/${reqId}/functional-spec.md`,
+            technicalSpec: `requirements/done/${reqId}/technical-spec.md`,
+            architecture: `requirements/done/${reqId}/architecture.md`
+        },
+        testingNotes: testingNotes || "N/A"
+    };
+    const readmeValidation = (0, validate_1.validateJson)("project-readme.schema.json", readmeJson);
+    if (!readmeValidation.valid) {
+        console.log("Project README validation failed:");
+        readmeValidation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    const projectRoot = path_1.default.join(workspace.root, projectName);
+    fs_1.default.writeFileSync(path_1.default.join(projectRoot, "project-readme.md"), readmeRendered, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(projectRoot, "project-readme.json"), JSON.stringify(readmeJson, null, 2), "utf-8");
+    const decisionLog = path_1.default.join(doneDir, "decision-log");
+    if (fs_1.default.existsSync(decisionLog)) {
+        const archiveRoot = path_1.default.join(projectRoot, "decision-log", reqId);
+        fs_1.default.mkdirSync(path_1.default.dirname(archiveRoot), { recursive: true });
+        fs_1.default.renameSync(decisionLog, archiveRoot);
+    }
+    const progressLog = path_1.default.join(doneDir, "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()} finished requirement ${reqId}\n`;
+    fs_1.default.appendFileSync(progressLog, logEntry, "utf-8");
+    const changelog = path_1.default.join(doneDir, "changelog.md");
+    if (!fs_1.default.existsSync(changelog)) {
+        fs_1.default.writeFileSync(changelog, "# Changelog\n\n", "utf-8");
+    }
+    const changeEntry = `\n- ${new Date().toISOString()} finished requirement ${reqId}\n`;
+    fs_1.default.appendFileSync(changelog, changeEntry, "utf-8");
+    console.log(`Moved requirement to ${doneDir}`);
+}

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

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

package/dist/commands/req-lint.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.runReqLint = runReqLint;
+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 validate_1 = require("../validation/validate");
+async function runReqLint() {
+    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 locations = ["backlog", "wip", "in-progress", "done", "archived"];
+    const dir = locations
+        .map((status) => path_1.default.join(base, status, reqId))
+        .find((candidate) => fs_1.default.existsSync(candidate));
+    if (!dir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const schemaMap = {
+        "requirement.json": "requirement.schema.json",
+        "functional-spec.json": "functional-spec.schema.json",
+        "technical-spec.json": "technical-spec.schema.json",
+        "architecture.json": "architecture.schema.json",
+        "test-plan.json": "test-plan.schema.json",
+        "quality.json": "quality.schema.json",
+        "project-readme.json": "project-readme.schema.json"
+    };
+    let failures = 0;
+    for (const [file, schema] of Object.entries(schemaMap)) {
+        const filePath = path_1.default.join(dir, file);
+        if (!fs_1.default.existsSync(filePath)) {
+            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: ${file}`);
+            result.errors.forEach((error) => console.log(`- ${error}`));
+        }
+        else {
+            console.log(`Valid: ${file}`);
+        }
+    }
+    if (failures === 0) {
+        console.log("All artifacts valid for this requirement.");
+    }
+}

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

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

package/dist/commands/req-list.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqList = runReqList;
+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 STATUSES = ["backlog", "wip", "in-progress", "done", "archived"];
+async function runReqList(statusFilter) {
+    const projectName = await (0, prompt_1.ask)("Project name: ");
+    if (!projectName) {
+        console.log("Project name is required.");
+        return;
+    }
+    const workspace = (0, index_1.getWorkspaceInfo)();
+    const base = path_1.default.join(workspace.root, projectName, "requirements");
+    if (!fs_1.default.existsSync(base)) {
+        console.log("No requirements found for this project.");
+        return;
+    }
+    const statuses = statusFilter ? STATUSES.filter((status) => status === statusFilter) : STATUSES;
+    for (const status of statuses) {
+        const dir = path_1.default.join(base, status);
+        if (!fs_1.default.existsSync(dir)) {
+            continue;
+        }
+        const items = fs_1.default.readdirSync(dir).filter((entry) => fs_1.default.statSync(path_1.default.join(dir, entry)).isDirectory());
+        if (items.length > 0) {
+            console.log(`${status}:`);
+            items.forEach((item) => console.log(`- ${item}`));
+        }
+    }
+}

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

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

package/dist/commands/req-plan.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqPlan = runReqPlan;
+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);
+    if (fs_1.default.existsSync(backlog))
+        return backlog;
+    if (fs_1.default.existsSync(wip))
+        return wip;
+    return null;
+}
+async function runReqPlan() {
+    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 in backlog or wip.");
+        return;
+    }
+    const requirementJsonPath = path_1.default.join(requirementDir, "requirement.json");
+    if (!fs_1.default.existsSync(requirementJsonPath)) {
+        console.log("Missing requirement.json. Run `req create` first.");
+        return;
+    }
+    const requirementJson = JSON.parse(fs_1.default.readFileSync(requirementJsonPath, "utf-8"));
+    const requirementValidation = (0, validate_1.validateJson)("requirement.schema.json", requirementJson);
+    if (!requirementValidation.valid) {
+        console.log("Requirement validation failed:");
+        requirementValidation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    const wipDir = path_1.default.join(workspace.root, projectName, "requirements", "wip", reqId);
+    if (requirementDir.includes(path_1.default.join("requirements", "backlog"))) {
+        fs_1.default.mkdirSync(path_1.default.dirname(wipDir), { recursive: true });
+        fs_1.default.renameSync(requirementDir, wipDir);
+        (0, index_1.updateProjectStatus)(workspace, projectName, "wip");
+    }
+    const targetDir = fs_1.default.existsSync(wipDir) ? wipDir : requirementDir;
+    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 stack = await (0, prompt_1.ask)("Tech stack - comma separated: ");
+    const interfaces = await (0, prompt_1.ask)("Interfaces - comma separated: ");
+    const dataModel = await (0, prompt_1.ask)("Data model - comma separated: ");
+    const security = await (0, prompt_1.ask)("Security - comma separated: ");
+    const techErrors = await (0, prompt_1.ask)("Error handling - comma separated: ");
+    const performance = await (0, prompt_1.ask)("Performance - comma separated: ");
+    const observability = await (0, prompt_1.ask)("Observability - comma separated: ");
+    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 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 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 technicalJson = {
+        stack: (0, list_1.parseList)(stack),
+        interfaces: (0, list_1.parseList)(interfaces),
+        dataModel: (0, list_1.parseList)(dataModel),
+        security: (0, list_1.parseList)(security),
+        errors: (0, list_1.parseList)(techErrors),
+        performance: (0, list_1.parseList)(performance),
+        observability: (0, list_1.parseList)(observability)
+    };
+    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 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 validations = [
+        (0, validate_1.validateJson)("functional-spec.schema.json", functionalJson),
+        (0, validate_1.validateJson)("technical-spec.schema.json", technicalJson),
+        (0, validate_1.validateJson)("architecture.schema.json", architectureJson),
+        (0, validate_1.validateJson)("test-plan.schema.json", testPlanJson)
+    ];
+    const failures = validations.flatMap((result) => result.errors);
+    if (failures.length > 0) {
+        console.log("Spec validation failed:");
+        failures.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    console.log("Spec validation passed.");
+    const functionalTemplate = (0, render_1.loadTemplate)("functional-spec");
+    const technicalTemplate = (0, render_1.loadTemplate)("technical-spec");
+    const architectureTemplate = (0, render_1.loadTemplate)("architecture");
+    const testPlanTemplate = (0, render_1.loadTemplate)("test-plan");
+    const functionalRendered = (0, render_1.renderTemplate)(functionalTemplate, {
+        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)
+    });
+    const technicalRendered = (0, render_1.renderTemplate)(technicalTemplate, {
+        title: projectName,
+        stack: (0, list_1.formatList)(stack),
+        interfaces: (0, list_1.formatList)(interfaces),
+        data_model: (0, list_1.formatList)(dataModel),
+        security: (0, list_1.formatList)(security),
+        errors: (0, list_1.formatList)(techErrors),
+        performance: (0, list_1.formatList)(performance),
+        observability: (0, list_1.formatList)(observability)
+    });
+    const architectureRendered = (0, render_1.renderTemplate)(architectureTemplate, {
+        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)
+    });
+    const testPlanRendered = (0, render_1.renderTemplate)(testPlanTemplate, {
+        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"
+    });
+    const writes = [
+        [path_1.default.join(targetDir, "functional-spec.md"), functionalRendered],
+        [path_1.default.join(targetDir, "functional-spec.json"), JSON.stringify(functionalJson, null, 2)],
+        [path_1.default.join(targetDir, "technical-spec.md"), technicalRendered],
+        [path_1.default.join(targetDir, "technical-spec.json"), JSON.stringify(technicalJson, null, 2)],
+        [path_1.default.join(targetDir, "architecture.md"), architectureRendered],
+        [path_1.default.join(targetDir, "architecture.json"), JSON.stringify(architectureJson, null, 2)],
+        [path_1.default.join(targetDir, "test-plan.md"), testPlanRendered],
+        [path_1.default.join(targetDir, "test-plan.json"), JSON.stringify(testPlanJson, null, 2)]
+    ];
+    if (flags.parallel) {
+        await Promise.all(writes.map(([filePath, content]) => fs_1.default.promises.writeFile(filePath, content, "utf-8")));
+    }
+    else {
+        writes.forEach(([filePath, content]) => fs_1.default.writeFileSync(filePath, content, "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()} generated specs 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()} planned requirement ${reqId}\n`;
+    fs_1.default.appendFileSync(changelog, changeEntry, "utf-8");
+    console.log(`Generated specs in ${targetDir}`);
+}

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

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

package/dist/commands/req-refine.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqRefine = runReqRefine;
+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 findRequirementFile(workspaceRoot, project, reqId) {
+    const base = path_1.default.join(workspaceRoot, project, "requirements");
+    const candidates = [
+        path_1.default.join(base, "backlog", reqId, "requirement.json"),
+        path_1.default.join(base, "wip", reqId, "requirement.json"),
+        path_1.default.join(base, "in-progress", reqId, "requirement.json"),
+        path_1.default.join(base, "done", reqId, "requirement.json")
+    ];
+    return candidates.find((candidate) => fs_1.default.existsSync(candidate)) ?? null;
+}
+async function runReqRefine() {
+    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 reqPath = findRequirementFile(workspace.root, projectName, reqId);
+    if (!reqPath) {
+        console.log("Requirement not found.");
+        return;
+    }
+    const raw = JSON.parse(fs_1.default.readFileSync(reqPath, "utf-8"));
+    const objective = await (0, prompt_1.ask)(`Objective (${raw.objective}): `);
+    const actors = await (0, prompt_1.ask)("Actors - comma separated: ");
+    const scopeIn = await (0, prompt_1.ask)("Scope (in) - comma separated: ");
+    const scopeOut = await (0, prompt_1.ask)("Scope (out) - comma separated: ");
+    const acceptance = await (0, prompt_1.ask)("Acceptance criteria - comma separated: ");
+    const nfrSecurity = await (0, prompt_1.ask)("NFR security: ");
+    const nfrPerformance = await (0, prompt_1.ask)("NFR performance: ");
+    const nfrAvailability = await (0, prompt_1.ask)("NFR availability: ");
+    const constraints = await (0, prompt_1.ask)("Constraints - comma separated: ");
+    const risks = await (0, prompt_1.ask)("Risks - comma separated: ");
+    const links = await (0, prompt_1.ask)("Links - comma separated: ");
+    const flags = (0, flags_1.getFlags)();
+    const improveNote = flags.improve ? await (0, prompt_1.ask)("Improve focus (optional): ") : "";
+    const updated = {
+        ...raw,
+        objective: objective || raw.objective,
+        actors: actors ? (0, list_1.parseList)(actors) : raw.actors,
+        scope: {
+            in: scopeIn ? (0, list_1.parseList)(scopeIn) : raw.scope.in,
+            out: scopeOut ? (0, list_1.parseList)(scopeOut) : raw.scope.out
+        },
+        acceptanceCriteria: acceptance ? (0, list_1.parseList)(acceptance) : raw.acceptanceCriteria,
+        nfrs: {
+            security: nfrSecurity || raw.nfrs.security,
+            performance: nfrPerformance || raw.nfrs.performance,
+            availability: nfrAvailability || raw.nfrs.availability
+        },
+        constraints: constraints ? (0, list_1.parseList)(constraints) : raw.constraints,
+        risks: risks ? (0, list_1.parseList)(risks) : raw.risks,
+        links: links ? (0, list_1.parseList)(links) : raw.links,
+        updatedAt: new Date().toISOString()
+    };
+    const validation = (0, validate_1.validateJson)("requirement.schema.json", updated);
+    if (!validation.valid) {
+        console.log("Requirement validation failed:");
+        validation.errors.forEach((error) => console.log(`- ${error}`));
+        return;
+    }
+    fs_1.default.writeFileSync(reqPath, JSON.stringify(updated, null, 2), "utf-8");
+    const template = (0, render_1.loadTemplate)("requirement");
+    const rendered = (0, render_1.renderTemplate)(template, {
+        title: updated.title,
+        id: updated.id,
+        objective: updated.objective,
+        actors: (0, list_1.formatList)((updated.actors ?? []).join(", ")),
+        scope_in: (0, list_1.formatList)(updated.scope.in.join(", ")),
+        scope_out: (0, list_1.formatList)(updated.scope.out.join(", ")),
+        acceptance_criteria: (0, list_1.formatList)(updated.acceptanceCriteria.join(", ")),
+        nfr_security: updated.nfrs.security,
+        nfr_performance: updated.nfrs.performance,
+        nfr_availability: updated.nfrs.availability,
+        constraints: (0, list_1.formatList)((updated.constraints ?? []).join(", ")),
+        risks: (0, list_1.formatList)((updated.risks ?? []).join(", ")),
+        links: (0, list_1.formatList)((updated.links ?? []).join(", "))
+    });
+    const mdPath = reqPath.replace("requirement.json", "requirement.md");
+    fs_1.default.writeFileSync(mdPath, rendered, "utf-8");
+    const changelogPath = path_1.default.join(path_1.default.dirname(reqPath), "changelog.md");
+    const logEntry = `\n- ${new Date().toISOString()} refined requirement ${updated.id}\n`;
+    fs_1.default.appendFileSync(changelogPath, logEntry, "utf-8");
+    if (flags.improve) {
+        const progressLog = path_1.default.join(path_1.default.dirname(reqPath), "progress-log.md");
+        if (!fs_1.default.existsSync(progressLog)) {
+            fs_1.default.writeFileSync(progressLog, "# Progress Log\n\n", "utf-8");
+        }
+        const improveEntry = `\n- ${new Date().toISOString()} improve: ${improveNote || "refinement requested"}\n`;
+        fs_1.default.appendFileSync(progressLog, improveEntry, "utf-8");
+    }
+    console.log(`Requirement updated at ${mdPath}`);
+}

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

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

package/dist/commands/req-report.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReqReport = runReqReport;
+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 REQUIRED_FILES = [
+    "requirement.json",
+    "functional-spec.json",
+    "technical-spec.json",
+    "architecture.json",
+    "test-plan.json",
+    "quality.json",
+    "project-readme.json"
+];
+async function runReqReport() {
+    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"];
+    const dir = statuses.map((status) => path_1.default.join(base, status, reqId)).find((candidate) => fs_1.default.existsSync(candidate));
+    if (!dir) {
+        console.log("Requirement not found.");
+        return;
+    }
+    console.log(`Requirement report: ${reqId}`);
+    let missing = 0;
+    for (const file of REQUIRED_FILES) {
+        const exists = fs_1.default.existsSync(path_1.default.join(dir, file));
+        console.log(`${exists ? "OK" : "MISSING"}: ${file}`);
+        if (!exists)
+            missing += 1;
+    }
+    console.log(`Missing files: ${missing}`);
+}

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

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