sdd-cli 0.1.18 → 0.1.20

package/README.md

@@ -157,11 +157,18 @@ Use `--questions` when you want the manual question-by-question flow.
 - `sdd-cli init` -- create SDD workspace and config
 - `sdd-cli list` -- list flows, router flows, templates, prompt packs, and projects
 - `sdd-cli status --next` -- show current project state and exact next command
+- `sdd-cli scope list` -- list monorepo workspace scopes
+- `sdd-cli scope status <scope>` -- show status summary for one scope
 - `sdd-cli doctor` -- validate completeness and consistency
+  - `sdd-cli doctor --fix` -- apply safe remediations for missing requirement ops files
 
 ### Router
 - `sdd-cli route` -- classify user intent and route to the right flow
 
+### Imports
+- `sdd-cli import issue <github-issue-url>` -- import issue context and bootstrap autopilot
+- `sdd-cli import jira <ticket-or-browse-url>` -- import Jira context and bootstrap autopilot
+
 ### Requirement lifecycle
 - `sdd-cli req create`
 - `sdd-cli req refine`
@@ -185,10 +192,22 @@ Use `--questions` when you want the manual question-by-question flow.
 - `sdd-cli learn refine`
 - `sdd-cli learn deliver`
 
+### PR review
+- `sdd-cli pr start`
+- `sdd-cli pr audit`
+- `sdd-cli pr respond`
+- `sdd-cli pr finish`
+- `sdd-cli pr report`
+- `sdd-cli pr bridge`
+- `sdd-cli pr risk`
+- `sdd-cli pr bridge-check`
+
 ### Flags
 - `--approve` -- run without extra confirmations
 - `--improve` -- re-open and enhance existing docs
 - `--output <path>` -- override workspace output
+- `--scope <name>` -- isolate artifacts by monorepo scope namespace
+- `--metrics-local` -- record local opt-in telemetry snapshots in `workspace/metrics`
 - `--project <name>` -- set project name
 - `--parallel` -- generate in parallel
 - `--questions` -- use manual question-driven discovery flow
@@ -232,6 +251,8 @@ For a full onboarding walkthrough, see:
 
 - Adoption execution tracker: `AGENTS.md`
 - 90-day roadmap: `docs/ADOPTION_ROADMAP_90D.md`
+- Value backlog: `docs/VALUE_BACKLOG.md`
+- Error codes and remediation guide: `docs/ERROR_CODES.md`
 
 ## Where files are stored (clean repos)
 
@@ -244,6 +265,29 @@ By default, the tool writes to a dedicated workspace, not into your repo:
 Optional:
 - `--output ./docs/sdd` to keep SDD next to the repo
 - `--output ../_sdd/<project>` for a separate shared directory
+- `--scope apps-payments` to isolate workspaces for one monorepo domain
+
+## Release notes automation
+
+- Generate notes from conventional commits:
+`npm run release:notes`
+- Write notes to `docs/releases/<version>.md`:
+`npm run release:notes -- --write --version v0.1.20`
+- Generate post-release quality summary:
+`npm run release:metrics`
+- Promote `Unreleased` changelog entries into a version:
+`npm run release:changelog -- --version v0.1.20`
+- Verify tag/version consistency:
+`npm run verify:release-tag -- --tag v0.1.20`
+- Verify npm publish bundle before publishing:
+`npm run verify:publish`
+
+## Local metrics (opt-in)
+
+- Enable local snapshots:
+`sdd-cli --metrics-local hello "your intent"`
+- View summary from current workspace root:
+`npm run metrics:summary -- <workspace-path>`
 
 ## Lifecycle folders
 

package/dist/cli.js

@@ -46,9 +46,12 @@ const route_1 = require("./commands/route");
 const doctor_1 = require("./commands/doctor");
 const quickstart_1 = require("./commands/quickstart");
 const status_1 = require("./commands/status");
+const import_issue_1 = require("./commands/import-issue");
+const import_jira_1 = require("./commands/import-jira");
 const paths_1 = require("./paths");
 const flags_1 = require("./context/flags");
 const prompt_1 = require("./ui/prompt");
