@aipper/aiws 0.0.29 → 0.0.31

package/dist/cli.js

@@ -0,0 +1,773 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { UserError } from "./errors.js";
+import { delegationCheckCommand } from "./delegation/cli.js";
+import { wsPullCommand } from "./commands/ws-pull.js";
+import { wsPushCommand } from "./commands/ws-push.js";
+import { wsMigrateCommand } from "./commands/ws-migrate.js";
+import { wsSubmoduleSetupCommand } from "./commands/ws-submodule-setup.js";
+import { wsCommitCommand } from "./commands/ws-commit.js";
+import { wsPlanVerifyCommand } from "./commands/ws-plan-verify.js";
+import { wsVerifyBeforeCompleteCommand } from "./commands/ws-verify-before-complete.js";
+import { wsHandoffCommand } from "./commands/ws-handoff.js";
+import { wsFinishCommand } from "./commands/ws-finish.js";
+import { wsDeliverCommand } from "./commands/ws-deliver.js";
+import { initCommand } from "./commands/init.js";
+import { updateCommand } from "./commands/update.js";
+import { validateCommand } from "./commands/validate.js";
+import { rollbackCommand } from "./commands/rollback.js";
+import { codexInstallPromptsCommand } from "./commands/codex-install-prompts.js";
+import { codexStatusPromptsCommand } from "./commands/codex-status-prompts.js";
+import { codexUninstallPromptsCommand } from "./commands/codex-uninstall-prompts.js";
+import { codexInstallSkillsCommand } from "./commands/codex-install-skills.js";
+import { codexStatusSkillsCommand } from "./commands/codex-status-skills.js";
+import { codexUninstallSkillsCommand } from "./commands/codex-uninstall-skills.js";
+import { hooksInstallCommand } from "./commands/hooks-install.js";
+import { hooksStatusCommand } from "./commands/hooks-status.js";
+import { opencodeAutoCommand } from "./commands/opencode-auto.js";
+import { opencodeSuperviseCommand } from "./commands/opencode-supervise.js";
+import { opencodeStatusCommand } from "./commands/opencode-status.js";
+import { dashboardServeCommand } from "./commands/dashboard.js";
+import { changeArchiveCommand, changeEvidenceCommand, changeFinishCommand, changeListCommand, changeNewCommand, changeNextCommand, changeStateCommand, changeStartCommand, changeStatusCommand, changeSyncCommand, changeTemplatesInitCommand, changeTemplatesWhichCommand, changeValidateCommand, metricsSummaryCommand, } from "./commands/change.js";
+export async function cliMain(argv) {
+    const args = argv.slice();
+    if (args[0] === "codex" && (args.includes("-h") || args.includes("--help"))) {
+        printCodexHelp();
+        return 0;
+    }
+    if (args[0] === "hooks" && (args.includes("-h") || args.includes("--help"))) {
+        printHooksHelp();
+        return 0;
+    }
+    if (args[0] === "opencode" && (args.includes("-h") || args.includes("--help"))) {
+        printOpenCodeHelp();
+        return 0;
+    }
+    if (args[0] === "dashboard" && (args.includes("-h") || args.includes("--help"))) {
+        printDashboardHelp();
+        return 0;
+    }
+    if (args[0] === "change" && (args.includes("-h") || args.includes("--help"))) {
+        printChangeHelp();
+        return 0;
+    }
+    if (args[0] === "metrics" && (args.includes("-h") || args.includes("--help"))) {
+        printMetricsHelp();
+        return 0;
+    }
+    if (args[0] === "delegation" && (args.includes("-h") || args.includes("--help"))) {
+        printDelegationHelp();
+        return 0;
+    }
+    if (args.length === 0 || args.includes("-h") || args.includes("--help") || args[0] === "help") {
+        printHelp();
+        return 0;
+    }
+    if (args[0] === "--version" || args[0] === "-v") {
+        console.log(getAiwsVersion());
+        return 0;
+    }
+    const cmd = args.shift();
+    if (!cmd) {
+        printHelp();
+        return 0;
+    }
+    switch (cmd) {
+        case "init": {
+            const { positionals, options } = parseArgs(args, {
+                template: { type: "string" },
+            });
+            const targetPath = positionals[0] ?? ".";
+            const templateId = options.template ?? "workspace";
+            await initCommand({ targetPath, templateId: String(templateId) });
+            return 0;
+        }
+        case "update": {
+            const { positionals } = parseArgs(args, {});
+            const targetPath = positionals[0] ?? ".";
+            await updateCommand({ targetPath });
+            return 0;
+        }
+        case "validate": {
+            const { positionals, options } = parseArgs(args, {
+                stamp: { type: "boolean" },
+            });
+            const targetPath = positionals[0] ?? ".";
+            await validateCommand({ targetPath, stamp: options.stamp === true });
+            return 0;
+        }
+        case "rollback": {
+            const { positionals } = parseArgs(args, {});
+            if (positionals.length === 0) {
+                throw new UserError("rollback requires <timestamp|latest>", { details: "Usage: aiws rollback [path] <timestamp|latest>" });
+            }
+            let targetPath = ".";
+            let stamp = "";
+            if (positionals.length === 1) {
+                stamp = positionals[0] ?? "";
+            }
+            else {
+                targetPath = positionals[0] ?? ".";
+                stamp = positionals[1] ?? "";
+            }
+            await rollbackCommand({ targetPath, stamp });
+            return 0;
+        }
+        case "codex": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printCodexHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "install-skills": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                        force: { type: "boolean" },
+                        "dry-run": { type: "boolean" },
+                    });
+                    await codexInstallSkillsCommand({
+                        templateId: options.template ?? "workspace",
+                        skillsDir: options.dir,
+                        force: options.force === true,
+                        dryRun: options["dry-run"] === true,
+                    });
+                    return 0;
+                }
+                case "status-skills": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                    });
+                    await codexStatusSkillsCommand({
+                        templateId: options.template ?? "workspace",
+                        skillsDir: options.dir,
+                    });
+                    return 0;
+                }
+                case "uninstall-skills": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                    });
+                    await codexUninstallSkillsCommand({
+                        templateId: options.template ?? "workspace",
+                        skillsDir: options.dir,
+                    });
+                    return 0;
+                }
+                case "install-prompts": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                        force: { type: "boolean" },
+                        "dry-run": { type: "boolean" },
+                    });
+                    await codexInstallPromptsCommand({
+                        templateId: options.template ?? "workspace",
+                        promptsDir: options.dir,
+                        force: options.force === true,
+                        dryRun: options["dry-run"] === true,
+                    });
+                    return 0;
+                }
+                case "status": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                    });
+                    await codexStatusPromptsCommand({
+                        templateId: options.template ?? "workspace",
+                        promptsDir: options.dir,
+                    });
+                    return 0;
+                }
+                case "uninstall-prompts": {
+                    const { options } = parseArgs(args, {
+                        template: { type: "string" },
+                        dir: { type: "string" },
+                    });
+                    await codexUninstallPromptsCommand({
+                        templateId: options.template ?? "workspace",
+                        promptsDir: options.dir,
+                    });
+                    return 0;
+                }
+                default:
+                    throw new UserError(`Unknown codex subcommand: ${sub}`, { details: "Use `aiws codex --help` to see available subcommands." });
+            }
+        }
+        case "hooks": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printHooksHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "install": {
+                    const { positionals } = parseArgs(args, {});
+                    const targetPath = positionals[0] ?? ".";
+                    await hooksInstallCommand({ targetPath });
+                    return 0;
+                }
+                case "status": {
+                    const { positionals } = parseArgs(args, {});
+                    const targetPath = positionals[0] ?? ".";
+                    await hooksStatusCommand({ targetPath });
+                    return 0;
+                }
+                default:
+                    throw new UserError(`Unknown hooks subcommand: ${sub}`, { details: "Use `aiws hooks --help` to see available subcommands." });
+            }
+        }
+        case "dashboard": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printDashboardHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "serve": {
+                    const { options } = parseArgs(args, {
+                        host: { type: "string" },
+                        port: { type: "string" },
+                    });
+                    const host = options.host ?? "127.0.0.1";
+                    const port = options.port ? Number.parseInt(String(options.port), 10) : 3456;
+                    await dashboardServeCommand({ host, port });
+                    return 0;
+                }
+                default:
+                    throw new UserError(`Unknown dashboard subcommand: ${sub}`, { details: "Use `aiws dashboard --help` to see available subcommands." });
+            }
+        }
+        case "opencode": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printOpenCodeHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "status": {
+                    const { positionals } = parseArgs(args, {});
+                    const targetPath = positionals[0] ?? ".";
+                    await opencodeStatusCommand({ targetPath });
+                    return 0;
+                }
+                case "auto": {
+                    const { positionals, options } = parseArgs(args, {
+                        session: { type: "string" },
+                        window: { type: "string" },
+                        once: { type: "boolean" },
+                        "poll-ms": { type: "string" },
+                        "no-update": { type: "boolean" },
+                    });
+                    const targetPath = positionals[0] ?? ".";
+                    await opencodeAutoCommand({
+                        targetPath,
+                        sessionName: options.session,
+                        windowName: options.window,
+                        once: options.once === true,
+                        pollMs: options["poll-ms"],
+                        noUpdate: options["no-update"] === true,
+                    });
+                    return 0;
+                }
+                case "supervise": {
+                    const { positionals, options } = parseArgs(args, {
+                        session: { type: "string" },
+                        window: { type: "string" },
+                        once: { type: "boolean" },
+                        "poll-ms": { type: "string" },
+                    });
+                    const targetPath = positionals[0] ?? ".";
+                    await opencodeSuperviseCommand({
+                        targetPath,
+                        sessionName: options.session,
+                        windowName: options.window,
+                        once: options.once === true,
+                        pollMs: options["poll-ms"],
+                    });
+                    return 0;
+                }
+                default:
+                    throw new UserError(`Unknown opencode subcommand: ${sub}`, { details: "Use `aiws opencode --help` to see available subcommands." });
+            }
+        }
+        case "change": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printChangeHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "list": {
+                    await changeListCommand();
+                    return 0;
+                }
+                case "start": {
+                    const { positionals, options } = parseArgs(args, {
+                        title: { type: "string" },
+                        "no-design": { type: "boolean" },
+                        hooks: { type: "boolean" },
+                        "no-switch": { type: "boolean" },
+                        switch: { type: "boolean" },
+                        "allow-dirty": { type: "boolean" },
+                    });
+                    const changeId = positionals[0] ?? "";
+                    if (!changeId)
+                        throw new UserError("change start requires <change-id>", {
+                            details: "Usage: aiws change start <change-id> [--title <title>] [--no-design] [--hooks] [--no-switch] [--switch] [--allow-dirty]",
+                        });
+                    await changeStartCommand({
+                        changeId,
+                        title: options.title,
+                        noDesign: options["no-design"] === true,
+                        enableHooks: options.hooks === true,
+                        noSwitch: options["no-switch"] === true,
+                        forceSwitch: options.switch === true,
+                        allowDirty: options["allow-dirty"] === true,
+                    });
+                    return 0;
+                }
+                case "new": {
+                    const { positionals, options } = parseArgs(args, {
+                        title: { type: "string" },
+                        "no-design": { type: "boolean" },
+                    });
+                    const changeId = positionals[0] ?? "";
+                    if (!changeId)
+                        throw new UserError("change new requires <change-id>", { details: "Usage: aiws change new <change-id> [--title <title>] [--no-design]" });
+                    await changeNewCommand({
+                        changeId,
+                        title: options.title,
+                        noDesign: options["no-design"] === true,
+                    });
+                    return 0;
+                }
+                case "status": {
+                    const { positionals } = parseArgs(args, {});
+                    const changeId = positionals[0];
+                    await changeStatusCommand({ changeId });
+                    return 0;
+                }
+                case "next": {
+                    const { positionals } = parseArgs(args, {});
+                    const changeId = positionals[0];
+                    await changeNextCommand({ changeId });
+                    return 0;
+                }
+                case "validate": {
+                    const { positionals, options } = parseArgs(args, {
+                        strict: { type: "boolean" },
+                        "allow-truth-drift": { type: "boolean" },
+                        "check-evidence": { type: "boolean" },
+                        "check-scope": { type: "boolean" },
+                    });
+                    const changeId = positionals[0];
+                    await changeValidateCommand({
+                        changeId,
+                        strict: options.strict === true,
+                        allowTruthDrift: options["allow-truth-drift"] === true,
+                        checkEvidence: options["check-evidence"] === true,
+                        checkScope: options["check-scope"] === true,
+                    });
+                    return 0;
+                }
+                case "evidence": {
+                    const { positionals, options } = parseArgs(args, {
+                        "no-validate": { type: "boolean" },
+                        "allow-fail": { type: "boolean" },
+                    });
+                    const changeId = positionals[0];
+                    await changeEvidenceCommand({
+                        changeId,
+                        noValidate: options["no-validate"] === true,
+                        allowFail: options["allow-fail"] === true,
+                    });
+                    return 0;
+                }
+                case "state": {
+                    const { positionals, options } = parseArgs(args, { write: { type: "boolean" } });
+                    const changeId = positionals[0];
+                    await changeStateCommand({ changeId, write: options.write === true });
+                    return 0;
+                }
+                case "sync": {
+                    const { positionals } = parseArgs(args, {});
+                    const changeId = positionals[0];
+                    await changeSyncCommand({ changeId });
+                    return 0;
+                }
+                case "archive": {
+                    const { positionals, options } = parseArgs(args, {
+                        date: { type: "string" },
+                        force: { type: "boolean" },
+                    });
+                    const changeId = positionals[0];
+                    await changeArchiveCommand({
+                        changeId,
+                        datePrefix: options.date,
+                        force: options.force === true,
+                    });
+                    return 0;
+                }
+                case "finish": {
+                    const { positionals, options } = parseArgs(args, {
+                        into: { type: "string" },
+                        base: { type: "string" },
+                        push: { type: "boolean" },
+                        remote: { type: "string" },
+                    });
+                    const changeId = positionals[0];
+                    await changeFinishCommand({
+                        changeId,
+                        into: options.into,
+                        base: options.base,
+                        push: options.push === true,
+                        remote: options.remote,
+                    });
+                    return 0;
+                }
+                case "templates": {
+                    const templatesSub = args.shift();
+                    if (!templatesSub)
+                        throw new UserError("change templates requires <which|init>", { details: "Usage: aiws change templates which|init" });
+                    if (templatesSub === "which") {
+                        const { positionals } = parseArgs(args, {});
+                        if (positionals.length > 0)
+                            throw new UserError("change templates which takes no args");
+                        await changeTemplatesWhichCommand();
+                        return 0;
+                    }
+                    if (templatesSub === "init") {
+                        const { positionals } = parseArgs(args, {});
+                        if (positionals.length > 0)
+                            throw new UserError("change templates init takes no args");
+                        await changeTemplatesInitCommand();
+                        return 0;
+                    }
+                    throw new UserError(`Unknown change templates subcommand: ${templatesSub}`, { details: "Use `aiws change --help` to see available commands." });
+                }
+                default:
+                    throw new UserError(`Unknown change subcommand: ${sub}`, { details: "Use `aiws change --help` to see available subcommands." });
+            }
+        }
+        case "metrics": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printMetricsHelp();
+                return 0;
+            }
+            if (sub === "summary") {
+                const { options } = parseArgs(args, { since: { type: "string" } });
+                await metricsSummaryCommand({ since: options.since });
+                return 0;
+            }
+            throw new UserError(`Unknown metrics subcommand: ${sub}`, { details: "Use `aiws metrics --help` to see available subcommands." });
+        }
+        case "pull":
+            await wsPullCommand({ cwd: args[0] || "." });
+            return 0;
+        case "push": {
+            const { positionals, options } = parseArgs(args, { remote: { type: "string" } });
+            await wsPushCommand({ cwd: positionals[0] || ".", remote: options.remote || "origin" });
+            return 0;
+        }
+        case "migrate":
+            await wsMigrateCommand({ cwd: args[0] || "." });
+            return 0;
+        case "submodule-setup": {
+            const { positionals, options } = parseArgs(args, { branch: { type: "string" } });
+            await wsSubmoduleSetupCommand({ cwd: positionals[0] || ".", branch: options.branch || "main" });
+            return 0;
+        }
+        case "commit": {
+            const { positionals, options } = parseArgs(args, { message: { type: "string" }, m: { type: "string" } });
+            const message = options.message || options.m;
+            await wsCommitCommand({ cwd: positionals[0] || ".", message });
+            return 0;
+        }
+        case "plan-verify":
+            await wsPlanVerifyCommand({ cwd: args[0] || "." });
+            return 0;
+        case "verify-bc":
+            await wsVerifyBeforeCompleteCommand({ cwd: args[0] || "." });
+            return 0;
+        case "handoff":
+            await wsHandoffCommand({ cwd: args[0] || "." });
+            return 0;
+        case "finish": {
+            const { positionals, options } = parseArgs(args, {
+                into: { type: "string" },
+                push: { type: "boolean" },
+                remote: { type: "string" },
+            });
+            await wsFinishCommand({
+                cwd: ".",
+                changeId: positionals[0],
+                into: options.into,
+                push: options.push === true,
+                remote: options.remote || "origin",
+            });
+            return 0;
+        }
+        case "deliver": {
+            const { positionals, options } = parseArgs(args, {
+                message: { type: "string" },
+                m: { type: "string" },
+            });
+            const message = options.message || options.m;
+            await wsDeliverCommand({
+                cwd: ".",
+                changeId: positionals[0],
+                message,
+            });
+            return 0;
+        }
+        case "delegation": {
+            const sub = args.shift();
+            if (!sub || sub === "help" || sub === "--help" || sub === "-h") {
+                printDelegationHelp();
+                return 0;
+            }
+            switch (sub) {
+                case "check": {
+                    const { positionals, options } = parseArgs(args, {
+                        "change-id": { type: "string" },
+                        role: { type: "string" },
+                    });
+                    const changeId = options["change-id"] ?? positionals[0];
+                    const role = options.role ?? positionals[1];
+                    if (!changeId || !role) {
+                        throw new UserError("delegation check requires --change-id and --role", {
+                            details: "Usage: aiws delegation check --change-id <id> --role <role>",
+                        });
+                    }
+                    const ok = await delegationCheckCommand({
+                        changeId: String(changeId),
+                        role: String(role),
+                    });
+                    return ok ? 0 : 1;
+                }
+                default:
+                    throw new UserError(`Unknown delegation subcommand: ${sub}`, {
+                        details: "Use `aiws delegation --help` to see available subcommands.",
+                    });
+            }
+        }
+        default:
+            throw new UserError(`Unknown command: ${cmd}`, { details: "Use --help to see available commands." });
+    }
+}
+function printHelp() {
+    console.log(`aiws (WORK IN PROGRESS)
+
+Usage:
+  aiws init [path] [--template <id>]
+  aiws update [path]
+  aiws validate [path] [--stamp]
+  aiws rollback [path] <timestamp|latest>
+  aiws pull [path]
+  aiws push [path] [--remote <name>]
+  aiws migrate [path]
+  aiws commit [path] [-m <message>]
+  aiws plan-verify [path]
+  aiws verify-bc [path]
+  aiws handoff [path]
+  aiws submodule-setup [path] [--branch <name>]
+  aiws finish [change-id] [--into <branch>] [--push] [--remote <name>]
+  aiws deliver [change-id] [-m <message>]
+  aiws change <subcommand>
+  aiws metrics <subcommand>
+  aiws delegation <subcommand>
+  aiws dashboard <subcommand>
+  aiws opencode <subcommand>
+  aiws codex <subcommand>
+  aiws hooks <subcommand>
+
+Options:
+  --template <id>   Template id (default: workspace)
+  --stamp           Write evidence stamp (validate)
+  -h, --help        Show help
+  -v, --version     Show version
+`);
+}
+function printCodexHelp() {
+    console.log(`aiws codex
+
+Usage:
+  aiws codex install-skills [--template <id>] [--dir <path>] [--force] [--dry-run]
+  aiws codex status-skills [--template <id>] [--dir <path>]
+  aiws codex uninstall-skills [--template <id>] [--dir <path>]
+  aiws codex install-prompts [--template <id>] [--dir <path>] [--force] [--dry-run]
+  aiws codex status [--template <id>] [--dir <path>]
+  aiws codex uninstall-prompts [--template <id>] [--dir <path>]
+
+Notes:
+  - Prefer repo skills: .agents/skills (no install needed)
+  - Prefer global skills over legacy prompts
+  - Default skills dir: ~/.agents/skills
+  - Compatibility/test override: $CODEX_HOME/.agents/skills or --dir <path>
+  - install-prompts is legacy (prompts are deprecated)
+  - Default target dir: ~/.codex/prompts
+  - If CODEX_HOME is set: $CODEX_HOME/prompts
+`);
+}
+function printHooksHelp() {
+    console.log(`aiws hooks
+
+Usage:
+  aiws hooks install [path]
+  aiws hooks status [path]
+
+Notes:
+  - install will set: git config core.hooksPath .githooks
+  - hooks can be bypassed with: WS_CHANGE_HOOK_BYPASS=1
+`);
+}
+function printOpenCodeHelp() {
+    console.log(`aiws opencode
+
+Usage:
+  aiws opencode status [path]
+  aiws opencode auto [path] [--session <name>] [--window <name>] [--once] [--poll-ms <ms>] [--no-update]
+  aiws opencode supervise [path] [--session <name>] [--window <name>] [--once] [--poll-ms <ms>]
+
+Notes:
+  - Detects project-local .opencode/ and oh-my-opencode (oMo) config.
+  - auto can refresh managed OpenCode autonomy files via \`aiws update .\` when needed, then ensure watchdog is running in tmux.
+  - Helps verify whether AIWS OpenCode skills should prefer oMo agents or fallback to standard-opencode.
+  - supervise explicitly ensures the approval watchdog is running in tmux; it does not auto-approve host permissions.
+`);
+}
+function printDashboardHelp() {
+    console.log(`aiws dashboard
+
+Usage:
+  aiws dashboard serve [--host 127.0.0.1] [--port 3456]
+
+Notes:
+  - Local-only dashboard, no external dependencies.
+  - Dashboard also exposes workflow governance data sourced from @aipper/aiws-spec:
+    /api/changes, /api/workflow-stages, /api/change/<id>/validate?strict=1
+  - Recommended: run change quality gate first (AI tools: $ws-plan-verify):
+    aiws change validate <change-id> --strict
+`);
+}
+function printChangeHelp() {
+    console.log(`aiws change
+
+Usage:
+  aiws change list
+  aiws change start <change-id> [--title <title>] [--no-design] [--hooks] [--no-switch] [--switch] [--allow-dirty]
+  aiws change finish [change-id] [--into <branch> | --base <branch>] [--push] [--remote <name>]
+  aiws change new <change-id> [--title <title>] [--no-design]
+  aiws change status [change-id]
+  aiws change next [change-id]
+  aiws change validate [change-id] [--strict] [--allow-truth-drift] [--check-evidence] [--check-scope]
+  aiws change evidence [change-id] [--no-validate] [--allow-fail]
+  aiws change state [change-id] [--write]
+  aiws change sync [change-id]
+  aiws change archive [change-id] [--date YYYY-MM-DD] [--force]
+  aiws change templates which
+  aiws change templates init
+
+Notes:
+  - change-id must be kebab-case: ^[a-z0-9]+(-[a-z0-9]+)*$
+  - If your git branch matches change/<change-id> (or changes/ws/ws-change prefixes),
+    you can omit <change-id> for status/next/validate/sync/archive/finish.
+  - Execution quality gate first: aiws change validate [change-id] --strict
+    (equivalent to running $ws-plan-verify in AI tools).
+  - status/next now prioritize quality-gate guidance before coding ($ws-dev-lite / $ws-dev).
+  - start refuses to switch branches with a dirty working tree (unless --allow-dirty).
+  - finish --push is submodule-aware: when .gitmodules exists it pushes submodules first, then the target branch.
+  - archive runs strict validation and (by default) requires all tasks checked.
+  - archive --force also bypasses truth drift gating (not recommended).
+`);
+}
+function printMetricsHelp() {
+    console.log(`aiws metrics
+
+Usage:
+  aiws metrics summary [--since YYYY-MM-DD]
+
+Notes:
+  - Reads .aiws/changes/*/metrics.json (and .aiws/changes/archive/*/metrics.json) and prints a best-effort summary.
+`);
+}
+function printDelegationHelp() {
+    console.log(`aiws delegation
+
+Usage:
+  aiws delegation check --change-id <id> --role <role>
+
+Notes:
+  - Verifies that a context JSONL file exists for the given change and role.
+  - Roles: worker, explorer, reviewer, planner.
+  - Convention path: .aiws/changes/<change-id>/analysis/<role>-context.jsonl
+  - Exit code 0 if JSONL exists with entries, 1 otherwise.
+`);
+}
+function parseArgs(argv, schema) {
+    const positionals = [];
+    const options = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] ?? "";
+        if (!a.startsWith("-")) {
+            positionals.push(a);
+            continue;
+        }
+        if (a === "--") {
+            positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (!a.startsWith("--")) {
+            throw new UserError(`Unknown option: ${a}`);
+        }
+        const eq = a.indexOf("=");
+        const key = (eq === -1 ? a.slice(2) : a.slice(2, eq)).trim();
+        if (!schema[key]) {
+            throw new UserError(`Unknown option: --${key}`);
+        }
+        const type = schema[key]?.type;
+        if (type === "boolean") {
+            if (eq !== -1) {
+                const raw = a.slice(eq + 1).trim().toLowerCase();
+                options[key] = raw === "1" || raw === "true" || raw === "yes" || raw === "y" || raw === "on";
+            }
+            else {
+                options[key] = true;
+            }
+            continue;
+        }
+        let value = "";
+        if (eq !== -1) {
+            value = a.slice(eq + 1);
+        }
+        else {
+            const next = argv[i + 1];
+            if (!next || next.startsWith("-")) {
+                throw new UserError(`Missing value for --${key}`);
+            }
+            value = next;
+            i++;
+        }
+        options[key] = value;
+    }
+    return { positionals, options };
+}
+function getAiwsVersion() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path.resolve(here, "../package.json");
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        return String(pkg.version || "").trim() || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+//# sourceMappingURL=cli.js.map