igel-qe-core 1.0.5 → 1.0.8

package/dist/cli/index.js

@@ -1,86 +1,670 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import chalk from "chalk";
-import { spawn } from "child_process";
+import { spawn, spawnSync, execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import { setupPlatform } from "./platform.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Project root is 2 levels up from dist/cli/
+const PROJECT_ROOT = join(__dirname, "..", "..");
 const program = new Command();
 program
     .name("igel-qe")
     .description("IGEL QE Developer Experience CLI")
     .version("1.0.0");
+// ── helpers ────────────────────────────────────────────────────────────────────
+function getPythonBin() {
+    const venv = join(PROJECT_ROOT, ".venv", "bin", "python");
+    return existsSync(venv) ? venv : "python3";
+}
+function resolveRequirementsPath() {
+    const primary = join(PROJECT_ROOT, "requirements.txt");
+    if (existsSync(primary))
+        return primary;
+    const fallback = join(PROJECT_ROOT, "src", "deploy", "requirements.txt");
+    if (existsSync(fallback))
+        return fallback;
+    return null;
+}
+const EXCLUDED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    ".github",
+    ".vscode",
+    ".venv",
+    "__pycache__",
+    "dist",
+    "build",
+    ".idea",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ai",
+]);
+const AUTOMATION_ROOT_HINTS = [
+    "tests",
+    "test",
+    "specs",
+    "pages",
+    "page_objects",
+    "pom",
+    "fixtures",
+    "utils",
+    "helpers",
+    "utilities",
+    "api",
+    "api_clients",
+    "services",
+    "testdata",
+    "test_data",
+    "data",
+    "config",
+    "core",
+    "ui",
+];
+function pathDepth(base, target) {
+    const rel = target.replace(base, "").replace(/^\//, "");
+    if (!rel)
+        return 0;
+    return rel.split("/").filter(Boolean).length;
+}
+function buildContextTemplate(workspaceRoot, dirPath) {
+    const rel = dirPath === workspaceRoot ? "." : dirPath.replace(`${workspaceRoot}/`, "");
+    return [
+        `# Context - ${rel}`,
+        "",
+        "## Purpose",
+        `Describe the responsibility of this folder (${rel}) in the automation framework.`,
+        "",
+        "## Key Assets",
+        "List important files, modules, fixtures, page objects, utilities, and test data here.",
+        "",
+        "## Conventions",
+        "Document naming patterns, coding standards, and folder-specific rules.",
+        "",
+        "## Risks and Dependencies",
+        "Capture external dependencies, brittle areas, and environment assumptions.",
+        "",
+    ].join("\n");
+}
+function detectAutomationRoots(workspaceRoot) {
+    const roots = [];
+    for (const d of AUTOMATION_ROOT_HINTS) {
+        const p = join(workspaceRoot, d);
+        if (existsSync(p)) {
+            try {
+                if (statSync(p).isDirectory())
+                    roots.push(p);
+            }
+            catch {
+                // Ignore unreadable entries.
+            }
+        }
+    }
+    return roots;
+}
+function scaffoldFrameworkContexts(workspaceRoot) {
+    const written = [];
+    const queue = [];
+    // Whole framework-level context at repository root.
+    const rootContext = join(workspaceRoot, "context.md");
+    if (!existsSync(rootContext)) {
+        writeFileSync(rootContext, buildContextTemplate(workspaceRoot, workspaceRoot), "utf-8");
+        written.push(rootContext);
+    }
+    const roots = detectAutomationRoots(workspaceRoot);
+    for (const r of roots)
+        queue.push(r);
+    // Fallback: if no known automation roots are found, traverse top-level folders.
+    if (queue.length === 0) {
+        try {
+            for (const entry of readdirSync(workspaceRoot)) {
+                if (EXCLUDED_DIRS.has(entry) || entry.startsWith("."))
+                    continue;
+                const full = join(workspaceRoot, entry);
+                if (existsSync(full) && statSync(full).isDirectory())
+                    queue.push(full);
+            }
+        }
+        catch {
+            // Ignore traversal issues.
+        }
+    }
+    // Traverse root hints and all subfolders under them, excluding noisy/system dirs.
+    for (let i = 0; i < queue.length; i += 1) {
+        const current = queue[i];
+        const baseName = current.split("/").pop() || "";
+        if (EXCLUDED_DIRS.has(baseName) || baseName.startsWith("."))
+            continue;
+        const contextPath = join(current, "context.md");
+        if (!existsSync(contextPath)) {
+            writeFileSync(contextPath, buildContextTemplate(workspaceRoot, current), "utf-8");
+            written.push(contextPath);
+        }
+        try {
+            const entries = readdirSync(current);
+            for (const entry of entries) {
+                if (EXCLUDED_DIRS.has(entry) || entry.startsWith("."))
+                    continue;
+                const full = join(current, entry);
+                if (!existsSync(full) || !statSync(full).isDirectory())
+                    continue;
+                // Guard against excessive recursive scaffolding in very deep trees.
+                if (pathDepth(workspaceRoot, full) <= 8) {
+                    queue.push(full);
+                }
+            }
+        }
+        catch {
+            // Ignore unreadable directories.
+        }
+    }
+    return written;
+}
+function listFrameworkContextFiles(workspaceRoot) {
+    const found = [];
+    const queue = [workspaceRoot];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        let entries = [];
+        try {
+            entries = readdirSync(current);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = join(current, entry);
+            try {
+                const st = statSync(full);
+                if (st.isDirectory()) {
+                    if (EXCLUDED_DIRS.has(entry) || entry.startsWith("."))
+                        continue;
+                    queue.push(full);
+                    continue;
+                }
+                if (st.isFile() && entry === "context.md") {
+                    found.push(full);
+                }
+            }
+            catch {
+                // Ignore unreadable entries.
+            }
+        }
+    }
+    return Array.from(new Set(found)).sort();
+}
+function isCopilotCliAvailable() {
+    const check = spawnSync("copilot", ["--version"], { encoding: "utf-8" });
+    return check.status === 0;
+}
+function isCopilotAuthenticated(workspaceRoot) {
+    const probe = spawnSync("copilot", ["-C", workspaceRoot, "-p", "Reply with exactly OK.", "--allow-all-tools", "--no-color", "-s"], { encoding: "utf-8" });
+    return probe.status === 0;
+}
+function ensureCopilotLogin(workspaceRoot) {
+    if (!isCopilotCliAvailable())
+        return false;
+    if (isCopilotAuthenticated(workspaceRoot))
+        return true;
+    console.log(chalk.yellow("   ⚠ GitHub Copilot CLI is not authenticated."));
+    console.log(chalk.yellow("   → Please complete Copilot login to continue context enrichment."));
+    const login = spawnSync("copilot", ["login"], { stdio: "inherit", encoding: "utf-8" });
+    if (login.status !== 0)
+        return false;
+    return isCopilotAuthenticated(workspaceRoot);
+}
+function enrichWithCopilotCli(workspaceRoot, contextFiles) {
+    let updated = 0;
+    let failed = 0;
+    for (const absPath of contextFiles) {
+        const relPath = absPath.replace(`${workspaceRoot}/`, "");
+        const prompt = [
+            `Update the markdown file at path '${relPath}' in place.`,
+            "Goal: make it both human-understandable and LLM-ready for automation framework reasoning.",
+            "Requirements:",
+            "- Keep heading style consistent.",
+            "- Include: purpose, architecture role, key assets, dependencies, conventions, risks, and update guidance.",
+            "- Be concrete and repository-aware.",
+            "- Do not modify any file other than the target file.",
+            "- Preserve valid markdown.",
+        ].join("\n");
+        const result = spawnSync("copilot", [
+            "-C", workspaceRoot,
+            "-p", prompt,
+            "--allow-all-tools",
+            "--allow-all-paths",
+            "--no-color",
+            "-s",
+        ], { encoding: "utf-8" });
+        if (result.status === 0) {
+            updated += 1;
+        }
+        else {
+            failed += 1;
+        }
+    }
+    return { updated, failed };
+}
+const GITHUB_AGENT_FILES = {
+    "IGEL-QE.agent.md": `---
+name: IGEL QE Orchestrator
+description: Single user-facing orchestrator for IGEL QE workflows. Plans first, enforces approvals, then runs generation. IGEL OS12 only.
+argument-hint: Provide the Jira issue key (for example IGEL-1234) and the requested workflow intent.
+target: vscode
+tools: ['mcp']
+---
+
+You are the IGEL QE Orchestrator Agent. IGEL OS12 only. Do not reference OS11.
+
+You are the single user-facing entrypoint. Always select and execute one of these governed flows:
+
+1. Test case planning
+2. Test case generation
+3. Automation planning
+4. Automation generation
+5. Explicit approval recording
+
+Mandatory governance rules:
+- Never bypass planning for generation requests.
+- If a generation request arrives without required approval, stop and ask for approval first.
+- Surface governance questions in batch form when the planning response includes questions.
+
+Tool dispatch:
+- Plan test cases: call \`plan_test_cases\`.
+- Generate test cases: call \`generate_test_cases\`.
+- Plan automation: call \`plan_automation\`.
+- Generate automation: call \`generate_automation\`.
+- Record approval: call \`record_approval\` with stage, decision, actor, and reason.
+
+Output format to user:
+- Selected workflow
+- Governance status (approval required, approval state, questions)
+- Result summary
+- Any blocking reason and the exact next action
+`,
+};
+/**
+ * Scaffold .github/agents/*.agent.md into the user's repo (idempotent — skips existing files).
+ * Content is embedded as string literals so the npm package is self-contained.
+ */
+function scaffoldGithubAgents(targetDir) {
+    const agentsDir = join(targetDir, ".github", "agents");
+    mkdirSync(agentsDir, { recursive: true });
+    const written = [];
+    for (const [filename, content] of Object.entries(GITHUB_AGENT_FILES)) {
+        const filePath = join(agentsDir, filename);
+        if (!existsSync(filePath)) {
+            writeFileSync(filePath, content, "utf-8");
+            written.push(filePath);
+        }
+    }
+    return written;
+}
+/**
+ * Invoke the Python workflow_cli and return parsed JSON output.
+ * Rejects if the process exits non-zero or output is not valid JSON.
+ */
+function runWorkflow(action, args) {
+    return new Promise((resolve, reject) => {
+        const py = getPythonBin();
+        const proc = spawn(py, ["-m", "src.cli.workflow_cli", "--action", action, "--args", JSON.stringify(args)], { cwd: PROJECT_ROOT, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (d) => (stdout += d.toString()));
+        proc.stderr.on("data", (d) => (stderr += d.toString()));
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                if (stderr)
+                    process.stderr.write(chalk.gray(stderr));
+                return reject(new Error(`workflow_cli exited with code ${code}`));
+            }
+            try {
+                resolve(JSON.parse(stdout.trim()));
+            }
+            catch {
+                // Non-JSON output — just print it
+                resolve({ raw: stdout.trim() });
+            }
+        });
+    });
+}
+// ── init ───────────────────────────────────────────────────────────────────────
 program
     .command("init")
