agent-workflow-kit-cli 1.2.1 → 1.3.0

package/dist/cli/commands/adr.js

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import { ADRService } from "../../core/awos/adr.js";
+export async function createAdrCommand(options) {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n📝 Creating New Architectural Decision Record (ADR)"));
+    console.log(chalk.dim("------------------------------------------"));
+    const title = options.title || "Decision Title";
+    const status = options.status || "proposed";
+    const context = options.context || "Explain the problem or background context.";
+    const decision = options.decision || "Detail what will change and what decision is made.";
+    const consequences = options.consequences || "What are the positive or negative consequences of this path?";
+    const decisionMaker = options.decisionMaker || "AWOS System";
+    const created = await ADRService.create(cwd, {
+        title,
+        status,
+        context,
+        decision,
+        consequences,
+        metadata: {
+            decisionMakerRole: decisionMaker,
+        },
+    });
+    console.log(chalk.bold.green(`\n🎉 ADR Created Successfully!`));
+    console.log(`${chalk.bold("ID:")}      ${created.id}`);
+    console.log(`${chalk.bold("File:")}    docs/adr/${created.id}.md`);
+    console.log(`${chalk.bold("Title:")}   ${created.title}`);
+    console.log(`${chalk.bold("Status:")}  ${created.status}\n`);
+}
+export async function listAdrsCommand() {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n📖 Architectural Decision Records (ADRs)"));
+    console.log(chalk.dim("------------------------------------------"));
+    const list = await ADRService.list(cwd);
+    if (list.length === 0) {
+        console.log(chalk.gray("No ADRs found under 'docs/adr/'."));
+        return;
+    }
+    for (const adr of list) {
+        let statusColor = chalk.yellow;
+        if (adr.status === "accepted")
+            statusColor = chalk.green;
+        else if (adr.status === "rejected")
+            statusColor = chalk.red;
+        else if (adr.status === "superseded")
+            statusColor = chalk.gray;
+        console.log(`${chalk.bold.green(`- ${adr.id}`)}: ${adr.title} (${statusColor(adr.status)}) [${adr.date}]`);
+        if (adr.metadata?.decisionMakerRole) {
+            console.log(chalk.gray(`  Decision Maker: ${adr.metadata.decisionMakerRole}`));
+        }
+    }
+    console.log("");
+}
+export async function showAdrCommand(id) {
+    const cwd = process.cwd();
+    const adr = await ADRService.load(cwd, id);
+    let statusColor = chalk.yellow;
+    if (adr.status === "accepted")
+        statusColor = chalk.green;
+    else if (adr.status === "rejected")
+        statusColor = chalk.red;
+    else if (adr.status === "superseded")
+        statusColor = chalk.gray;
+    console.log(chalk.bold.cyan(`\n🔍 ADR Details: ${adr.id}`));
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(`${chalk.bold("Title:")}        ${adr.title}`);
+    console.log(`${chalk.bold("Date:")}         ${adr.date}`);
+    console.log(`${chalk.bold("Status:")}       ${statusColor(adr.status)}`);
+    if (adr.metadata?.decisionMakerRole) {
+        console.log(`${chalk.bold("Role:")}         ${adr.metadata.decisionMakerRole}`);
+    }
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(chalk.bold("Context:"));
+    console.log(`  ${adr.context}\n`);
+    console.log(chalk.bold("Decision:"));
+    console.log(`  ${adr.decision}\n`);
+    console.log(chalk.bold("Consequences:"));
+    console.log(`  ${adr.consequences}\n`);
+    console.log(chalk.dim("------------------------------------------\n"));
+}
+export async function searchAdrsCommand(keyword) {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan(`\n🔎 Searching ADRs for keyword: '${keyword}'`));
+    console.log(chalk.dim("------------------------------------------"));
+    const results = await ADRService.search(cwd, keyword);
+    if (results.length === 0) {
+        console.log(chalk.yellow("No decisions found matching the keyword."));
+        return;
+    }
+    console.log(chalk.green(`Found ${results.length} matching ADRs:\n`));
+    for (const adr of results) {
+        console.log(`${chalk.bold.green(`- ${adr.id}`)}: ${adr.title} (${adr.status})`);
+    }
+    console.log("");
+}

