agent-sdd 1.0.3

package/dist/cli.js

@@ -0,0 +1,867 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { CliApproveHandler } from "./features/approve/adapters/inbound/CliApproveHandler.js";
+import { NodeApproveFileSystem } from "./features/approve/adapters/outbound/NodeApproveFileSystem.js";
+import { NodePlanFileWriter } from "./features/approve/adapters/outbound/NodePlanFileWriter.js";
+import { SystemApproveClock } from "./features/approve/adapters/outbound/SystemApproveClock.js";
+import { CliCheckHandler } from "./features/check/adapters/inbound/CliCheckHandler.js";
+import { CliDoctorHandler } from "./features/doctor/adapters/inbound/CliDoctorHandler.js";
+import { NodeRegistryReader } from "./features/doctor/adapters/outbound/NodeRegistryReader.js";
+import { CliFinalizeHandler } from "./features/finalize/adapters/inbound/CliFinalizeHandler.js";
+import { NodeFinalizeFileSystem } from "./features/finalize/adapters/outbound/NodeFinalizeFileSystem.js";
+import { NodePlanRepo } from "./features/finalize/adapters/outbound/NodePlanRepo.js";
+import { SystemFinalizeClock } from "./features/finalize/adapters/outbound/SystemFinalizeClock.js";
+import { CliPlanShowHandler } from "./features/plan/adapters/inbound/CliPlanShowHandler.js";
+import { NodePlanReader } from "./features/plan/adapters/outbound/NodePlanReader.js";
+import { CliReportHandler } from "./features/report/adapters/inbound/CliReportHandler.js";
+import { NodeReportFileSystem } from "./features/report/adapters/outbound/NodeReportFileSystem.js";
+import { ChildProcessCheckGit } from "./features/check/adapters/outbound/ChildProcessCheckGit.js";
+import { NodeCheckFileReader } from "./features/check/adapters/outbound/NodeCheckFileReader.js";
+import { CliLintHandler } from "./features/lint/adapters/inbound/CliLintHandler.js";
+import { NodeLintFileReader } from "./features/lint/adapters/outbound/NodeLintFileReader.js";
+import { CliReadyHandler } from "./features/ready/adapters/inbound/CliReadyHandler.js";
+import { ChildProcessReadyGit } from "./features/ready/adapters/outbound/ChildProcessReadyGit.js";
+import { NodeReadyFileSystem } from "./features/ready/adapters/outbound/NodeReadyFileSystem.js";
+import { CliRefreshHandler } from "./features/refresh/adapters/inbound/CliRefreshHandler.js";
+import { ChildProcessRefreshGit } from "./features/refresh/adapters/outbound/ChildProcessRefreshGit.js";
+import { NodeRefreshFileReader } from "./features/refresh/adapters/outbound/NodeRefreshFileReader.js";
+import { SystemRefreshClock } from "./features/refresh/adapters/outbound/SystemRefreshClock.js";
+import { CliRecordHandler } from "./features/record/adapters/inbound/CliRecordHandler.js";
+import { NodeRecordFileSystem } from "./features/record/adapters/outbound/NodeRecordFileSystem.js";
+import { CliInstallHandler } from "./features/install/adapters/inbound/CliInstallHandler.js";
+import { NodeInstallSource } from "./features/install/adapters/outbound/NodeInstallSource.js";
+import { NodeInstallTargetFs } from "./features/install/adapters/outbound/NodeInstallTargetFs.js";
+import { isInstallTarget, } from "./features/install/domain/InstallTarget.js";
+import { CliTokenHandler } from "./features/token/adapters/inbound/CliTokenHandler.js";
+import { ChildProcessTokenGit } from "./features/token/adapters/outbound/ChildProcessTokenGit.js";
+import { NodeTokenConfigReader } from "./features/token/adapters/outbound/NodeTokenConfigReader.js";
+const TOP_LEVEL_HELP = `sdd
+
+Usage:
+  sdd token    [--format=json|human]
+  sdd check    [--format=json|human]
+  sdd refresh  [--format=json|human|yaml]
+  sdd lint     [--format=json|human]
+  sdd approve  --id <id-or-glob> --approver <human-id>
+               --owner-role <role> --change-request <url>
+               [--scope <scope>] [--target-status approved|deprecated|removed]
+               [--reviewed-test-oracle <ref>]
+               [--inline | --plan <plan_id>] [--format=json|human]
+  sdd plan show [--plan <plan_id>] [--format=json|human]
+  sdd finalize  [--plan <plan_id>] [--format=json|human]
+  sdd doctor    --rule-version [--rules <path>] [--format=json|human]
+  sdd report    --pr-summary [--against <ref>] [--format=json|human]
+  sdd ready    [--format=json|human] [--partition <name>]
+  sdd record list           [--partition <name>] [--format=json|human]
+  sdd record get <id>       [--format=json|human]
+  sdd record set <id>       (--from-file <p> | --content <s>) [--format=json|human]
+  sdd record add --after <id> (--from-file <p> | --content <s>) [--format=json|human]
+  sdd install <all|claude|codex> [--scope user|project] [--dry-run] [--format=json|human]
+  sdd --help
+  sdd --version`;
+const COMMAND_HELP = {
+    token: "Usage: sdd token [--format=json|human]",
+    check: "Usage: sdd check [--format=json|human]",
+    refresh: "Usage: sdd refresh [--format=json|human|yaml]",
+    lint: "Usage: sdd lint [--format=json|human]",
+    approve: "Usage: sdd approve --id <id-or-glob> --approver <human-id> --owner-role <role> --change-request <url> [--scope <scope>] [--target-status approved|deprecated|removed] [--reviewed-test-oracle <ref>] [--inline | --plan <plan_id>] [--format=json|human]",
+    ready: "Usage: sdd ready [--format=json|human] [--partition <name>]",
+    finalize: "Usage: sdd finalize [--plan <plan_id>] [--format=json|human]",
+    plan: "Usage: sdd plan show [--plan <plan_id>] [--format=json|human]",
+    doctor: "Usage: sdd doctor --rule-version [--rules <path>] [--format=json|human]",
+    report: "Usage: sdd report --pr-summary [--against <ref>] [--format=json|human]",
+    record: "Usage: sdd record list [--partition <name>] | get <id> | set <id> (--from-file <p>|--content <s>) | add --after <id> (--from-file <p>|--content <s>) [--format=json|human]",
+    install: "Usage: sdd install <all|claude|codex> [--scope user|project] [--dry-run] [--format=json|human]",
+};
+export async function main(argv, cwd) {
+    const parsed = parseArgv(argv);
+    if (parsed.mode === "help") {
+        return {
+            exitCode: 0,
+            stdout: `${parsed.subcommand ? COMMAND_HELP[parsed.subcommand] : TOP_LEVEL_HELP}\n`,
+            stderr: "",
+        };
+    }
+    if (parsed.mode === "version") {
+        return { exitCode: 0, stdout: `${packageVersion()}\n`, stderr: "" };
+    }
+    if (parsed.mode === "error") {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `${parsed.message ?? "invalid arguments"}\n${TOP_LEVEL_HELP}\n`,
+        };
+    }
+    if (parsed.subcommand === "token") {
+        return dispatchToken(cwd, parsed.format);
+    }
+    if (parsed.subcommand === "check") {
+        return dispatchCheck(cwd, parsed.format);
+    }
+    if (parsed.subcommand === "lint") {
+        return dispatchLint(cwd, parsed.format);
+    }
+    if (parsed.subcommand === "approve") {
+        return dispatchApprove(parsed, cwd);
+    }
+    if (parsed.subcommand === "finalize") {
+        return dispatchFinalize(parsed, cwd);
+    }
+    if (parsed.subcommand === "plan") {
+        return dispatchPlan(parsed, cwd);
+    }
+    if (parsed.subcommand === "doctor") {
+        return dispatchDoctor(parsed, cwd);
+    }
+    if (parsed.subcommand === "report") {
+        return dispatchReport(parsed, cwd);
+    }
+    if (parsed.subcommand === "record") {
+        return dispatchRecord(parsed, cwd);
+    }
+    if (parsed.subcommand === "install") {
+        return dispatchInstall(parsed);
+    }
+    if (parsed.subcommand === "ready") {
+        return dispatchReady(parsed, cwd);
+    }
+    return dispatchRefresh(parsed, cwd);
+}
+function dispatchToken(cwd, format) {
+    const command = new CliTokenHandler({
+        config: new NodeTokenConfigReader(),
+        git: new ChildProcessTokenGit(),
+    });
+    return command.execute(cwd, format === "json" ? "json" : "human");
+}
+function dispatchCheck(cwd, format) {
+    const files = new NodeCheckFileReader();
+    const command = new CliCheckHandler({
+        config: files,
+        git: new ChildProcessCheckGit(),
+        spec: files,
+    });
+    return command.execute(cwd, format === "json" ? "json" : "human");
+}
+function dispatchLint(cwd, format) {
+    const files = new NodeLintFileReader();
+    const command = new CliLintHandler({ config: files, files });
+    return command.execute(cwd, format === "json" ? "json" : "human");
+}
+function dispatchApprove(parsed, cwd) {
+    const approve = parsed.command?.approve;
+    const req = approveRequest(approve ?? {});
+    if (req.mode === "error") {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${req.message}\n${COMMAND_HELP.approve}\n`,
+        });
+    }
+    const files = new NodeApproveFileSystem();
+    const plans = new NodePlanFileWriter();
+    const command = new CliApproveHandler({
+        clock: new SystemApproveClock(),
+        config: files,
+        files,
+        plans,
+    });
+    return command.execute(cwd, req.value, parsed.format === "json" ? "json" : "human", {
+        inline: approve?.inline === true,
+        planId: approve?.planId,
+    });
+}
+function dispatchFinalize(parsed, cwd) {
+    const finalizeFs = new NodeFinalizeFileSystem();
+    const command = new CliFinalizeHandler({
+        clock: new SystemFinalizeClock(),
+        config: finalizeFs,
+        files: finalizeFs,
+        plans: new NodePlanRepo(),
+    });
+    return command.execute(cwd, { planId: parsed.command?.finalize?.planId }, parsed.format === "json" ? "json" : "human");
+}
+function dispatchPlan(parsed, cwd) {
+    const plan = parsed.command?.plan;
+    if (plan?.subcommand !== "show") {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.plan}\n`,
+        });
+    }
+    const reader = new NodePlanReader();
+    const command = new CliPlanShowHandler({ config: reader, reader });
+    return command.execute(cwd, { planId: plan.planId }, parsed.format === "json" ? "json" : "human");
+}
+function dispatchDoctor(parsed, cwd) {
+    const doctor = parsed.command?.doctor;
+    if (doctor === undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.doctor}\n`,
+        });
+    }
+    const command = new CliDoctorHandler({
+        registry: new NodeRegistryReader(),
+    });
+    return command.execute(cwd, {
+        ruleVersion: doctor.ruleVersion,
+        rulesPath: doctor.rulesPath,
+    }, parsed.format === "json" ? "json" : "human");
+}
+function dispatchReport(parsed, cwd) {
+    const report = parsed.command?.report;
+    if (report === undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.report}\n`,
+        });
+    }
+    const reportFs = new NodeReportFileSystem();
+    const git = new ChildProcessReadyGit();
+    const command = new CliReportHandler({
+        config: reportFs,
+        files: reportFs,
+        readAtRef: (root, ref, path) => git.readAtRef(root, ref, path),
+        repoRoot: (cwdInner) => git.repoRoot(cwdInner),
+    });
+    return command.execute(cwd, {
+        prSummary: report.prSummary,
+        against: report.against,
+    }, parsed.format === "json" ? "json" : "human");
+}
+function dispatchRecord(parsed, cwd) {
+    if (parsed.command?.record === undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.record}\n`,
+        });
+    }
+    const record = parsed.command.record;
+    const fs = new NodeRecordFileSystem();
+    const command = new CliRecordHandler({ config: fs, files: fs, writer: fs });
+    const format = parsed.format === "json" ? "json" : "human";
+    const sub = record.subcommand;
+    if (sub === "list") {
+        return command.execute(cwd, { kind: "list", partition: record.partition }, format);
+    }
+    if (sub === "get") {
+        const id = record.id;
+        if (id === undefined) {
+            return Promise.resolve({
+                exitCode: 2,
+                stdout: "",
+                stderr: `${COMMAND_HELP.record}\n`,
+            });
+        }
+        return command.execute(cwd, { kind: "get", id }, format);
+    }
+    const bodyResult = resolveRecordBody(record, cwd);
+    if (bodyResult.error !== undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${bodyResult.error}\n`,
+        });
+    }
+    if (sub === "set") {
+        const id = record.id;
+        if (id === undefined) {
+            return Promise.resolve({
+                exitCode: 2,
+                stdout: "",
+                stderr: `${COMMAND_HELP.record}\n`,
+            });
+        }
+        return command.execute(cwd, { kind: "set", id, body: bodyResult.body }, format);
+    }
+    const afterId = record.afterId;
+    if (afterId === undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.record}\n`,
+        });
+    }
+    const action = {
+        kind: "add",
+        afterId,
+        body: bodyResult.body,
+    };
+    return command.execute(cwd, action, format);
+}
+function dispatchInstall(parsed) {
+    const install = parsed.command?.install;
+    if (install === undefined) {
+        return Promise.resolve({
+            exitCode: 2,
+            stdout: "",
+            stderr: `${COMMAND_HELP.install}\n`,
+        });
+    }
+    const command = new CliInstallHandler({
+        source: new NodeInstallSource(),
+        fs: new NodeInstallTargetFs(),
+    });
+    return command.execute(install.target, { dryRun: install.dryRun, scope: install.scope }, parsed.format === "json" ? "json" : "human");
+}
+function dispatchReady(parsed, cwd) {
+    const fs = new NodeReadyFileSystem();
+    const command = new CliReadyHandler({
+        config: fs,
+        files: fs,
+        git: new ChildProcessReadyGit(),
+    });
+    return command.execute(cwd, parsed.format === "json" ? "json" : "human", parsed.command?.ready?.partition, parsed.command?.ready?.against);
+}
+function dispatchRefresh(parsed, cwd) {
+    const refreshFiles = new NodeRefreshFileReader();
+    const refreshCommand = new CliRefreshHandler({
+        clock: new SystemRefreshClock(),
+        config: refreshFiles,
+        git: new ChildProcessRefreshGit(),
+        spec: refreshFiles,
+    });
+    return refreshCommand.execute(cwd, parsed.format ?? "yaml");
+}
+function parseArgv(argv) {
+    if (argv.length === 0) {
+        return { mode: "help" };
+    }
+    if (argv.length === 1 && argv[0] === "--help") {
+        return { mode: "help" };
+    }
+    if (argv.length === 1 && argv[0] === "--version") {
+        return { mode: "version" };
+    }
+    const subcommand = argv[0];
+    if (!isSubcommand(subcommand)) {
+        return { mode: "error", message: `unknown subcommand: ${subcommand}` };
+    }
+    if (argv.length === 2 && argv[1] === "--help") {
+        return { mode: "help", subcommand };
+    }
+    const rest = argv.slice(1);
+    if (subcommand === "approve") {
+        return parseApproveArgv(rest);
+    }
+    if (subcommand === "ready") {
+        return parseReadyArgv(rest);
+    }
+    if (subcommand === "finalize") {
+        return parseFinalizeArgv(rest);
+    }
+    if (subcommand === "plan") {
+        return parsePlanArgv(rest);
+    }
+    if (subcommand === "doctor") {
+        return parseDoctorArgv(rest);
+    }
+    if (subcommand === "report") {
+        return parseReportArgv(rest);
+    }
+    if (subcommand === "record") {
+        return parseRecordArgv(rest);
+    }
+    if (subcommand === "install") {
+        return parseInstallArgv(rest);
+    }
+    const defaultFormat = subcommand === "refresh" ? "yaml" : "human";
+    let format = defaultFormat;
+    for (const arg of rest) {
+        if (!arg.startsWith("--format=")) {
+            return { mode: "error", message: `unknown flag: ${arg}` };
+        }
+        const value = arg.slice("--format=".length);
+        if (!isFormat(value) || (subcommand !== "refresh" && value === "yaml")) {
+            return { mode: "error", message: `invalid format: ${value}` };
+        }
+        format = value;
+    }
+    return { mode: "command", subcommand, format };
+}
+function parseReadyArgv(args) {
+    const ready = {};
+    let format = "human";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--partition") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --partition" };
+            }
+            ready.partition = next;
+            i++;
+            continue;
+        }
+        if (arg === "--against") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --against" };
+            }
+            ready.against = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    return { mode: "command", subcommand: "ready", format, command: { ready } };
+}
+function parseApproveArgv(args) {
+    const approve = {};
+    let format = "human";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--inline") {
+            approve.inline = true;
+            continue;
+        }
+        if (!arg.startsWith("--")) {
+            return { mode: "error", message: `unknown positional: ${arg}` };
+        }
+        const key = arg.slice(2);
+        const next = args[i + 1];
+        if (next === undefined || next.startsWith("--")) {
+            return { mode: "error", message: `missing value for --${key}` };
+        }
+        i++;
+        switch (key) {
+            case "id":
+                approve.id = next;
+                break;
+            case "approver":
+                approve.approver = next;
+                break;
+            case "owner-role":
+                approve.ownerRole = next;
+                break;
+            case "change-request":
+                approve.changeRequest = next;
+                break;
+            case "scope":
+                approve.scope = next;
+                break;
+            case "target-status":
+                approve.targetStatus = next;
+                break;
+            case "reviewed-test-oracle":
+                approve.reviewedTestOracle = next;
+                break;
+            case "plan":
+                approve.planId = next;
+                break;
+            default:
+                return { mode: "error", message: `unknown flag: --${key}` };
+        }
+    }
+    if (approve.inline === true && approve.planId !== undefined) {
+        return {
+            mode: "error",
+            message: "--inline and --plan are mutually exclusive",
+        };
+    }
+    return {
+        mode: "command",
+        subcommand: "approve",
+        format,
+        command: { approve },
+    };
+}
+function parseFinalizeArgv(args) {
+    const finalize = {};
+    let format = "human";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--plan") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --plan" };
+            }
+            finalize.planId = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    return {
+        mode: "command",
+        subcommand: "finalize",
+        format,
+        command: { finalize },
+    };
+}
+function parsePlanArgv(args) {
+    if (args.length === 0 || args[0] !== "show") {
+        return {
+            mode: "error",
+            message: "expected: sdd plan show [--plan <plan_id>]",
+        };
+    }
+    const plan = { subcommand: "show" };
+    let format = "human";
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--plan") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --plan" };
+            }
+            plan.planId = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    return { mode: "command", subcommand: "plan", format, command: { plan } };
+}
+function approveRequest(args) {
+    if (args.id === undefined) {
+        return { mode: "error", message: "--id required" };
+    }
+    if (args.approver === undefined) {
+        return { mode: "error", message: "--approver required" };
+    }
+    if (args.ownerRole === undefined) {
+        return { mode: "error", message: "--owner-role required" };
+    }
+    if (args.changeRequest === undefined) {
+        return { mode: "error", message: "--change-request required" };
+    }
+    const targetStatus = args.targetStatus ?? "approved";
+    if (!isTargetStatus(targetStatus)) {
+        return {
+            mode: "error",
+            message: `invalid --target-status: ${targetStatus}`,
+        };
+    }
+    return {
+        mode: "ok",
+        value: {
+            id: args.id,
+            approver: args.approver,
+            ownerRole: args.ownerRole,
+            changeRequest: args.changeRequest,
+            scope: args.scope ?? "first-time-approval",
+            targetStatus,
+            reviewedTestOracle: args.reviewedTestOracle ?? null,
+        },
+    };
+}
+function isTargetStatus(value) {
+    return value === "approved" || value === "deprecated" || value === "removed";
+}
+function packageVersion() {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const value = JSON.parse(readFileSync(packagePath, "utf8"));
+    if (!isRecord(value) || typeof value.version !== "string") {
+        throw new Error("package.json version is missing");
+    }
+    return value.version;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSubcommand(value) {
+    return (value === "token" ||
+        value === "check" ||
+        value === "refresh" ||
+        value === "lint" ||
+        value === "approve" ||
+        value === "ready" ||
+        value === "finalize" ||
+        value === "plan" ||
+        value === "doctor" ||
+        value === "report" ||
+        value === "record" ||
+        value === "install");
+}
+function parseRecordArgv(args) {
+    const sub = args[0];
+    if (sub !== "list" && sub !== "get" && sub !== "set" && sub !== "add") {
+        return {
+            mode: "error",
+            message: "expected: sdd record list | get <id> | set <id> | add --after <id>",
+        };
+    }
+    const record = { subcommand: sub };
+    let rest = args.slice(1);
+    if (sub === "get" || sub === "set") {
+        const id = rest[0];
+        if (id === undefined || id.startsWith("--")) {
+            return { mode: "error", message: `expected: sdd record ${sub} <id>` };
+        }
+        record.id = id;
+        rest = rest.slice(1);
+    }
+    const parsedFlags = parseRecordFlags(rest, record);
+    if (parsedFlags.mode === "error") {
+        return parsedFlags;
+    }
+    if (sub === "add" && record.afterId === undefined) {
+        return { mode: "error", message: "sdd record add requires --after <id>" };
+    }
+    if (sub === "set" || sub === "add") {
+        const hasContent = record.content !== undefined;
+        const hasFile = record.fromFile !== undefined;
+        if (hasContent === hasFile) {
+            return {
+                mode: "error",
+                message: "provide exactly one of --from-file <path> or --content <body>",
+            };
+        }
+    }
+    return {
+        mode: "command",
+        subcommand: "record",
+        format: parsedFlags.format,
+        command: { record },
+    };
+}
+function parseRecordFlags(rest, record) {
+    const sub = record.subcommand;
+    let format = "human";
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--partition" && sub === "list") {
+            const next = rest[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --partition" };
+            }
+            record.partition = next;
+            i++;
+            continue;
+        }
+        if (arg === "--after" && sub === "add") {
+            const next = rest[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --after" };
+            }
+            record.afterId = next;
+            i++;
+            continue;
+        }
+        if (arg === "--content" && (sub === "set" || sub === "add")) {
+            const next = rest[i + 1];
+            if (next === undefined) {
+                return { mode: "error", message: "missing value for --content" };
+            }
+            record.content = next;
+            i++;
+            continue;
+        }
+        if (arg === "--from-file" && (sub === "set" || sub === "add")) {
+            const next = rest[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --from-file" };
+            }
+            record.fromFile = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    return { mode: "ok", format };
+}
+function parseInstallArgv(args) {
+    const target = args[0];
+    if (target === undefined || !isInstallTarget(target)) {
+        return {
+            mode: "error",
+            message: "expected: sdd install <all|claude|codex>",
+        };
+    }
+    const install = { target, dryRun: false, scope: "user" };
+    let format = "human";
+    const rest = args.slice(1);
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            install.dryRun = true;
+            continue;
+        }
+        if (arg === "--scope" || arg.startsWith("--scope=")) {
+            const value = arg.startsWith("--scope=")
+                ? arg.slice("--scope=".length)
+                : rest[++i];
+            if (value !== "user" && value !== "project") {
+                return {
+                    mode: "error",
+                    message: `invalid scope: ${value ?? "(missing)"}`,
+                };
+            }
+            install.scope = value;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    return {
+        mode: "command",
+        subcommand: "install",
+        format,
+        command: { install },
+    };
+}
+function resolveRecordBody(record, cwd) {
+    if (record.content !== undefined) {
+        return { body: record.content };
+    }
+    const fromFile = record.fromFile;
+    if (fromFile === undefined) {
+        return { error: "provide --from-file or --content" };
+    }
+    try {
+        return { body: readFileSync(resolve(cwd, fromFile), "utf8") };
+    }
+    catch {
+        return { error: `cannot read --from-file: ${fromFile}` };
+    }
+}
+function parseReportArgv(args) {
+    const report = { prSummary: false };
+    let format = "human";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--pr-summary") {
+            report.prSummary = true;
+            continue;
+        }
+        if (arg === "--against") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --against" };
+            }
+            report.against = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    if (!report.prSummary) {
+        return { mode: "error", message: "report requires --pr-summary" };
+    }
+    return {
+        mode: "command",
+        subcommand: "report",
+        format,
+        command: { report },
+    };
+}
+function parseDoctorArgv(args) {
+    const doctor = {
+        ruleVersion: false,
+        rulesPath: "rules/enforcement_registry.md",
+    };
+    let format = "human";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--format=")) {
+            const value = arg.slice("--format=".length);
+            if (!isFormat(value) || value === "yaml") {
+                return { mode: "error", message: `invalid format: ${value}` };
+            }
+            format = value;
+            continue;
+        }
+        if (arg === "--rule-version") {
+            doctor.ruleVersion = true;
+            continue;
+        }
+        if (arg === "--rules") {
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith("--")) {
+                return { mode: "error", message: "missing value for --rules" };
+            }
+            doctor.rulesPath = next;
+            i++;
+            continue;
+        }
+        return { mode: "error", message: `unknown flag: ${arg}` };
+    }
+    if (!doctor.ruleVersion) {
+        return { mode: "error", message: "doctor requires --rule-version" };
+    }
+    return {
+        mode: "command",
+        subcommand: "doctor",
+        format,
+        command: { doctor },
+    };
+}
+function isFormat(value) {
+    return value === "json" || value === "human" || value === "yaml";
+}
+if (isEntrypoint()) {
+    const result = await main(process.argv.slice(2), process.cwd());
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}
+function isEntrypoint() {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+}