-    .description("Bootstrap the Python AI Platform Layer")
+    .description("Bootstrap the IGEL QE AI Platform")
     .option("--with-copilot", "Auto-configure for GitHub Copilot in VS Code")
     .option("--with-cline", "Auto-configure for Cline")
-    .option("--with-antigravity", "Auto-configure for Antigravity (Gemini Code Assist)")
     .option("--with-all", "Auto-configure all supported platforms")
     .action(async (options) => {
-    console.log(chalk.blue("Initializing IGEL QE AI Platform..."));
-    const steps = [
-        "1. Checking Python version...",
-        "2. Creating virtual environment...",
-        "3. Installing Python dependencies...",
-        "4. Verifying PostgreSQL & pgvector...",
-        "5. Configuring MCP Server...",
-        "6. Building initial Code Index & Asset Registry..."
-    ];
-    for (const step of steps) {
-        console.log(chalk.yellow(step));
-        // Simulate step execution for demonstration
-        await new Promise(r => setTimeout(r, 500));
-        console.log(chalk.green(`  ✓ Done`));
-    }
-    console.log(chalk.bold.green("\nIGEL QE AI Platform successfully initialized!"));
-    if (options.withCopilot || options.withAll) {
-        await setupPlatform('copilot');
+    const workspaceRoot = process.cwd();
+    console.log(chalk.blue("\nInitializing IGEL QE AI Platform…\n"));
+    // Step 1 — venv + pip
+    const venvPath = join(PROJECT_ROOT, ".venv");
+    if (!existsSync(venvPath)) {
+        console.log(chalk.yellow("1. Creating virtual environment…"));
+        try {
+            execSync(`python3 -m venv .venv`, { cwd: PROJECT_ROOT, stdio: "inherit" });
+            console.log(chalk.green("   ✓ venv created"));
+        }
+        catch (e) {
+            console.log(chalk.yellow(`   ⚠ venv setup skipped: ${e instanceof Error ? e.message : String(e)}`));
+        }
+    }
+    else {
+        console.log(chalk.green("1. Virtual environment already exists ✓"));
+    }
+    console.log(chalk.yellow("2. Installing Python dependencies…"));
+    const reqPath = resolveRequirementsPath();
+    if (!reqPath) {
+        console.log(chalk.yellow("   ⚠ requirements file not found; skipping Python dependency install"));
+    }
+    else {
+        try {
+            execSync(`${getPythonBin()} -m pip install -q -r \"${reqPath}\"`, {
+                cwd: PROJECT_ROOT, stdio: "inherit",
+            });
+            console.log(chalk.green("   ✓ Dependencies installed"));
+        }
+        catch (e) {
+            console.log(chalk.yellow(`   ⚠ Dependency install skipped: ${e instanceof Error ? e.message : String(e)}`));
+        }
+    }
+    // Step 2 — scaffold .github/agents/ agent prompts in workspace
+    console.log(chalk.yellow("3. Scaffolding .github/agents/ prompts…"));
+    const written = scaffoldGithubAgents(workspaceRoot);
+    if (written.length > 0) {
+        console.log(chalk.green(`   ✓ Wrote ${written.length} agent file(s)`));
+    }
+    else {
+        console.log(chalk.green("   ✓ .github/agents/ already up to date"));
+    }
+    // Step 2b — scaffold framework context files (root + folder + subfolder)
+    console.log(chalk.yellow("3b. Scaffolding framework context files…"));
+    const contextWritten = scaffoldFrameworkContexts(workspaceRoot);
+    if (contextWritten.length > 0) {
+        console.log(chalk.green(`   ✓ Wrote ${contextWritten.length} context.md file(s)`));
+    }
+    else {
+        console.log(chalk.green("   ✓ Framework context files already up to date"));
+    }
+    // Step 2c — enrich framework context files via AST/dependency graph + DB sync
+    console.log(chalk.yellow("3c. Enriching framework context files (AST + dependency graph + DB sync)…"));
+    try {
+        const enrichResult = await runWorkflow("enrich_framework_context", {
+            repo_path: workspaceRoot,
+        });
+        if (typeof enrichResult.enriched_count === "number") {
+            console.log(chalk.green(`   ✓ Enriched ${enrichResult.enriched_count} context.md file(s)`));
+        }
+        else if (enrichResult.raw) {
+            console.log(chalk.green("   ✓ Context enrichment completed"));
+        }
+        else {
+            console.log(chalk.yellow("   ⚠ Context enrichment returned no summary; continuing"));
+        }
+    }
+    catch (e) {
+        console.log(chalk.yellow(`   ⚠ Context enrichment skipped: ${e instanceof Error ? e.message : String(e)}`));
+    }
+    // Step 2d — Copilot CLI enrichment pass (asks login if needed), then DB sync.
+    console.log(chalk.yellow("3d. Enriching context via GitHub Copilot CLI…"));
+    try {
+        const allContextFiles = listFrameworkContextFiles(workspaceRoot);
+        if (allContextFiles.length === 0) {
+            console.log(chalk.yellow("   ⚠ No context.md files found for Copilot enrichment"));
+        }
+        else if (!isCopilotCliAvailable()) {
+            console.log(chalk.yellow("   ⚠ Copilot CLI not installed; skipping Copilot enrichment"));
+        }
+        else if (!ensureCopilotLogin(workspaceRoot)) {
+            console.log(chalk.yellow("   ⚠ Copilot login was not completed; skipping Copilot enrichment"));
+        }
+        else {
+            const run = enrichWithCopilotCli(workspaceRoot, allContextFiles);
+            console.log(chalk.green(`   ✓ Copilot updated ${run.updated} context.md file(s)`));
+            if (run.failed > 0) {
+                console.log(chalk.yellow(`   ⚠ Copilot failed to update ${run.failed} context.md file(s)`));
+            }
+            // Persist updated file content/metadata to DB without overwriting Copilot edits.
+            const contextPaths = allContextFiles.map((p) => p.replace(`${workspaceRoot}/`, ""));
+            await runWorkflow("enrich_framework_context", {
+                repo_path: workspaceRoot,
+                context_paths: contextPaths,
+                persist_only: true,
+            });
+            console.log(chalk.green("   ✓ Synced Copilot-enriched context metadata to DB"));
+        }
+    }
+    catch (e) {
+        console.log(chalk.yellow(`   ⚠ Copilot context enrichment skipped: ${e instanceof Error ? e.message : String(e)}`));
+    }
+    // Step 3 — write MCP config (default: Copilot when no explicit platform flags)
+    console.log(chalk.yellow("4. Configuring MCP server…"));
+    const noPlatformFlags = !options.withCopilot && !options.withCline && !options.withAll;
+    const useCopilot = options.withCopilot || options.withAll || noPlatformFlags;
+    if (useCopilot) {
+        await setupPlatform("copilot");
     }
     if (options.withCline || options.withAll) {
-        await setupPlatform('cline');
+        await setupPlatform("cline");
     }
-    if (options.withAntigravity || options.withAll) {
-        await setupPlatform('antigravity');
+    console.log(chalk.green("   ✓ MCP configuration written"));
+    // Step 4 — connectivity checks (advisory by default)
+    console.log(chalk.yellow("5. Running pre-flight checks…"));
+    try {
+        const checkResult = await runWorkflow("init_check", {});
+        const checks = checkResult;
+        if (checks.checks) {
+            for (const [name, result] of Object.entries(checks.checks)) {
+                const icon = result.status === "ok" ? chalk.green("✓") : result.status === "warn" ? chalk.yellow("⚠") : result.status === "skipped" ? chalk.gray("-") : chalk.red("✗");
+                console.log(`   ${icon} ${name}: ${result.message}`);
+            }
+        }
+        if (!checks.ready) {
+            console.log(chalk.yellow(`   ⚠ Required runtime checks failed: ${(checks.required_failed || []).join(", ")}`));
+            console.log(chalk.yellow("   ⚠ Init scaffolding is complete, but generation flows may fail until runtime dependencies are configured."));
+        }
+        else {
+            console.log(chalk.green("   ✓ Pre-flight checks passed"));
+        }
+        if ((checks.warnings || []).length > 0) {
+            console.log(chalk.yellow(`   ⚠ Optional integrations degraded: ${(checks.warnings || []).join(", ")}`));
+        }
     }
-    console.log(`You can now use GitHub Copilot, Cline, or Antigravity to invoke MCP tools or run commands via this CLI.`);
+    catch (e) {
+        console.log(chalk.yellow(`   ⚠ Pre-flight checks could not run: ${e instanceof Error ? e.message : String(e)}`));
+        console.log(chalk.yellow("   ⚠ Init scaffolding is complete. Configure runtime dependencies before generation."));
+    }
+    console.log(chalk.bold.green("\nIGEL QE AI Platform initialised successfully!\n"));
+    console.log("Run " + chalk.cyan("igel-qe status") + " to verify project state.");
 });
+// ── generate ───────────────────────────────────────────────────────────────────
 program
-    .command("sync")
-    .description("Trigger a delta sync of the automation codebase")
-    .option("-c, --commit <hash>", "Bitbucket commit hash to sync", "HEAD")
-    .action((options) => {
-    console.log(chalk.blue(`Triggering delta sync for commit: ${options.commit}...`));
-    import('path').then(path => {
-        import('url').then(url => {
-            const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-            const projectRoot = path.join(__dirname, '..', '..', '..');
-            const pythonProcess = spawn("python", [
-                "-m", "knowledge_base.cli.workflow_cli",
-                "--action", "sync_bitbucket",
-                "--args", JSON.stringify({ commit_hash: options.commit })
-            ], {
-                cwd: projectRoot,
-                env: process.env,
-                stdio: 'inherit'
-            });
-            pythonProcess.on("close", (code) => {
-                if (code === 0) {
-                    console.log(chalk.green("Sync completed successfully."));
-                }
-                else {
-                    console.error(chalk.red(`Sync failed with code ${code}`));
-                }
-            });
+    .command("generate")
+    .description("Generate test cases for a Jira issue")
+    .requiredOption("--jira-key <key>", "Jira issue key, e.g. IGEL-1234")
+    .option("--test-reqid <id>", "Optional sub-requirement id to scope generation under the Jira key")
+    .action(async (options) => {
+    console.log(chalk.blue(`\nGenerating test cases for ${options.jiraKey}…`));
+    try {
+        const result = await runWorkflow("generate_test_cases", {
+            jira_key: options.jiraKey,
+            test_reqid: options.testReqid,
         });
-    });
+        if (result.error) {
+            console.error(chalk.red(`Error: ${result.error}`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`\n✓ Generation complete`));
+        console.log(`  Scenarios      : ${result.scenarios_count}`);
+        console.log(`  Total cases    : ${result.total_cases}`);
+        console.log(`  Approved cases : ${result.approved_cases}`);
+        if (result.plan_artifact_used)
+            console.log(chalk.gray("  (reused an existing plan)"));
+        const artifact = result.artifact;
+        if (artifact?.artifact_dir)
+            console.log(`  Artifact       : ${artifact.artifact_dir}`);
+        if (Array.isArray(result.unapproved_cases) && result.unapproved_cases.length > 0) {
+            console.log(chalk.yellow(`  ⚠ ${result.unapproved_cases.length} test case(s) below confidence threshold — review required`));
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`Generation failed: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+});
+// ── feedback ───────────────────────────────────────────────────────────────────
+program
+    .command("feedback")
+    .description("Submit corrective feedback on a generated artefact")
+    .requiredOption("--level <level>", "Feedback level: requirement, scenario, testcase, teststep")
+    .requiredOption("--target <id>", "Target artefact ID, e.g. TC_IGEL-1234_S01_P")
+    .requiredOption("--type <type>", "Feedback type: correction, rejection, enhancement, approval")
+    .requiredOption("--comment <text>", "Feedback comment text")
+    .action(async (options) => {
+    console.log(chalk.blue(`\nSubmitting ${options.type} feedback on ${options.target}…`));
+    try {
+        const result = await runWorkflow("submit_feedback", {
+            level: options.level,
+            target_id: options.target,
+            feedback_type: options.type,
+            user_comment: options.comment,
+        });
+        if (result.error) {
+            console.error(chalk.red(`Error: ${result.error}`));
+            process.exit(1);
+        }
+        console.log(chalk.green("✓ Feedback submitted"));
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+});
+// ── impact ─────────────────────────────────────────────────────────────────────
+program
+    .command("impact")
+    .description("Run impact analysis for changed files")
+    .option("--files <paths...>", "One or more changed file paths")
+    .option("--commit <hash>", "Commit hash to fetch changed files from Bitbucket")
+    .option("--repo-path <path>", "Local repo root path")
+    .action(async (options) => {
+    if (!options.files && !options.commit) {
+        console.error(chalk.red("Provide either --files or --commit"));
+        process.exit(1);
+    }
+    console.log(chalk.blue("\nRunning impact analysis…"));
+    try {
+        let changedFiles;
+        if (options.files) {
+            changedFiles = options.files;
+        }
+        else {
+            const syncArgs = { commit_hash: options.commit };
+            if (options.repoPath)
+                syncArgs.repo_path = options.repoPath;
+            const syncResult = await runWorkflow("sync_from_commit", syncArgs);
+            if (syncResult.error) {
+                console.error(chalk.red(`Error: ${syncResult.error}`));
+                process.exit(1);
+            }
+            changedFiles = syncResult.changed_files || [];
+        }
+        const args = { changed_files: changedFiles };
+        if (options.repoPath)
+            args.repo_path = options.repoPath;
+        const result = await runWorkflow("impact_analysis", args);
+        if (result.error) {
+            console.error(chalk.red(`Error: ${result.error}`));
+            process.exit(1);
+        }
+        console.log(chalk.green("✓ Impact analysis complete"));
+        const impact = result.impact;
+        if (impact) {
+            if (impact.affected_requirements?.length) {
+                console.log("Affected requirements:");
+                impact.affected_requirements.forEach((r) => console.log(`  • ${r}`));
+            }
+            if (impact.affected_scripts?.length) {
+                console.log("Affected scripts:");
+                impact.affected_scripts.forEach((s) => console.log(`  • ${s}`));
+            }
+            if (impact.affected_assets?.length) {
+                console.log("Affected assets:");
+                impact.affected_assets.forEach((a) => console.log(`  • ${a}`));
+            }
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+});
+// ── status ─────────────────────────────────────────────────────────────────────
+program
+    .command("status")
+    .description("Show current project state (reads from .ai/system/ after rebuilding from DB)")
+    .option("--json", "Output raw JSON")
+    .action(async (options) => {
+    console.log(chalk.blue("\nFetching project status…"));
+    try {
+        const result = await runWorkflow("get_project_status", {});
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            const state = result;
+            console.log(chalk.bold("\nProject State"));
+            const ps = state.project_state;
+            if (ps) {
+                console.log(`  Assets       : ${ps.asset_count ?? "-"}`);
+                console.log(`  Requirements : ${ps.requirement_count ?? "-"}`);
+                console.log(`  Test cases   : ${ps.testcase_count ?? "-"}`);
+                console.log(`  Scripts      : ${ps.script_count ?? "-"}`);
+            }
+            const ss = state.sync_state;
+            if (ss?.connectors) {
+                console.log(chalk.bold("\nConnector Sync"));
+                ss.connectors.forEach((c) => {
+                    const icon = c.status === "ok" ? chalk.green("✓") : chalk.yellow("⚠");
+                    console.log(`  ${icon} ${c.source}: last synced ${c.last_synced_at || "never"}`);
+                });
+            }
+            console.log(chalk.green("\n✓ Status complete"));
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
+});
+// ── sync (legacy) ──────────────────────────────────────────────────────────────
+program
+    .command("sync")
+    .description("Trigger a delta sync from a Bitbucket commit hash")
+    .requiredOption("-c, --commit <hash>", "Bitbucket commit hash to sync (must be a resolvable Bitbucket API commit hash, not a local git ref like HEAD)")
+    .action(async (options) => {
+    console.log(chalk.blue(`\nTriggering sync for commit: ${options.commit}…`));
+    try {
+        await runWorkflow("sync_from_commit", { commit_hash: options.commit });
+        console.log(chalk.green("✓ Sync completed"));
+    }
+    catch (e) {
+        console.error(chalk.red(`Sync failed: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    }
 });
+// ── platform sub-command ──────────────────────────────────────────────────────
 const platformCmd = program
     .command("platform")
     .description("Manage coding agent platform configurations");
 platformCmd
     .command("setup <platform>")
-    .description("Setup an MCP configuration for a specific platform (copilot, cline)")
+    .description("Write MCP config for a platform (copilot, cline)")
     .action(async (platform) => {
-    console.log(chalk.blue(`Setting up configuration for ${platform}...`));
+    console.log(chalk.blue(`Setting up configuration for ${platform}…`));
     await setupPlatform(platform);
 });
 program.parse();