open-multi-agent-kit 0.78.0

package/dist/cli/register-spec-agent-goal-commands.js

@@ -0,0 +1,441 @@
+import { t } from "../util/i18n.js";
+import { CliError } from "../util/cli-contract.js";
+export function registerSpecAgentGoalCommands(program) {
+    const specify = program.command("specify").description(t("cli.specifyDesc"));
+    specify
+        .command("init")
+        .description("Initialize spec-driven development (spec-kit)")
+        .option("--preset <name>", "Preset to apply")
+        .action(async (options) => {
+        const { specifyInitCommand } = await import("../commands/specify.js");
+        await specifyInitCommand(options);
+    });
+    const specifyWf = specify.command("workflow").description("Manage spec-kit workflows");
+    specifyWf
+        .command("run <workflow-id>")
+        .description("Run a spec-kit workflow (e.g. speckit)")
+        .option("-i, --input <pairs...>", "Input key=value pairs")
+        .action(async (workflowId, options) => {
+        const { specifyWorkflowRunCommand } = await import("../commands/specify.js");
+        const inputs = {};
+        if (options.input) {
+            for (const pair of Array.isArray(options.input) ? options.input : [options.input]) {
+                const [k, v] = pair.split("=");
+                if (k)
+                    inputs[k] = v ?? "";
+            }
+        }
+        await specifyWorkflowRunCommand(workflowId, inputs);
+    });
+    specifyWf
+        .command("list")
+        .description("List installed workflows")
+        .action(async () => {
+        const { specifyWorkflowListCommand } = await import("../commands/specify.js");
+        await specifyWorkflowListCommand();
+    });
+    const specifyExt = specify.command("extension").description("Manage spec-kit extensions");
+    specifyExt
+        .command("add <name>")
+        .description("Add an extension")
+        .action(async (name) => {
+        const { specifyExtensionAddCommand } = await import("../commands/specify.js");
+        await specifyExtensionAddCommand(name);
+    });
+    specifyExt
+        .command("list")
+        .description("List installed extensions")
+        .action(async () => {
+        const { specifyExtensionListCommand } = await import("../commands/specify.js");
+        await specifyExtensionListCommand();
+    });
+    specify
+        .command("version")
+        .description("Show spec-kit version")
+        .action(async () => {
+        const { specifyVersionCommand } = await import("../commands/specify.js");
+        await specifyVersionCommand();
+    });
+    const spec = program.command("spec").description(t("cmd.specDesc"));
+    spec
+        .command("init")
+        .description(t("cmd.specInitDesc"))
+        .option("-f, --force", t("cmd.specInitForceOption"))
+        .action(async (options) => {
+        const { specInitCommand } = await import("../commands/spec.js");
+        await specInitCommand(options);
+    });
+    spec
+        .command("status")
+        .description(t("cmd.specStatusDesc"))
+        .action(async () => {
+        const { specStatusCommand } = await import("../commands/spec.js");
+        await specStatusCommand();
+    });
+    spec
+        .command("check")
+        .description(t("cmd.specCheckDesc"))
+        .action(async () => {
+        const { specCheckCommand } = await import("../commands/spec.js");
+        await specCheckCommand();
+    });
+    const specPreset = spec.command("preset").description("Manage spec-kit presets");
+    specPreset
+        .command("install <name>")
+        .description("Install a spec-kit preset (built-in: omk)")
+        .action(async (name) => {
+        const { specPresetInstallCommand } = await import("../commands/spec.js");
+        await specPresetInstallCommand(name);
+    });
+    const agent = program.command("agent").description(t("cmd.agentDesc"));
+    agent
+        .command("list")
+        .description(t("cmd.agentListDesc"))
+        .action(async () => {
+        const { agentListCommand } = await import("../commands/agent.js");
+        await agentListCommand();
+    });
+    agent
+        .command("show <name>")
+        .description(t("cmd.agentShowDesc"))
+        .action(async (name) => {
+        const { agentShowCommand } = await import("../commands/agent.js");
+        await agentShowCommand(name);
+    });
+    agent
+        .command("create <name>")
+        .description(t("cmd.agentCreateDesc"))
+        .option("--from <template>", t("cmd.agentCreateFromOption"))
+        .action(async (name, options) => {
+        const { agentCreateCommand } = await import("../commands/agent.js");
+        await agentCreateCommand(name, options);
+    });
+    agent
+        .command("doctor")
+        .description(t("cmd.agentDoctorDesc"))
+        .action(async () => {
+        const { agentDoctorCommand } = await import("../commands/agent.js");
+        await agentDoctorCommand();
+    });
+    program
+        .command("verify")
+        .description(t("cmd.verifyDesc"))
+        .option("--run <id>", t("cmd.verifyRunOption"))
+        .option("--json", t("cmd.verifyJsonOption"))
+        .action(async (options) => {
+        const globalOpts = program.opts();
+        const { verifyCommand } = await import("../commands/verify.js");
+        try {
+            await verifyCommand({ ...options, runId: globalOpts.runId });
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    const goal = program.command("goal").description(t("cmd.goalDesc"));
+    goal
+        .command("create <rawPrompt>")
+        .description(t("cmd.goalCreateDesc"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .option("--title <title>", t("cmd.goalTitleOption"))
+        .option("--objective <text>", t("cmd.goalObjectiveOption"))
+        .option("--risk <level>", t("cmd.goalRiskOption"))
+        .action(async (rawPrompt, options) => {
+        const { goalCreateCommand } = await import("../commands/goal.js");
+        try {
+            await goalCreateCommand(rawPrompt, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("list")
+        .description(t("cmd.goalListDesc"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (options) => {
+        const { goalListCommand } = await import("../commands/goal.js");
+        try {
+            await goalListCommand(options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("show <goal-id>")
+        .description(t("cmd.goalShowDesc"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalShowCommand } = await import("../commands/goal.js");
+        try {
+            await goalShowCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("plan <goal-id>")
+        .description(t("cmd.goalPlanDesc"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalPlanCommand } = await import("../commands/goal.js");
+        try {
+            await goalPlanCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("run <goal-id>")
+        .description(t("cmd.goalRunDesc"))
+        .option("--workers <n>", t("cmd.goalWorkersOption"), "auto")
+        .option("--run-id <id>", t("cmd.goalRunIdOption"))
+        .option("--mcp-scope <all|project|none>", "MCP scope for this goal DAG run (all | project | none)")
+        .option("--provider <provider>", "provider policy (auto | authority | kimi | deepseek | codex | qwen | openrouter)", "auto")
+        .option("--model <model>", "provider model or provider/model override")
+        .option("--approval-policy <policy>", t("cmd.parallelApprovalOption"), "interactive")
+        .option("--timeout-preset <preset>", t("cmd.runTimeoutPresetOption"))
+        .option("--watch", t("cmd.parallelWatchOption"))
+        .option("--no-watch", t("cmd.parallelNoWatchOption"))
+        .option("--view <mode>", "Display mode: cockpit | table | compact", "cockpit")
+        .option("--max-auto-continue-iterations <n>", "maximum automatic continue/replan iterations")
+        .action(async (goalId, options) => {
+        const globalOpts = program.opts();
+        const { goalRunCommand } = await import("../commands/goal.js");
+        try {
+            await goalRunCommand(goalId, {
+                ...options,
+                runId: options.runId ?? globalOpts.runId,
+                watch: options.watch,
+            });
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("verify <goal-id>")
+        .description(t("cmd.goalVerifyDesc"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalVerifyCommand } = await import("../commands/goal.js");
+        try {
+            await goalVerifyCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("close <goal-id>")
+        .description(t("cmd.goalCloseDesc"))
+        .option("--force", t("cmd.goalForceOption"))
+        .option("--reason <text>", t("cmd.goalReasonOption"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalCloseCommand } = await import("../commands/goal.js");
+        try {
+            await goalCloseCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("block <goal-id>")
+        .description(t("cmd.goalBlockDesc"))
+        .requiredOption("--reason <text>", t("cmd.goalReasonOption"))
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { goalBlockCommand } = await import("../commands/goal.js");
+        try {
+            await goalBlockCommand(goalId, options);
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("continue [goal-id]")
+        .description("Continue the latest active goal (or specified goal-id)")
+        .option("--workers <n>", "Worker count", "auto")
+        .option("--run-id <id>", "Run ID")
+        .option("--from-run-id <id>", "Run ID to read as continuation context")
+        .option("--mcp-scope <all|project|none>", "MCP scope for this goal continuation DAG (all | project | none)")
+        .option("--provider <provider>", "provider policy (auto | authority | kimi | deepseek | codex | qwen | openrouter)", "auto")
+        .option("--model <model>", "provider model or provider/model override")
+        .option("--approval-policy <policy>", t("cmd.parallelApprovalOption"), "interactive")
+        .option("--timeout-preset <preset>", t("cmd.runTimeoutPresetOption"))
+        .option("--watch", t("cmd.parallelWatchOption"))
+        .option("--no-watch", t("cmd.parallelNoWatchOption"))
+        .option("--view <mode>", "Display mode: cockpit | table | compact", "cockpit")
+        .option("--max-auto-continue-iterations <n>", "maximum automatic continue/replan iterations")
+        .action(async (goalId, options) => {
+        const globalOpts = program.opts();
+        const { goalContinueCommand } = await import("../commands/goal.js");
+        try {
+            await goalContinueCommand(goalId, {
+                ...options,
+                runId: options.runId ?? globalOpts.runId,
+                watch: options.watch,
+            });
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("auto [goal-id]")
+        .description("Automatically continue/replan a goal within bounded iterations")
+        .option("--workers <n>", "Worker count", "auto")
+        .option("--run-id <id>", "Run ID")
+        .option("--from-run-id <id>", "Run ID to read as continuation context")
+        .option("--mcp-scope <all|project|none>", "MCP scope for this goal auto DAG (all | project | none)")
+        .option("--provider <provider>", "provider policy (auto | authority | kimi | deepseek | codex | qwen | openrouter)", "auto")
+        .option("--model <model>", "provider model or provider/model override")
+        .option("--approval-policy <policy>", t("cmd.parallelApprovalOption"), "interactive")
+        .option("--timeout-preset <preset>", t("cmd.runTimeoutPresetOption"))
+        .option("--watch", t("cmd.parallelWatchOption"))
+        .option("--no-watch", t("cmd.parallelNoWatchOption"))
+        .option("--view <mode>", "Display mode: cockpit | table | compact", "cockpit")
+        .option("--max-auto-continue-iterations <n>", "maximum automatic continue/replan iterations")
+        .action(async (goalId, options) => {
+        const globalOpts = program.opts();
+        const { goalContinueCommand } = await import("../commands/goal.js");
+        try {
+            await goalContinueCommand(goalId, {
+                ...options,
+                runId: options.runId ?? globalOpts.runId,
+                watch: options.watch,
+            });
+        }
+        catch (err) {
+            if (err instanceof CliError) {
+                if (process.exitCode === undefined)
+                    process.exitCode = err.exitCode;
+                return;
+            }
+            throw err;
+        }
+    });
+    goal
+        .command("watch <goal-id>")
+        .description("Start the in-process goal daemon for a goal")
+        .option("--provider <provider>", "provider policy (auto | authority | kimi | deepseek | codex | qwen | openrouter)", "auto")
+        .option("--approval-policy <policy>", t("cmd.parallelApprovalOption"), "interactive")
+        .option("--interval-ms <ms>", "Daemon loop interval in milliseconds")
+        .option("--max-iterations <n>", "Maximum daemon iterations")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { defaultGoalDaemon } = await import("../goal/goal-daemon.js");
+        const { goalVerifyCommand, goalContinueCommand, goalBlockCommand } = await import("../commands/goal.js");
+        const started = defaultGoalDaemon.start(goalId, {
+            provider: options.provider,
+            approvalPolicy: options.approvalPolicy,
+            intervalMs: options.intervalMs ? Number.parseInt(options.intervalMs, 10) : undefined,
+            maxIterations: options.maxIterations ? Number.parseInt(options.maxIterations, 10) : undefined,
+            onVerify: async (id) => { await goalVerifyCommand(id, { json: true }); },
+            onContinue: async (id, runOptions) => { await goalContinueCommand(id, runOptions); },
+            onBlock: async (id, reason) => { await goalBlockCommand(id, { reason, json: true }); },
+        });
+        const payload = { goalId, running: started };
+        if (options.json)
+            console.log(JSON.stringify(payload, null, 2));
+        else
+            console.log(started ? `Goal daemon started for ${goalId}` : `Goal daemon already running for ${goalId}`);
+    });
+    goal
+        .command("wake <goal-id>")
+        .description("Wake a sleeping goal daemon")
+        .option("--reason <text>", "Wake reason")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { defaultGoalDaemon } = await import("../goal/goal-daemon.js");
+        const ok = defaultGoalDaemon.wake(goalId, options.reason);
+        const payload = { goalId, woken: ok };
+        if (options.json)
+            console.log(JSON.stringify(payload, null, 2));
+        else
+            console.log(ok ? `Goal daemon woken for ${goalId}` : `No sleeping daemon for ${goalId}`);
+    });
+    goal
+        .command("sleep <goal-id>")
+        .description("Pause a running goal daemon until it is woken")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { defaultGoalDaemon } = await import("../goal/goal-daemon.js");
+        const ok = defaultGoalDaemon.sleep(goalId);
+        const payload = { goalId, sleeping: ok };
+        if (options.json)
+            console.log(JSON.stringify(payload, null, 2));
+        else
+            console.log(ok ? `Goal daemon sleeping for ${goalId}` : `No running daemon for ${goalId}`);
+    });
+    goal
+        .command("daemon [goal-id]")
+        .description("Show goal daemon status")
+        .option("--json", t("cmd.goalJsonOption"))
+        .action(async (goalId, options) => {
+        const { defaultGoalDaemon } = await import("../goal/goal-daemon.js");
+        const payload = goalId
+            ? { goalId, status: defaultGoalDaemon.getStatus(goalId) }
+            : { running: defaultGoalDaemon.listRunning() };
+        if (options.json)
+            console.log(JSON.stringify(payload, null, 2));
+        else
+            console.log(JSON.stringify(payload, null, 2));
+    });
+}

package/dist/cli/register-tool-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerToolCommands(program: Command): void;

package/dist/cli/register-tool-commands.js

@@ -0,0 +1,191 @@
+import { t } from "../util/i18n.js";
+export function registerToolCommands(program) {
+    const graph = program.command("graph").description("Inspect OMK ontology graph");
+    graph
+        .command("view")
+        .description("Generate an HTML view for .omk/memory/graph-state.json")
+        .option("--input <path>", "Input graph-state.json path")
+        .option("--output <path>", "Output HTML path")
+        .option("--limit <n>", "Maximum visible nodes", "900")
+        .option("--type <types>", "Comma-separated node types, e.g. Memory,Decision,Task,Risk,File")
+        .option("--include-memory-versions", "Include MemoryVersion nodes")
+        .option("--open", "Open generated HTML in browser")
+        .action(async (options) => {
+        const { graphViewCommand } = await import("../commands/graph.js");
+        await graphViewCommand(options);
+    });
+    program
+        .command("hud")
+        .description(t("cmd.hudDesc"))
+        .option("-w, --watch", t("cmd.hudWatchOption"))
+        .option("--refresh <ms>", t("cmd.hudRefreshOption"), "2000")
+        .option("--compact", "show compact dashboard")
+        .option("--section <section>", "show only one section (run|project|resources)")
+        .option("--no-clear", "do not clear screen between refreshes")
+        .option("--alternate-screen", "use alternate screen buffer")
+        .action(async (options) => {
+        const globalOpts = program.opts();
+        const { hudCommand } = await import("../commands/hud.js");
+        const validSections = ["run", "project", "resources"];
+        if (options.section && !validSections.includes(options.section)) {
+            console.error(`Invalid section: ${options.section}. Valid values: ${validSections.join(", ")}`);
+            process.exit(1);
+        }
+        await hudCommand({
+            runId: globalOpts.runId,
+            watch: Boolean(options.watch),
+            refreshMs: Number.parseInt(options.refresh, 10),
+            compact: options.compact,
+            section: options.section,
+            noClear: options.noClear,
+            alternateScreen: options.alternateScreen,
+        });
+    });
+    program
+        .command("merge [run-id]")
+        .description(t("cmd.mergeDesc"))
+        .option("--run <id>", "run ID", "latest")
+        .option("--strategy <strategy>", "merge strategy (first | best)", "first")
+        .option("--dry-run", "preview merge without applying")
+        .action(async (runIdArg, options) => {
+        const globalOpts = program.opts();
+        const { mergeCommand } = await import("../commands/merge.js");
+        await mergeCommand({ ...options, runId: globalOpts.runId, run: runIdArg ?? options.run });
+    });
+    program
+        .command("sync")
+        .description(t("cmd.syncDesc"))
+        .option("--global", t("cmd.syncGlobalOption"))
+        .option("--dry-run", t("cmd.syncDryRunOption"))
+        .option("--diff", t("cmd.syncDiffOption"))
+        .option("--rollback", t("cmd.syncRollbackOption"))
+        .action(async (options) => {
+        const { syncCommand } = await import("../commands/sync.js");
+        await syncCommand(options);
+    });
+    program
+        .command("lsp [server]")
+        .description(t("cmd.lspDesc"))
+        .option("--print-config", t("cmd.lspPrintConfigOption"))
+        .option("--check", t("cmd.lspCheckOption"))
+        .action(async (server, options) => {
+        const { lspCommand } = await import("../commands/lsp.js");
+        await lspCommand(server, options);
+    });
+    const design = program.command("design").description(t("cmd.designDesc"));
+    design
+        .command("init")
+        .description(t("cmd.designInitDesc"))
+        .action(async () => {
+        const { designInitCommand } = await import("../commands/design.js");
+        await designInitCommand();
+    });
+    design
+        .command("list")
+        .description(t("cmd.designListDesc"))
+        .action(async () => {
+        const { designListCommand } = await import("../commands/design.js");
+        await designListCommand();
+    });
+    design
+        .command("apply <name>")
+        .description(t("cmd.designDownloadDesc"))
+        .action(async (name) => {
+        const { designApplyCommand } = await import("../commands/design.js");
+        await designApplyCommand(name);
+    });
+    design
+        .command("search <keyword>")
+        .description(t("cmd.designSearchDesc"))
+        .action(async (keyword) => {
+        const { designSearchCommand } = await import("../commands/design.js");
+        await designSearchCommand(keyword);
+    });
+    design
+        .command("open-design")
+        .alias("od")
+        .description(t("cmd.designOpenDesignDesc"))
+        .option("--dir <path>", "Open Design checkout directory (default: .omk/open-design)")
+        .option("--branch <branch>", "Open Design git branch or tag", "main")
+        .option("--ref <ref>", "Open Design git ref/branch/tag/SHA (or OMK_OPEN_DESIGN_REF)")
+        .option("--daemon-port <port>", "Open Design daemon localhost port", "7457")
+        .option("--web-port <port>", "Open Design web localhost port", "5175")
+        .option("--doctor", "Check Open Design bridge readiness without cloning, installing, or starting")
+        .option("--foreground", "Run tools-dev in the foreground")
+        .option("--no-install", "Skip pnpm install")
+        .option("--update", "Run git pull --ff-only when the checkout already exists")
+        .option("--open", "Open the localhost URL in the default browser")
+        .option("--print-only", "Print the launch plan without cloning, installing, or starting")
+        .option("--json", "With --doctor, output machine-readable JSON")
+        .action(async (options) => {
+        const { designOpenDesignCommand } = await import("../commands/design.js");
+        await designOpenDesignCommand(options);
+    });
+    design
+        .command("lint [file]")
+        .description(t("cmd.designValidateDesc"))
+        .action(async (file) => {
+        const { designLintCommand } = await import("../commands/design.js");
+        await designLintCommand(file);
+    });
+    design
+        .command("diff [from] [to]")
+        .description("DESIGN.md diff")
+        .action(async (from, to) => {
+        const { designDiffCommand } = await import("../commands/design.js");
+        await designDiffCommand(from, to);
+    });
+    design
+        .command("export <format> [file]")
+        .description(t("cmd.designExportDesc"))
+        .action(async (format, file) => {
+        const { designExportCommand } = await import("../commands/design.js");
+        await designExportCommand(format, file);
+    });
+    const google = program.command("google").description(t("cmd.googleDesc"));
+    google
+        .command("stitch-install")
+        .description(t("cmd.googleSkillsDesc"))
+        .action(async () => {
+        const { stitchInstallCommand } = await import("../commands/google.js");
+        await stitchInstallCommand();
+    });
+    const snip = program.command("snip").description("Manage reusable code snippets");
+    snip
+        .command("save <name>")
+        .description("Save a snippet from stdin or file")
+        .option("-f, --file <path>", "Read snippet content from file")
+        .option("-t, --tags <tags>", "Comma-separated tags")
+        .action(async (name, options) => {
+        const { snipSaveCommand } = await import("../commands/snip.js");
+        await snipSaveCommand(name, options);
+    });
+    snip
+        .command("get <name>")
+        .description("Print a snippet")
+        .action(async (name) => {
+        const { snipGetCommand } = await import("../commands/snip.js");
+        await snipGetCommand(name);
+    });
+    snip
+        .command("list")
+        .description("List all snippets")
+        .action(async () => {
+        const { snipListCommand } = await import("../commands/snip.js");
+        await snipListCommand();
+    });
+    snip
+        .command("search <query>")
+        .description("Search snippets")
+        .action(async (query) => {
+        const { snipSearchCommand } = await import("../commands/snip.js");
+        await snipSearchCommand(query);
+    });
+    snip
+        .command("delete <name>")
+        .description("Delete a snippet")
+        .action(async (name) => {
+        const { snipDeleteCommand } = await import("../commands/snip.js");
+        await snipDeleteCommand(name);
+    });
+}

package/dist/cli/register-workflow-commands.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerWorkflowCommands(program: Command): void;