+const local_metrics_1 = require("./telemetry/local-metrics");
 const program = new commander_1.Command();
 function getVersion() {
     try {
@@ -72,7 +75,9 @@ program
     .option("--beginner", "Enable extra step-by-step guidance in hello flow")
     .option("--from-step <step>", "Resume or start autopilot from step: create|plan|start|test|finish")
     .option("--project <name>", "Select or name the project")
-    .option("--output <path>", "Override workspace output root");
+    .option("--output <path>", "Override workspace output root")
+    .option("--scope <name>", "Target a monorepo scope namespace inside the workspace")
+    .option("--metrics-local", "Enable local opt-in telemetry snapshots in workspace/metrics");
 program.hook("preAction", (thisCommand, actionCommand) => {
     const opts = typeof actionCommand.optsWithGlobals === "function" ? actionCommand.optsWithGlobals() : thisCommand.opts();
     (0, flags_1.setFlags)({
@@ -84,8 +89,14 @@ program.hook("preAction", (thisCommand, actionCommand) => {
         beginner: Boolean(opts.beginner),
         fromStep: typeof opts.fromStep === "string" ? opts.fromStep : undefined,
         project: typeof opts.project === "string" ? opts.project : undefined,
-        output: typeof opts.output === "string" ? opts.output : undefined
+        output: typeof opts.output === "string" ? opts.output : undefined,
+        scope: typeof opts.scope === "string" ? opts.scope : undefined,
+        metricsLocal: Boolean(opts.metricsLocal)
     });
+    const commandPath = typeof actionCommand.name === "function"
+        ? `${thisCommand.name()} ${actionCommand.name()}`.trim()
+        : thisCommand.name();
+    (0, local_metrics_1.recordCommandMetric)(commandPath);
 });
 program.hook("postAction", () => {
     (0, prompt_1.closePrompt)();
@@ -119,6 +130,22 @@ program
     .description("Show project requirement counts and next recommended command")
     .option("--next", "Print exact next command to run")
     .action((options) => (0, status_1.runStatus)(Boolean(options.next)));
+const scopeCmd = program.command("scope").description("Monorepo scope workspace commands");
+scopeCmd
+    .command("list")
+    .description("List known workspace scopes")
+    .action(async () => {
+    const { runScopeList } = await Promise.resolve().then(() => __importStar(require("./commands/scope-list")));
+    runScopeList();
+});
+scopeCmd
+    .command("status")
+    .description("Show project status summary for a scope")
+    .argument("[scope]", "Scope name")
+    .action(async (scope) => {
+    const { runScopeStatus } = await Promise.resolve().then(() => __importStar(require("./commands/scope-status")));
+    runScopeStatus(scope);
+});
 const req = program.command("req").description("Requirement lifecycle commands");
 req
     .command("create")
@@ -234,6 +261,27 @@ pr
     const { runPrReport } = await Promise.resolve().then(() => __importStar(require("./commands/pr-report")));
     await runPrReport();
 });
+pr
+    .command("bridge")
+    .description("Link PR review artifacts into a requirement")
+    .action(async () => {
+    const { runPrBridge } = await Promise.resolve().then(() => __importStar(require("./commands/pr-bridge")));
+    await runPrBridge();
+});
+pr
+    .command("risk")
+    .description("Generate PR risk severity rollup and unresolved summary")
+    .action(async () => {
+    const { runPrRisk } = await Promise.resolve().then(() => __importStar(require("./commands/pr-risk")));
+    await runPrRisk();
+});
+pr
+    .command("bridge-check")
+    .description("Validate PR bridge integrity for a requirement")
+    .action(async () => {
+    const { runPrBridgeCheck } = await Promise.resolve().then(() => __importStar(require("./commands/pr-bridge-check")));
+    await runPrBridgeCheck();
+});
 const test = program.command("test").description("Test planning commands");
 test
     .command("plan")
@@ -317,7 +365,8 @@ program
     .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));
+    .option("--fix", "Apply safe remediations (missing changelog/progress-log)")
+    .action((project, requirementId, options) => (0, doctor_1.runDoctor)(project, requirementId, Boolean(options.fix)));
 const ai = program.command("ai").description("Codex provider commands");
 ai
     .command("status")
@@ -334,4 +383,19 @@ ai
     const { runAiExec } = await Promise.resolve().then(() => __importStar(require("./commands/ai-exec")));
     await runAiExec(prompt.join(" ").trim());
 });