package/dist/cli/commands/export.js

@@ -101,6 +101,19 @@ export async function runExport(target, options) {
         output += `=============================\n\n`;
     }
     output = output.trim();
+    if (options.output) {
+        console.log(chalk.blue(`Writing exported workflows to file: ${options.output}...`));
+        try {
+            const fullOutputPath = path.resolve(cwd, options.output);
+            await fs.mkdir(path.dirname(fullOutputPath), { recursive: true });
+            await fs.writeFile(fullOutputPath, output, "utf8");
+            console.log(chalk.green(`✔️ Successfully exported ${parsedSkills.length} custom workflow(s) to ${options.output}!`));
+        }
+        catch (err) {
+            console.error(chalk.red(`❌ Failed to write export file: ${err instanceof Error ? err.message : String(err)}`));
+        }
+        return;
+    }
     if (options.clipboard) {
         console.log(chalk.blue("Copying exported workflows to clipboard..."));
         const success = await writeToClipboard(output);

package/dist/cli/commands/profile.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import { getRepositoryContext } from "../../core/awos/intelligence.js";
+import { loadProfile, validateArchitecture } from "../../core/awos/profiles.js";
+export async function runProfileCheck(options) {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n🔎 AWOS Architecture Profile Linter"));
+    console.log(chalk.dim("------------------------------------------"));
+    const context = await getRepositoryContext(cwd);
+    const targetProfileName = options.profile || context.architecture;
+    console.log(`Target Profile: ${chalk.green(targetProfileName)} (detected from ${chalk.yellow(context.stack)})`);
+    console.log(chalk.dim("------------------------------------------\n"));
+    try {
+        const profile = await loadProfile(targetProfileName);
+        console.log(chalk.gray("Scanning workspace files for structural rules constraints..."));
+        const violations = await validateArchitecture(cwd, profile);
+        if (violations.length === 0) {
+            console.log(chalk.bold.green("\n🎉 Congratulations! Zero architecture or package boundaries violations found."));
+            return;
+        }
+        console.log(chalk.bold.red(`\n⚠️ Found ${violations.length} architectural rule violations:\n`));
+        for (const v of violations) {
+            const color = v.severity === "error" ? chalk.red : chalk.yellow;
+            console.log(`${color(`[${v.severity.toUpperCase()}]`)} ${chalk.underline(v.filePath)}`);
+            console.log(chalk.gray(`  Rule: ${v.ruleName} - ${v.message}\n`));
+        }
+        process.exit(1);
+    }
+    catch (err) {
+        throw new Error(`Profile check failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/cli/commands/role.js

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import path from "path";
+import { RoleRegistry } from "../../core/awos/registry.js";
+const DEFAULT_ROLES_DIR = ".agents/roles";
+export async function listRoles() {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n👥 Discovered Agent Role Catalog"));
+    console.log(chalk.dim("------------------------------------------"));
+    const dir = path.join(cwd, DEFAULT_ROLES_DIR);
+    const list = await RoleRegistry.discover(dir);
+    if (list.length === 0) {
+        console.log(chalk.gray(`No roles found under '${DEFAULT_ROLES_DIR}/'.`));
+        return;
+    }
+    for (const role of list) {
+        console.log(`${chalk.bold.green(`- ${role.id}`)}: ${role.name}`);
+        console.log(chalk.gray(`  ${role.description}\n`));
+    }
+}
+export async function showRole(id) {
+    const cwd = process.cwd();
+    const dir = path.join(cwd, DEFAULT_ROLES_DIR);
+    const role = await RoleRegistry.load(id, dir);
+    console.log(chalk.bold.cyan(`\n🔍 Agent Role: ${role.id}`));
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(`${chalk.bold("Name:")}        ${role.name}`);
+    console.log(`${chalk.bold("Description:")} ${role.description}`);
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(chalk.bold("Responsibilities:"));
+    for (const resp of role.responsibilities) {
+        console.log(`  - ${resp}`);
+    }
+    console.log(chalk.bold("\nRequired Inputs:"));
+    for (const inp of role.requiredInputs) {
+        console.log(`  - ${inp}`);
+    }
+    console.log(chalk.bold("\nExpected Outputs:"));
+    for (const out of role.expectedOutputs) {
+        console.log(`  - ${out}`);
+    }
+    console.log(chalk.bold("\nValidation Checklist:"));
+    for (const item of role.validationChecklist) {
+        console.log(`  - ${item}`);
+    }
+    console.log(chalk.bold("\nReview Checklist:"));
+    for (const item of role.reviewChecklist) {
+        console.log(`  - ${item}`);
+    }
+    console.log(chalk.dim("------------------------------------------\n"));
+}
+export async function validateRoles() {
+    const cwd = process.cwd();
+    const dir = path.join(cwd, DEFAULT_ROLES_DIR);
+    try {
+        const list = await RoleRegistry.discover(dir);
+        if (list.length === 0) {
+            console.log(chalk.yellow(`No roles discovered to validate under '${DEFAULT_ROLES_DIR}/'.`));
+            return;
+        }
+        for (const role of list) {
+            RoleRegistry.validate(role);
+            console.log(chalk.green(`✔️ Role '${role.id}' is schema valid.`));
+        }
+        console.log(chalk.bold.green(`\n🎉 All ${list.length} agent roles validated successfully!`));
+    }
+    catch (err) {
+        console.error(chalk.bold.red(`\n❌ Agent Role validation failed:`));
+        console.error(chalk.red(`  ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}

package/dist/cli/commands/run.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import { promises as fs } from "fs";
+import path from "path";
+import { WorkflowRuntime } from "../../core/awos/runtime.js";
+export async function runWorkflowCommand(workflowPath, options) {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n🚀 AWOS Workflow Executor"));
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(`Workflow File: ${chalk.green(workflowPath)}`);
+    console.log(`Dry Run:       ${options.dryRun ? chalk.yellow("Enabled 🧪") : chalk.gray("Disabled")}`);
+    console.log(chalk.dim("------------------------------------------\n"));
+    let graph;
+    try {
+        const fullPath = path.resolve(cwd, workflowPath);
+        const content = await fs.readFile(fullPath, "utf8");
+        graph = JSON.parse(content);
+    }
+    catch (err) {
+        throw new Error(`Failed to load workflow file: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let inputs = {};
+    if (options.inputs) {
+        try {
+            const inputsPath = path.resolve(cwd, options.inputs);
+            const content = await fs.readFile(inputsPath, "utf8");
+            inputs = JSON.parse(content);
+        }
+        catch {
+            // Inline JSON parsing
+            try {
+                inputs = JSON.parse(options.inputs);
+            }
+            catch (err) {
+                throw new Error(`Failed to parse inputs parameters: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    const runtime = new WorkflowRuntime(cwd);
+    const result = await runtime.run(graph, inputs, { dryRun: options.dryRun });
+    console.log(chalk.dim("\n------------------------------------------"));
+    if (result.status === "SUCCESS") {
+        console.log(chalk.bold.green(`✔️ Workflow execution succeeded! Run ID: ${result.runId}`));
+    }
+    else if (result.status === "PAUSED") {
+        console.log(chalk.bold.yellow(`⚠️ Workflow execution paused. Resume using: awk run resume ${result.runId}`));
+    }
+    else {
+        console.log(chalk.bold.red(`❌ Workflow execution failed. Run ID: ${result.runId}`));
+    }
+}
+export async function resumeWorkflowCommand(runId) {
+    const cwd = process.cwd();
+    const runFile = path.resolve(cwd, `.agents/state/runs/${runId}.json`);
+    console.log(chalk.bold.cyan(`\n🚀 AWOS Workflow Executor - Resuming Run '${runId}'`));
+    console.log(chalk.dim("------------------------------------------"));
+    try {
+        const runContent = await fs.readFile(runFile, "utf8");
+        const runState = JSON.parse(runContent);
+        console.log(`Active step state was: ${chalk.yellow(runState.status)}`);
+        // Simulate resumption by completing approval steps
+        runState.status = "EXECUTING";
+        const pausedStepIdx = runState.steps.findIndex((s) => s.status === "WAITING_APPROVAL");
+        if (pausedStepIdx !== -1) {
+            runState.steps[pausedStepIdx].status = "COMPLETED";
+            runState.steps[pausedStepIdx].completedAt = new Date().toISOString();
+            console.log(`✔️ Human approved step: ${chalk.green(runState.steps[pausedStepIdx].name)}`);
+        }
+        await fs.writeFile(runFile, JSON.stringify(runState, null, 2), "utf8");
+        console.log(chalk.green(`✔️ Run '${runId}' successfully resumed & marked completed!`));
+    }
+    catch (err) {
+        throw new Error(`Failed to resume execution run '${runId}': ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/cli/commands/workflow.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import chalk from "chalk";
+import { promises as fs } from "fs";
+import path from "path";
+import { WorkflowRegistry } from "../../core/awos/registry.js";
+import { WorkflowRuntime } from "../../core/awos/runtime.js";
+const DEFAULT_WORKFLOW_DIR = ".agents/workflows";
+export async function listWorkflows() {
+    const cwd = process.cwd();
+    console.log(chalk.bold.cyan("\n📋 Discovered AWOS Workflow Packs"));
+    console.log(chalk.dim("------------------------------------------"));
+    const dir = path.join(cwd, DEFAULT_WORKFLOW_DIR);
+    const list = await WorkflowRegistry.discover(dir);
+    if (list.length === 0) {
+        console.log(chalk.gray(`No workflows found under '${DEFAULT_WORKFLOW_DIR}/'.`));
+        return;
+    }
+    for (const wf of list) {
+        console.log(`${chalk.bold.green(`- ${wf.id}`)} v${wf.version} : ${wf.name}`);
+        console.log(chalk.gray(`  ${wf.description}`));
+        console.log(chalk.gray(`  Roles: ${wf.requiredRoles.join(", ")} | Architectures: ${wf.supportedArchitectures.join(", ")}\n`));
+    }
+}
+export async function showWorkflow(id) {
+    const cwd = process.cwd();
+    const dir = path.join(cwd, DEFAULT_WORKFLOW_DIR);
+    const wf = await WorkflowRegistry.load(id, dir);
+    console.log(chalk.bold.cyan(`\n🔍 Workflow Details: ${wf.id}`));
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(`${chalk.bold("Name:")}        ${wf.name}`);
+    console.log(`${chalk.bold("Version:")}     ${wf.version}`);
+    console.log(`${chalk.bold("Description:")} ${wf.description}`);
+    console.log(`${chalk.bold("Architectures:")} ${wf.supportedArchitectures.join(", ")}`);
+    console.log(`${chalk.bold("Required Roles:")} ${wf.requiredRoles.join(", ")}`);
+    console.log(chalk.dim("------------------------------------------"));
+    console.log(chalk.bold("Graph Execution Steps:"));
+    for (const node of wf.graph.nodes) {
+        const roleStr = node.role ? ` (Role: ${node.role})` : "";
+        const execStr = node.executor ? ` [Executor: ${node.executor}]` : "";
+        console.log(`  - [${node.type.toUpperCase()}] ${chalk.green(node.id)}: "${node.name}"${roleStr}${execStr}`);
+    }
+    console.log(chalk.dim("------------------------------------------\n"));
+}
+export async function validateWorkflow(id) {
+    const cwd = process.cwd();
+    const dir = path.join(cwd, DEFAULT_WORKFLOW_DIR);
+    try {
+        const wf = await WorkflowRegistry.load(id, dir);
+        WorkflowRegistry.validate(wf);
+        console.log(chalk.bold.green(`\n✔️ Workflow '${id}' is structurally valid and acyclic!`));
+    }
+    catch (err) {
+        console.error(chalk.bold.red(`\n❌ Workflow '${id}' is invalid:`));
+        console.error(chalk.red(`  ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+}
+export async function runWorkflowById(id, options) {
+    const cwd = process.cwd();
+    const dir = path.join(cwd, DEFAULT_WORKFLOW_DIR);
+    const wf = await WorkflowRegistry.load(id, dir);
+    let inputs = {};
+    if (options.inputs) {
+        try {
+            const inputsPath = path.resolve(cwd, options.inputs);
+            const content = await fs.readFile(inputsPath, "utf8");
+            inputs = JSON.parse(content);
+        }
+        catch {
+            try {
+                inputs = JSON.parse(options.inputs);
+            }
+            catch (err) {
+                throw new Error(`Failed to parse inputs parameters: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    console.log(chalk.bold.cyan(`\n🚀 Executing Discovered Workflow: ${wf.id}`));
+    console.log(chalk.dim("------------------------------------------"));
+    const runtime = new WorkflowRuntime(cwd);
+    const result = await runtime.run(wf.graph, inputs, { dryRun: options.dryRun });
+    console.log(chalk.dim("\n------------------------------------------"));
+    if (result.status === "SUCCESS") {
+        console.log(chalk.bold.green(`✔️ Workflow execution succeeded! Run ID: ${result.runId}`));
+    }
+    else if (result.status === "PAUSED") {
+        console.log(chalk.bold.yellow(`⚠️ Workflow execution paused. Resume using: awk resume ${result.runId}`));
+    }
+    else {
+        console.log(chalk.bold.red(`❌ Workflow execution failed. Run ID: ${result.runId}`));
+    }
+}

package/dist/cli/index.js

@@ -9,12 +9,17 @@ import { runAdd } from "./commands/add.js";
 import { runSync } from "./commands/sync.js";
 import { runDoctor } from "./commands/doctor.js";
 import { runExport } from "./commands/export.js";
+import { runWorkflowCommand, resumeWorkflowCommand } from "./commands/run.js";
+import { runProfileCheck } from "./commands/profile.js";
+import { listWorkflows, showWorkflow, validateWorkflow, runWorkflowById } from "./commands/workflow.js";
+import { listRoles, showRole, validateRoles } from "./commands/role.js";
+import { createAdrCommand, listAdrsCommand, showAdrCommand, searchAdrsCommand } from "./commands/adr.js";
 const program = new Command();
 export function runCli() {
     program
         .name("agent-workflow-kit")
         .description("Generate AI coding workflows/rules/templates for Codex and Antigravity")
-        .version("1.2.1");
+        .version("1.3.0");
     program
         .command("init")
         .description("Initialize agent guidelines and skills for the repository")
@@ -75,14 +80,200 @@ export function runCli() {
         .command("export <target>")
         .description("Export custom workflows/skills for the target agent (e.g., 'antigravity')")
         .option("--no-clipboard", "Do not copy the exported instructions to clipboard", false)
+        .option("-o, --output <file>", "Write the exported guidelines to a specific file")
         .action(async (target, options) => {
         try {
-            await runExport(target, { clipboard: options.clipboard });
+            await runExport(target, { clipboard: options.clipboard, output: options.output });
         }
         catch (err) {
             console.error(chalk.red(`Error running export: ${err instanceof Error ? err.message : String(err)}`));
             process.exit(1);
         }
     });
+    program
+        .command("run <workflow>")
+        .description("Execute an AWOS graph workflow")
+        .option("--inputs <inputs>", "Path to input JSON file or inline JSON string")
+        .option("--dry-run", "Execute workflow steps in simulation mode", false)
+        .action(async (workflow, options) => {
+        try {
+            await runWorkflowCommand(workflow, options);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error running workflow: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command("resume <runId>")
+        .description("Resume a suspended AWOS workflow")
+        .action(async (runId) => {
+        try {
+            await resumeWorkflowCommand(runId);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error resuming workflow: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    program
+        .command("profile")
+        .description("Validate directory architecture structure and rules boundaries")
+        .option("--profile <profile>", "Target profile name (e.g. clean-architecture)")
+        .action(async (options) => {
+        try {
+            await runProfileCheck(options);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error validation profile rules: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // --- Workflow Group Subcommands ---
+    const workflowCmd = program.command("workflow").description("Manage and execute AWOS workflow packs");
+    workflowCmd
+        .command("list")
+        .description("List discovered workflow packs")
+        .action(async () => {
+        try {
+            await listWorkflows();
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    workflowCmd
+        .command("show <id>")
+        .description("Show workflow pack steps and metadata")
+        .action(async (id) => {
+        try {
+            await showWorkflow(id);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    workflowCmd
+        .command("validate <id>")
+        .description("Validate a workflow pack schema and graph cyclic constraints")
+        .action(async (id) => {
+        try {
+            await validateWorkflow(id);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    workflowCmd
+        .command("run <id>")
+        .description("Run a registered workflow pack by ID")
+        .option("--inputs <inputs>", "Path to inputs parameter JSON file or inline string")
+        .option("--dry-run", "Run nodes in dry-run mode", false)
+        .action(async (id, options) => {
+        try {
+            await runWorkflowById(id, options);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error running workflow: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // --- Role Group Subcommands ---
+    const roleCmd = program.command("role").description("Manage agent role profiles");
+    roleCmd
+        .command("list")
+        .description("List all discovered role profiles in catalog")
+        .action(async () => {
+        try {
+            await listRoles();
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    roleCmd
+        .command("show <id>")
+        .description("Show agent role details, checklists and inputs schema")
+        .action(async (id) => {
+        try {
+            await showRole(id);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    roleCmd
+        .command("validate")
+        .description("Validate all roles catalog files schema parameters")
+        .action(async () => {
+        try {
+            await validateRoles();
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    // --- ADR Group Subcommands ---
+    const adrCmd = program.command("adr").description("Manage Architectural Decision Records");
+    adrCmd
+        .command("create")
+        .description("Create a new numbered architectural decision record (ADR)")
+        .option("--title <title>", "ADR decision title")
+        .option("--status <status>", "Initial status: proposed | accepted | rejected | superseded", "proposed")
+        .option("--context <context>", "Context background explanation")
+        .option("--decision <decision>", "Architectural decision detail statement")
+        .option("--consequences <consequences>", "Repercussions of decision taken")
+        .option("--decision-maker <maker>", "Role or name of decider", "AWOS System")
+        .action(async (options) => {
+        try {
+            await createAdrCommand(options);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    adrCmd
+        .command("list")
+        .description("List all saved ADR documents")
+        .action(async () => {
+        try {
+            await listAdrsCommand();
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    adrCmd
+        .command("show <id>")
+        .description("Display details of a numbered ADR document")
+        .action(async (id) => {
+        try {
+            await showAdrCommand(id);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
+    adrCmd
+        .command("search <keyword>")
+        .description("Search all ADR documents for keyword text matches")
+        .action(async (keyword) => {
+        try {
+            await searchAdrsCommand(keyword);
+        }
+        catch (err) {
+            console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    });
     program.parse(process.argv);
 }