agent-workflow-kit-cli 1.2.1 → 1.3.1

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/init.js

@@ -30,7 +30,14 @@ function printSuccessAndNextSteps(options) {
 }
 export async function updateGitignore(targetDir, dryRun) {
     const gitignorePath = path.join(targetDir, ".gitignore");
-    const rulesToIgnore = [".cursorrules", ".copilot-instructions.md", ".clinerules"];
+    const rulesToIgnore = [
+        ".cursorrules",
+        ".copilot-instructions.md",
+        ".clinerules",
+        "AGENTS.md",
+        "GEMINI.md",
+        ".agents/"
+    ];
     if (dryRun) {
         console.log(chalk.gray(`[Dry Run] Would update .gitignore in ${targetDir} to exclude IDE rule files.`));
         return;
@@ -78,6 +85,87 @@ async function writeWorkspaceIdeRulesAndGitignore(cwd, options) {
     }
     await updateGitignore(cwd, options.dryRun);
 }
+async function writeDefaultWorkflow(cwd, options) {
+    const workflowsDir = path.join(cwd, ".agents", "workflows");
+    const workflowFile = path.join(workflowsDir, "pr-verification.json");
+    const sampleWorkflow = {
+        id: "pr-verification",
+        name: "Pull Request Verification & ADR Flow",
+        description: "Compiles project, validates architecture boundaries, creates ADR, and requests human sign-off.",
+        version: "1.0.0",
+        supportedArchitectures: ["layered", "clean-architecture", "feature-first"],
+        requiredRoles: ["developer"],
+        graph: {
+            nodes: [
+                {
+                    id: "build-and-lint",
+                    name: "Compile and Lint Check",
+                    type: "task",
+                    executor: "command",
+                    params: {
+                        command: "npm run build || mvn compile || python -m py_compile **/*.py"
+                    },
+                    mockOutput: {
+                        status: "success",
+                        duration: "3.5s"
+                    }
+                },
+                {
+                    id: "verify-architecture",
+                    name: "Verify Layer Boundaries",
+                    type: "task",
+                    executor: "command",
+                    params: {
+                        command: "npx agent-workflow-kit-cli profile"
+                    },
+                    mockOutput: {
+                        violationsFound: 0,
+                        status: "clean"
+                    }
+                },
+                {
+                    id: "create-adr",
+                    name: "Generate Architecture Decision Record",
+                    type: "task",
+                    executor: "adr-generate",
+                    params: {
+                        title: "Automated PR Validation Record",
+                        status: "proposed",
+                        context: "Auto-generated during pipeline test run.",
+                        decision: "All structural layers passed boundary checks successfully.",
+                        consequences: "Workspace rules integrity confirmed."
+                    },
+                    mockOutput: {
+                        adrId: "ADR-0001",
+                        status: "proposed"
+                    }
+                },
+                {
+                    id: "operator-approval",
+                    name: "Operator Sign-off Hook",
+                    type: "approval"
+                }
+            ],
+            edges: [
+                { sourceId: "build-and-lint", targetId: "verify-architecture" },
+                { sourceId: "verify-architecture", targetId: "create-adr" },
+                { sourceId: "create-adr", targetId: "operator-approval" }
+            ]
+        }
+    };
+    if (options.dryRun) {
+        console.log(chalk.gray(`[Dry Run] Would create default workflow under ${workflowFile}`));
+        return;
+    }
+    try {
+        await fs.mkdir(workflowsDir, { recursive: true });
+        await fs.writeFile(workflowFile, JSON.stringify(sampleWorkflow, null, 2), "utf8");
+        console.log(chalk.green("✔️ Created default workflow pack: .agents/workflows/pr-verification.json"));
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`Could not create default workflow: ${err instanceof Error ? err.message : String(err)}`));
+    }
+}
 export async function runInit(options) {
     const cwd = process.cwd();
     console.log(chalk.bold.cyan("\n🚀 Agent Workflow Kit - Initializing..."));
@@ -292,5 +380,7 @@ export async function runInit(options) {
     }
     // Write workspace-level IDE rules and update gitignore
     await writeWorkspaceIdeRulesAndGitignore(cwd, options);
+    // Write default sample workflow DAG
+    await writeDefaultWorkflow(cwd, options);
     printSuccessAndNextSteps(options);
 }

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}`));
+    }
+}