+const importCmd = program.command("import").description("Import external work items into SDD flow");
+importCmd
+    .command("issue")
+    .description("Import a GitHub issue URL and bootstrap autopilot")
+    .argument("<url>", "GitHub issue URL")
+    .action(async (url) => {
+    await (0, import_issue_1.runImportIssue)(url);
+});
+importCmd
+    .command("jira")
+    .description("Import a Jira ticket and bootstrap autopilot")
+    .argument("<ticket>", "Jira ticket key or browse URL")
+    .action(async (ticket) => {
+    await (0, import_jira_1.runImportJira)(ticket);
+});
 program.parse(process.argv);

package/dist/commands/ai-exec.js

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

package/dist/commands/ai-status.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAiStatus = runAiStatus;
 const codex_1 = require("../providers/codex");
+const errors_1 = require("../errors");
 function runAiStatus() {
     const result = (0, codex_1.codexVersion)();
     if (!result.ok) {
-        console.log(`Codex not available: ${result.error}`);
+        (0, errors_1.printError)("SDD-1503", `Codex not available: ${result.error}`);
         return;
     }
     console.log(`Codex available: ${result.output}`);

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -44,15 +44,177 @@ function inferSchema(filePath) {
         return "project-readme.schema.json";
     return null;
 }
-function runDoctor(projectName, reqId) {
+function printError(code, message) {
+    console.log(`[${code}] ${message}`);
+}
+function ensureOpsFiles(requirementDir) {
+    const fixed = [];
+    const changelog = path_1.default.join(requirementDir, "changelog.md");
+    const progressLog = path_1.default.join(requirementDir, "progress-log.md");
+    if (!fs_1.default.existsSync(changelog)) {
+        fs_1.default.writeFileSync(changelog, "# Changelog\n\n", "utf-8");
+        fixed.push(changelog);
+    }
+    if (!fs_1.default.existsSync(progressLog)) {
+        fs_1.default.writeFileSync(progressLog, "# Progress Log\n\n", "utf-8");
+        fixed.push(progressLog);
+    }
+    return fixed;
+}
+function ensureRequirementsLayout(projectRoot) {
+    const fixed = [];
+    const statuses = ["backlog", "wip", "in-progress", "done", "archived"];
+    const base = path_1.default.join(projectRoot, "requirements");
+    fs_1.default.mkdirSync(base, { recursive: true });
+    for (const status of statuses) {
+        const dir = path_1.default.join(base, status);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+            fixed.push(dir);
+        }
+    }
+    return fixed;
+}
+function inferRequirementStatus(requirementDir) {
+    const parts = requirementDir.split(path_1.default.sep);
+    const reqIdx = parts.lastIndexOf("requirements");
+    if (reqIdx >= 0 && parts[reqIdx + 1]) {
+        return parts[reqIdx + 1];
+    }
+    return "backlog";
+}
+function buildJsonSkeleton(fileName, reqId, status) {
+    if (fileName === "requirement.json") {
+        return {
+            id: reqId,
+            title: reqId,
+            objective: "Autofixed requirement placeholder",
+            status,
+            actors: ["user"],
+            scope: { in: ["core workflow"], out: ["to refine"] },
+            acceptanceCriteria: ["placeholder acceptance criteria"],
+            nfrs: {
+                security: "baseline",
+                performance: "baseline",
+                availability: "baseline"
+            },
+            constraints: [],
+            risks: [],
+            links: [],
+            updatedAt: new Date().toISOString()
+        };
+    }
+    if (fileName === "functional-spec.json") {
+        return {
+            overview: "autofixed functional overview",
+            actors: ["user"],
+            useCases: ["placeholder use case"],
+            flows: ["placeholder flow"],
+            rules: ["placeholder rule"],
+            errors: ["placeholder error"],
+            acceptanceCriteria: ["placeholder acceptance"]
+        };
+    }
+    if (fileName === "technical-spec.json") {
+        return {
+            stack: ["node"],
+            interfaces: ["cli"],
+            dataModel: ["requirement json"],
+            security: ["baseline"],
+            errors: ["handled"],
+            performance: ["baseline"],
+            observability: ["logs"]
+        };
+    }
+    if (fileName === "architecture.json") {
+        return {
+            context: "autofixed architecture context",
+            containers: ["cli runtime"],
+            components: ["commands"],
+            deployment: ["local"],
+            diagrams: ["context.mmd"]
+        };
+    }
+    if (fileName === "test-plan.json") {
+        return {
+            criticalPaths: ["placeholder path"],
+            edgeCases: ["placeholder edge case"],
+            coverageTarget: "80%",
+            acceptanceTests: ["placeholder acceptance test"],
+            regressions: ["placeholder regression"]
+        };
+    }
+    if (fileName === "quality.json") {
+        return {
+            rules: ["single-responsibility"],
+            thresholds: { coverage: "80%", complexity: "10" },
+            profiles: {}
+        };
+    }
+    return {};
+}
+function expectedJsonByStatus(status) {
+    if (status === "wip") {
+        return ["requirement.json", "functional-spec.json", "technical-spec.json", "architecture.json", "test-plan.json"];
+    }
+    if (status === "in-progress" || status === "done") {
+        return [
+            "requirement.json",
+            "functional-spec.json",
+            "technical-spec.json",
+            "architecture.json",
+            "test-plan.json",
+            "quality.json"
+        ];
+    }
+    return ["requirement.json"];
+}
+function ensureJsonSkeletons(requirementDir) {
+    const fixed = [];
+    const status = inferRequirementStatus(requirementDir);
+    const reqId = path_1.default.basename(requirementDir);
+    for (const fileName of expectedJsonByStatus(status)) {
+        const filePath = path_1.default.join(requirementDir, fileName);
+        if (fs_1.default.existsSync(filePath)) {
+            continue;
+        }
+        const payload = buildJsonSkeleton(fileName, reqId, status);
+        fs_1.default.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf-8");
+        fixed.push(filePath);
+    }
+    return fixed;
+}
+function collectRequirementDirs(root) {
+    const base = path_1.default.join(root, "requirements");
+    const statuses = ["backlog", "wip", "in-progress", "done", "archived"];
+    const dirs = [];
+    for (const status of statuses) {
+        const statusDir = path_1.default.join(base, status);
+        if (!fs_1.default.existsSync(statusDir)) {
+            continue;
+        }
+        const entries = fs_1.default.readdirSync(statusDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                dirs.push(path_1.default.join(statusDir, entry.name));
+            }
+        }
+    }
+    return dirs;
+}
+function runDoctor(projectName, reqId, autoFix) {
     const workspace = (0, index_1.getWorkspaceInfo)();
+    (0, index_1.ensureWorkspace)(workspace);
     let root = workspace.root;
+    let projectRootForFix = root;
     if (projectName) {
         try {
             root = (0, index_1.getProjectInfo)(workspace, projectName).root;
+            projectRootForFix = root;
         }
         catch (error) {
-            console.log(error.message);
+            printError("SDD-2001", error.message);
+            process.exitCode = 1;
             return;
         }
     }
@@ -67,18 +229,44 @@ function runDoctor(projectName, reqId) {
         ];
         root = candidates.find((candidate) => fs_1.default.existsSync(candidate)) ?? root;
     }
+    const rootForFixReport = projectRootForFix;
     let failures = 0;
+    let fixes = 0;
+    const fixEntries = [];
     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}`));
+        printError("SDD-2002", "Prompt pack validation failed:");
+        promptResult.errors.forEach((error) => printError("SDD-2002", 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}`));
+        printError("SDD-2003", "Template validation failed:");
+        templateResult.errors.forEach((error) => printError("SDD-2003", error));
+    }
+    if (autoFix) {
+        const layoutFixed = ensureRequirementsLayout(projectRootForFix);
+        fixes += layoutFixed.length;
+        layoutFixed.forEach((dir) => {
+            fixEntries.push(dir);
+            console.log(`[SDD-2009] Fixed: ${dir}`);
+        });
+        const requirementDirs = reqId ? [root] : collectRequirementDirs(root);
+        for (const dir of requirementDirs) {
+            const fixed = ensureOpsFiles(dir);
+            fixes += fixed.length;
+            fixed.forEach((filePath) => {
+                fixEntries.push(filePath);
+                console.log(`[SDD-2004] Fixed: ${filePath}`);
+            });
+            const jsonFixed = ensureJsonSkeletons(dir);
+            fixes += jsonFixed.length;
+            jsonFixed.forEach((filePath) => {
+                fixEntries.push(filePath);
+                console.log(`[SDD-2008] Fixed: ${filePath}`);
+            });
+        }
     }
     const jsonFiles = collectJsonFiles(root);
     if (jsonFiles.length === 0) {
@@ -89,17 +277,36 @@ function runDoctor(projectName, reqId) {
         if (!schema) {
             continue;
         }
-        const data = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        let data;
+        try {
+            data = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        }
+        catch (error) {
+            failures += 1;
+            printError("SDD-2005", `Invalid JSON: ${filePath}`);
+            printError("SDD-2005", error.message);
+            continue;
+        }
         const result = (0, validate_1.validateJson)(schema, data);
         if (!result.valid) {
             failures += 1;
-            console.log(`Invalid: ${filePath}`);
-            result.errors.forEach((error) => console.log(`- ${error}`));
+            printError("SDD-2006", `Invalid: ${filePath}`);
+            result.errors.forEach((error) => printError("SDD-2006", error));
         }
         else {
             console.log(`Valid: ${filePath}`);
         }
     }
+    if (fixes > 0) {
+        console.log(`[SDD-2004] Applied fixes: ${fixes}`);
+        const report = {
+            generatedAt: new Date().toISOString(),
+            root: rootForFixReport,
+            fixes,
+            entries: fixEntries
+        };
+        fs_1.default.writeFileSync(path_1.default.join(rootForFixReport, "doctor-fix-report.json"), JSON.stringify(report, null, 2), "utf-8");
+    }
     if (failures === 0 && jsonFiles.length > 0) {
         console.log("All JSON artifacts are valid.");
     }
@@ -107,6 +314,7 @@ function runDoctor(projectName, reqId) {
         console.log("Prompt packs and templates are valid.");
     }
     else {
-        console.log(`Validation failed for ${failures} artifact(s).`);
+        printError("SDD-2007", `Validation failed for ${failures} artifact(s).`);
+        process.exitCode = 1;
     }
 }

package/dist/commands/gen-architecture.js

@@ -13,11 +13,12 @@ const validate_1 = require("../validation/validate");
 const gen_utils_1 = require("./gen-utils");
 const flags_1 = require("../context/flags");
 const index_1 = require("../workspace/index");
+const errors_1 = require("../errors");
 async function runGenArchitecture() {
     const projectName = await (0, prompt_1.askProjectName)();
     const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
     if (!projectName || !reqId) {
-        console.log("Project name and requirement ID are required.");
+        (0, errors_1.printError)("SDD-1631", "Project name and requirement ID are required.");
         return;
     }
     const workspace = (0, index_1.getWorkspaceInfo)();
@@ -26,12 +27,12 @@ async function runGenArchitecture() {
         project = (0, index_1.getProjectInfo)(workspace, projectName);
     }
     catch (error) {
-        console.log(error.message);
+        (0, errors_1.printError)("SDD-1632", error.message);
         return;
     }
     const requirementDir = (0, gen_utils_1.findRequirementDir)(project.name, reqId);
     if (!requirementDir) {
-        console.log("Requirement not found.");
+        (0, errors_1.printError)("SDD-1633", "Requirement not found.");
         return;
     }
     const context = await (0, prompt_1.ask)("Architecture context: ");
@@ -50,8 +51,8 @@ async function runGenArchitecture() {
     };
     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}`));
+        (0, errors_1.printError)("SDD-1634", "Architecture validation failed.");
+        validation.errors.forEach((error) => (0, errors_1.printError)("SDD-1634", error));
         return;
     }
     const template = (0, render_1.loadTemplate)("architecture");

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

@@ -11,6 +11,7 @@ const validate_1 = require("../validation/validate");
 const gen_utils_1 = require("./gen-utils");
 const flags_1 = require("../context/flags");
 const index_1 = require("../workspace/index");
+const errors_1 = require("../errors");
 function renderQualityYaml(rules, coverage, complexity) {
     const ruleLines = rules.length > 0 ? rules.map((rule) => `  - ${rule}`).join("\n") : "  - N/A";
     return [
@@ -27,7 +28,7 @@ async function runGenBestPractices() {
     const projectName = await (0, prompt_1.askProjectName)();
     const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
     if (!projectName || !reqId) {
-        console.log("Project name and requirement ID are required.");
+        (0, errors_1.printError)("SDD-1641", "Project name and requirement ID are required.");
         return;
     }
     const workspace = (0, index_1.getWorkspaceInfo)();
@@ -36,12 +37,12 @@ async function runGenBestPractices() {
         project = (0, index_1.getProjectInfo)(workspace, projectName);
     }
     catch (error) {
-        console.log(error.message);
+        (0, errors_1.printError)("SDD-1642", error.message);
         return;
     }
     const requirementDir = (0, gen_utils_1.findRequirementDir)(project.name, reqId);
     if (!requirementDir) {
-        console.log("Requirement not found.");
+        (0, errors_1.printError)("SDD-1643", "Requirement not found.");
         return;
     }
     const rules = await (0, prompt_1.ask)("Quality rules - comma separated: ");
@@ -61,8 +62,8 @@ async function runGenBestPractices() {
     };
     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}`));
+        (0, errors_1.printError)("SDD-1644", "Quality validation failed.");
+        validation.errors.forEach((error) => (0, errors_1.printError)("SDD-1644", error));
         return;
     }
     const qualityYaml = renderQualityYaml(qualityJson.rules, qualityJson.thresholds.coverage, qualityJson.thresholds.complexity);

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

@@ -13,11 +13,12 @@ const validate_1 = require("../validation/validate");
 const gen_utils_1 = require("./gen-utils");
 const flags_1 = require("../context/flags");
 const index_1 = require("../workspace/index");
+const errors_1 = require("../errors");
 async function runGenFunctionalSpec() {
     const projectName = await (0, prompt_1.askProjectName)();
     const reqId = await (0, prompt_1.ask)("Requirement ID (REQ-...): ");
     if (!projectName || !reqId) {
-        console.log("Project name and requirement ID are required.");
+        (0, errors_1.printError)("SDD-1611", "Project name and requirement ID are required.");
         return;
     }
     const workspace = (0, index_1.getWorkspaceInfo)();
@@ -26,12 +27,12 @@ async function runGenFunctionalSpec() {
         project = (0, index_1.getProjectInfo)(workspace, projectName);
     }
     catch (error) {
-        console.log(error.message);
+        (0, errors_1.printError)("SDD-1612", error.message);
         return;
     }
     const requirementDir = (0, gen_utils_1.findRequirementDir)(project.name, reqId);
     if (!requirementDir) {
-        console.log("Requirement not found.");
+        (0, errors_1.printError)("SDD-1613", "Requirement not found.");
         return;
     }
     const overview = await (0, prompt_1.ask)("Functional overview: ");
@@ -54,8 +55,8 @@ async function runGenFunctionalSpec() {
     };
     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}`));
+        (0, errors_1.printError)("SDD-1614", "Functional spec validation failed.");
+        validation.errors.forEach((error) => (0, errors_1.printError)("SDD-1614", error));
         return;
     }
     const template = (0, render_1.loadTemplate)("functional-spec");