@solaqua/skul 0.1.0

package/dist/cli.js

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHeadlessMode = isHeadlessMode;
+exports.createHeadlessPromptClient = createHeadlessPromptClient;
+exports.createPromptClient = createPromptClient;
+exports.createPromptClientForSelections = createPromptClientForSelections;
+exports.createHelpText = createHelpText;
+exports.parseCliArgs = parseCliArgs;
+const commander_1 = require("commander");
+const bundle_discovery_1 = require("./bundle-discovery");
+const bundle_items_1 = require("./bundle-items");
+const tool_mapping_1 = require("./tool-mapping");
+const VALID_TOOL_NAMES = new Set((0, tool_mapping_1.listToolDefinitions)().map((t) => t.name));
+const COMMANDS = [
+    "add",
+    "list",
+    "status",
+    "check",
+    "update",
+    "shadow",
+    "sync",
+    "reset",
+    "remove",
+    "apply",
+];
+const PROGRAM_HELP_DETAILS = [
+    "",
+    "Root instructions:",
+    "  cursor, codex, opencode, kiro, copilot, and antigravity target AGENTS.md; globally, codex targets .codex/AGENTS.md, opencode targets .config/opencode/AGENTS.md, kiro targets .kiro/steering/AGENTS.md, copilot targets .github/copilot-instructions.md, and antigravity targets .gemini/GEMINI.md; claude-code targets CLAUDE.md.",
+    "  Untracked root instructions are composed locally and hidden through .git/info/exclude.",
+    "  Tracked root instructions are rendered from HEAD plus Skul overlay content and marked skip-worktree.",
+    "",
+    "Safety and recovery:",
+    "  Use 'skul sync' for fast-forward pulls. For manual git updates, run 'skul shadow --suspend' before and 'skul shadow --refresh' after, as long as the root instruction file is still tracked.",
+    "  Shadow refresh refuses staged changes, unstaged edits, unmerged files, incompatible index flags, and manual edits to the current shadow render.",
+    "  'skul status' reports tracked shadow health; manual edits to shadowed root instruction files are a current limitation.",
+].join("\n");
+const ADD_HELP_DETAILS = [
+    "",
+    "Root instruction targets:",
+    "  Bundles may contribute root instruction files alongside skills/ and commands/ content.",
+    "  If the target root instruction file is already tracked, Skul creates a tracked shadow instead of leaving a visible git diff.",
+].join("\n");
+const SHADOW_HELP_DETAILS = [
+    "",
+    "Lifecycle:",
+    "  --suspend restores tracked root instruction files from HEAD and clears skip-worktree.",
+    "  --refresh rebuilds the effective shadow from the latest HEAD plus Skul overlay content and re-enables skip-worktree.",
+    "  The manual suspend/refresh flow only works when the root instruction file is still tracked after the Git update.",
+    "  Refresh refuses staged changes, unstaged edits, unmerged files, incompatible index flags, and manual edits to the current shadow render.",
+    "",
+    "Examples:",
+    "  skul shadow --suspend",
+    "  git pull --ff-only",
+    "  skul shadow --refresh",
+].join("\n");
+const SYNC_HELP_DETAILS = [
+    "",
+    "Lifecycle:",
+    "  Typical workflow: skul shadow --suspend -> git pull --ff-only -> skul shadow --refresh",
+    "  Prefer this in headless automation so tracked root instruction shadows are suspended and restored in one step.",
+    "  If git pull fails, Skul attempts to restore the prior shadow state before returning the error.",
+    "  If upstream stops tracking a shadowed root instruction, sync retires the shadow and removes its local state.",
+].join("\n");
+let clackPromptsModulePromise;
+// Commander is loaded in CommonJS mode for the CLI entrypoint, so use a tiny
+// dynamic-import bridge for the ESM-only @clack/prompts package.
+const loadEsmModule = new Function("specifier", "return import(specifier);");
+/**
+ * Returns true if the CLI should run in headless (non-interactive) mode.
+ * Detected via the SKUL_NO_TUI environment variable.
+ */
+function isHeadlessMode() {
+    return (process.env["SKUL_NO_TUI"] === "1" || process.env["SKUL_NO_TUI"] === "true");
+}
+/**
+ * Creates a prompt client that throws immediately instead of opening interactive
+ * prompts. Use this when SKUL_NO_TUI is set so agents never block waiting for input.
+ */
+function createHeadlessPromptClient() {
+    return {
+        async selectBundle(source) {
+            const hint = source ? `skul add ${source} <bundle>` : "skul add <bundle>";
+            throw new Error(`Bundle name is required in headless mode.\nHint: run '${hint}' to specify the bundle explicitly`);
+        },
+        async selectBundleFromSelections(_availableBundles, source) {
+            const hint = source
+                ? `skul remove ${source} <bundle>`
+                : "skul remove <bundle>";
+            throw new Error(`Bundle name is required in headless mode.\nHint: run '${hint}' to specify the bundle explicitly`);
+        },
+        async selectBundleItems() {
+            throw new Error("Bundle item selection requires an interactive terminal.\nHint: rerun with --include <item> instead of --select-items");
+        },
+        async selectBundleItemChoices() {
+            throw new Error("Bundle item selection requires an interactive terminal.\nHint: rerun with --include <item> instead of --select-items");
+        },
+        async selectAgents(availableAgents) {
+            throw new Error(`Agent selection is required in headless mode.\nHint: run 'skul add --agent <name>' to specify agents explicitly. Available: ${availableAgents.join(", ")}`);
+        },
+        async resolveFileConflict(conflictPath) {
+            throw new Error(`Conflict on ${conflictPath}: file already exists (headless mode)\nHint: run interactively to confirm overwrite`);
+        },
+        async confirmManagedFileRemoval(conflictPath, operation) {
+            throw new Error(`Modified managed file blocks ${operation} in headless mode: ${conflictPath}\nHint: run 'skul status' to inspect managed files, or run the command interactively to confirm`);
+        },
+    };
+}
+/** Creates the interactive prompt client used by the terminal UI. */
+function createPromptClient(availableBundles = []) {
+    const bundleSelections = availableBundles.map((bundle) => ({ bundle }));
+    return createPromptClientForSelections(bundleSelections);
+}
+/** Creates an interactive prompt client from richer bundle selection metadata. */
+function createPromptClientForSelections(availableBundles, loadPrompts = loadClackPromptsModule) {
+    return {
+        async selectBundle(source) {
+            if (availableBundles.length === 0) {
+                throw new Error(source
+                    ? `No bundles cached for ${source}. Run 'skul add ${source} <bundle>' to fetch one first`
+                    : "No bundles cached. Run 'skul add <source> <bundle>' to fetch one first");
+            }
+            const { isCancel, select } = await loadPrompts();
+            const choice = await select({
+                message: source ? `Select a bundle from ${source}` : "Select a bundle",
+                options: availableBundles.map((bundle) => ({
+                    value: bundle,
+                    label: formatBundleSelectionLabel(bundle, availableBundles),
+                })),
+            });
+            if (isCancel(choice)) {
+                throw new Error("Interactive bundle selection was cancelled");
+            }
+            return choice;
+        },
+        async selectBundleFromSelections(availableSelections, source) {
+            return createPromptClientForSelections(availableSelections, loadPrompts).selectBundle(source);
+        },
+        async selectBundleItems(availableItems, selectedItems, purpose = "install") {
+            return promptForBundleItemChoices(availableItems.map((item) => ({ value: item, label: item })), selectedItems, purpose, loadPrompts);
+        },
+        async selectBundleItemChoices(availableItems, selectedItems, purpose = "install") {
+            return promptForBundleItemChoices(availableItems, selectedItems, purpose, loadPrompts);
+        },
+        async selectAgents(availableAgents) {
+            if (availableAgents.length === 0) {
+                throw new Error("This bundle has no available agents");
+            }
+            const { isCancel, multiselect } = await loadPrompts();
+            const selected = await multiselect({
+                message: "Choose agents to install for (Space toggles choices; Enter confirms)",
+                options: availableAgents.map((agent) => ({
+                    value: agent,
+                    label: agent,
+                })),
+                required: true,
+            });
+            if (isCancel(selected)) {
+                throw new Error("Agent selection was cancelled");
+            }
+            return selected;
+        },
+        async resolveFileConflict(conflictPath) {
+            const { isCancel, confirm } = await loadPrompts();
+            const shouldOverwrite = await confirm({
+                message: `${conflictPath} already exists — overwrite it?`,
+            });
+            if (isCancel(shouldOverwrite) || !shouldOverwrite) {
+                throw new Error(`Conflict not resolved: ${conflictPath} already exists`);
+            }
+            return { action: "overwrite" };
+        },
+        async confirmManagedFileRemoval(conflictPath, operation) {
+            const { confirm, isCancel } = await loadPrompts();
+            const message = operation === "replace"
+                ? `Managed file was modified and must be removed before replacement: ${conflictPath}`
+                : operation === "remove"
+                    ? `Managed file was modified and must be removed during bundle removal: ${conflictPath}`
+                    : `Managed file was modified and must be removed during reset: ${conflictPath}`;
+            const confirmed = await confirm({
+                message,
+                initialValue: false,
+            });
+            if (isCancel(confirmed)) {
+                throw new Error("Managed file removal confirmation was cancelled");
+            }
+            return confirmed;
+        },
+    };
+}
+async function promptForBundleItemChoices(availableItems, selectedItems, purpose, loadPrompts) {
+    if (availableItems.length === 0) {
+        throw new Error("This bundle has no selectable items");
+    }
+    const { isCancel, multiselect } = await loadPrompts();
+    const choice = await multiselect({
+        message: `Choose bundle items to ${purpose} (Space toggles choices; Enter confirms)`,
+        options: availableItems,
+        initialValues: selectedItems,
+        required: true,
+    });
+    if (isCancel(choice)) {
+        throw new Error("Interactive bundle item selection was cancelled");
+    }
+    return choice;
+}
+function loadClackPromptsModule() {
+    clackPromptsModulePromise ??= loadEsmModule("@clack/prompts");
+    return clackPromptsModulePromise;
+}
+/** Renders CLI help text for either the full program or one subcommand. */
+function createHelpText(command) {
+    const output = [];
+    const program = createProgram({
+        selectBundle: async () => ({ bundle: "" }),
+        selectBundleFromSelections: async (availableBundles) => availableBundles[0] ?? { bundle: "" },
+        selectBundleItems: async () => [],
+        selectBundleItemChoices: async () => [],
+        selectAgents: async (agents) => agents,
+        resolveFileConflict: async () => ({ action: "overwrite" }),
+        confirmManagedFileRemoval: async () => true,
+    });
+    const writeOutput = (chunk) => {
+        output.push(chunk);
+    };
+    program.configureOutput({
+        writeOut: writeOutput,
+        writeErr: writeOutput,
+    });
+    if (command) {
+        const subcommand = program.commands.find((c) => c.name() === command);
+        if (subcommand) {
+            subcommand.configureOutput({
+                writeOut: writeOutput,
+                writeErr: writeOutput,
+            });
+            subcommand.outputHelp();
+            return output.join("");
+        }
+    }
+    program.outputHelp();
+    return output.join("");
+}
+/** Parses CLI arguments into a normalized command payload. */
+async function parseCliArgs(argv, prompts = createPromptClient()) {
+    const [rawCommand] = argv;
+    const command = rawCommand;
+    if (!command ||
+        command === "help" ||
+        command === "-h" ||
+        command === "--help") {
+        return { kind: "help" };
+    }
+    if (!COMMANDS.includes(command)) {
+        const suggestion = findClosestCommand(command, COMMANDS);
+        const hint = suggestion ? `, did you mean "${suggestion}"?` : "";
+        throw new Error(`Unknown command: "${command}"${hint}`);
+    }
+    const normalizedArgv = rawCommand && rawCommand !== command ? [command, ...argv.slice(1)] : argv;
+    const restArgs = normalizedArgv.slice(1);
+    if (restArgs.includes("--help") || restArgs.includes("-h")) {
+        return { kind: "help", command: command };
+    }
+    const context = {};
+    const program = createProgram(prompts, context);
+    try {
+        await program.parseAsync(normalizedArgv, { from: "user" });
+    }
+    catch (error) {
+        throw normalizeParseError(error, command);
+    }
+    return context.result ?? { kind: "help" };
+}
+function collectToolOption(value, previous) {
+    if (!VALID_TOOL_NAMES.has(value)) {
+        throw new Error(`Unknown tool: ${value}\nValid tools: ${Array.from(VALID_TOOL_NAMES).sort().join(", ")}`);
+    }
+    if (previous.includes(value)) {
+        return previous;
+    }
+    return [...previous, value];
+}
+function collectBundleItemOption(value, previous) {
+    const normalized = (0, bundle_items_1.normalizeBundleItemSelector)(value);
+    if (previous.includes(normalized)) {
+        return previous;
+    }
+    return [...previous, normalized];
+}
+function normalizeRefSelector(value) {
+    const normalizedValue = value.trim();
+    if (normalizedValue.length === 0) {
+        throw new Error("Ref selector must be a non-empty string");
+    }
+    return normalizedValue;
+}
+function resolveRequestedRefSelector(options) {
+    if (options.ref !== undefined) {
+        return normalizeRefSelector(options.ref);
+    }
+    return undefined;
+}
+function createProgram(prompts, context = {}) {
+    const program = new commander_1.Command();
+    program
+        .name("skul")
+        .description("Manage project-scoped AI configuration bundles\n\nEnv vars:\n  SKUL_NO_TUI=1   Run in headless/non-interactive mode (auto-resolves prompts)")
+        .addHelpText("after", PROGRAM_HELP_DETAILS)
+        .helpCommand(false)
+        .configureOutput({
+        writeOut: () => undefined,
+        writeErr: () => undefined,
+    })
+        .exitOverride();
+    program
+        .command("add")
+        .description("Add a bundle to the active set and materialize its files or root instructions")
+        .argument("[source]", "Bundle source (e.g. github.com/user/repo)")
+        .argument("[bundle]", "Bundle name")
+        .option("-a, --agent <name>", "Select a specific tool to materialize (repeatable)", collectToolOption, [])
+        .option("--ref <selector>", "Track a specific branch, tag, or commit instead of remote HEAD")
+        .option("--include <item>", "Install only a bundle item such as skills/name, agents/name, commands/name, or root-instruction (repeatable)", collectBundleItemOption, [])
+        .option("--select-items", "Choose bundle items interactively before installing")
+        .option("-n, --dry-run", "Preview what would be written without making any changes")
+        .option("-s, --ssh", "Clone the bundle source using SSH instead of HTTPS")
+        .option("-g, --global", "Install to global tool config under ~/")
+        .option("--disable-model-invocation", "Force disable-model-invocation on all skills even when the skill does not set it")
+        .addHelpText("after", ADD_HELP_DETAILS)
+        .action(async (source, bundle, opts) => {
+        const agents = opts.agent;
+        const includeItems = opts.include;
+        const selectItems = opts.selectItems ?? false;
+        const dryRun = opts.dryRun ?? false;
+        const global = opts.global ?? false;
+        const disableModelInvocation = opts.disableModelInvocation ?? false;
+        const ref = resolveRequestedRefSelector(opts);
+        if (!source && !bundle) {
+            throw new Error("Command add requires a source or bundle name\nHint: run 'skul add <source>' to select a bundle from that source, or 'skul add <bundle>' for a cached unique bundle");
+        }
+        if (selectItems && disableModelInvocation) {
+            throw new Error("--select-items and --disable-model-invocation cannot be used together\nHint: skills not selected in the prompt would remain on disk without the flag, leaving the installation inconsistent");
+        }
+        if (source && !bundle) {
+            // If the single argument looks like a git source (host/owner/repo), treat the
+            // repo slug as the bundle name so `skul add github.com/user/react-bundle` works.
+            try {
+                const detectedProtocol = opts.ssh
+                    ? "ssh"
+                    : (0, bundle_discovery_1.detectSourceProtocol)(source);
+                const normalizedSource = (0, bundle_discovery_1.normalizeBundleSource)(source);
+                const repoSlug = normalizedSource.split("/").at(-1);
+                context.result = {
+                    kind: "command",
+                    command: "add",
+                    options: {
+                        source: normalizedSource,
+                        bundle: repoSlug,
+                        protocol: detectedProtocol,
+                        agents,
+                        ...(includeItems.length > 0 ? { includeItems } : {}),
+                        ...(selectItems ? { selectItems } : {}),
+                        dryRun,
+                        ...(ref !== undefined ? { ref } : {}),
+                        inferredBundleFromSource: true,
+                        global,
+                        ...(disableModelInvocation ? { disableModelInvocation } : {}),
+                    },
+                };
+            }
+            catch {
+                // Not a valid source — treat as a plain bundle name.
+                context.result = {
+                    kind: "command",
+                    command: "add",
+                    options: {
+                        bundle: source,
+                        protocol: "https",
+                        agents,
+                        ...(includeItems.length > 0 ? { includeItems } : {}),
+                        ...(selectItems ? { selectItems } : {}),
+                        dryRun,
+                        ...(ref !== undefined ? { ref } : {}),
+                        global,
+                        ...(disableModelInvocation ? { disableModelInvocation } : {}),
+                    },
+                };
+            }
+            return;
+        }
+        const explicitSource = source;
+        const detectedProtocol = opts.ssh
+            ? "ssh"
+            : (0, bundle_discovery_1.detectSourceProtocol)(explicitSource);
+        const normalizedSource = (0, bundle_discovery_1.normalizeBundleSource)(explicitSource);
+        context.result = {
+            kind: "command",
+            command: "add",
+            options: {
+                source: normalizedSource,
+                bundle: bundle,
+                protocol: detectedProtocol,
+                agents,
+                ...(includeItems.length > 0 ? { includeItems } : {}),
+                ...(selectItems ? { selectItems } : {}),
+                dryRun,
+                ...(ref !== undefined ? { ref } : {}),
+                global,
+                ...(disableModelInvocation ? { disableModelInvocation } : {}),
+            },
+        };
+    });
+    program
+        .command("list")
+        .description("List available bundles in the local library")
+        .option("-j, --json", "Output as JSON (for scripting and agent use)")
+        .option("-s, --source <source>", "Filter results to a single cached source")
+        .action((opts) => {
+        context.result = {
+            kind: "command",
+            command: "list",
+            options: {
+                json: opts.json ?? false,
+                ...(opts.source !== undefined
+                    ? { source: (0, bundle_discovery_1.normalizeBundleSource)(opts.source) }
+                    : {}),
+            },
+        };
+    });
+    program
+        .command("status")
+        .description("Show desired state, current worktree materialization, and tracked root-instruction shadow health")
+        .option("-j, --json", "Output as JSON (for scripting and agent use)")
+        .option("-g, --global", "Show global tool config state")
+        .action((opts) => {
+        context.result = {
+            kind: "command",
+            command: "status",
+            options: { json: opts.json ?? false, global: opts.global ?? false },
+        };
+    });
+    program
+        .command("check")
+        .description("Check remote-backed bundles for upstream updates")
+        .argument("[bundle]", "Bundle name to check")
+        .option("-j, --json", "Output as JSON (for scripting and agent use)")
+        .action((bundle, opts) => {
+        context.result = {
+            kind: "command",
+            command: "check",
+            options: {
+                ...(bundle !== undefined ? { bundle } : {}),
+                json: opts.json ?? false,
+            },
+        };
+    });
+    program
+        .command("update")
+        .description("Update remote-backed bundles to the latest upstream revision")
+        .argument("[bundle]", "Bundle name to update")
+        .option("-n, --dry-run", "Preview what would be updated without making any changes")
+        .action((bundle, opts) => {
+        context.result = {
+            kind: "command",
+            command: "update",
+            options: {
+                ...(bundle !== undefined ? { bundle } : {}),
+                dryRun: opts.dryRun ?? false,
+            },
+        };
+    });
+    const shadowCommand = program
+        .command("shadow")
+        .description("Suspend or refresh tracked root instruction shadows")
+        .option("--suspend", "Restore tracked root instructions from HEAD and clear skip-worktree")
+        .option("--refresh", "Rebuild tracked root-instruction shadows from HEAD and re-enable skip-worktree")
+        .addHelpText("after", SHADOW_HELP_DETAILS)
+        .action((opts) => {
+        if (opts.suspend === opts.refresh) {
+            throw new Error("Command shadow requires exactly one of --suspend or --refresh");
+        }
+        context.result = {
+            kind: "command",
+            command: "shadow",
+            options: { action: opts.suspend ? "suspend" : "refresh" },
+        };
+    });
+    const syncCommand = program
+        .command("sync")
+        .description("Safely pull git updates around tracked root instruction shadows")
+        .addHelpText("after", SYNC_HELP_DETAILS)
+        .action(() => {
+        context.result = { kind: "command", command: "sync", options: {} };
+    });
+    program
+        .command("apply")
+        .description("Materialize all desired-state bundles into the current worktree")
+        .option("-n, --dry-run", "Preview what would be written without making any changes")
+        .option("-g, --global", "Apply global desired-state bundles")
+        .action((opts) => {
+        context.result = {
+            kind: "command",
+            command: "apply",
+            options: { dryRun: opts.dryRun ?? false, global: opts.global ?? false },
+        };
+    });
+    program
+        .command("reset")
+        .description("Remove all Skul-managed files and restore tracked root instructions in the current worktree")
+        .option("-n, --dry-run", "Preview what would be deleted without removing any files")
+        .option("-g, --global", "Reset globally managed tool config")
+        .action((opts) => {
+        context.result = {
+            kind: "command",
+            command: "reset",
+            options: { dryRun: opts.dryRun ?? false, global: opts.global ?? false },
+        };
+    });
+    program
+        .command("remove")
+        .description("Remove a bundle from the active set and recompose or restore any root instructions it owns")
+        .argument("[source]", "Bundle source (e.g. github.com/user/repo)")
+        .argument("[bundle]", "Bundle name to remove")
+        .option("--include <item>", "Remove only a bundle item such as skills/name, agents/name, commands/name, or root-instruction (repeatable)", collectBundleItemOption, [])
+        .option("--select-items", "Choose bundle items interactively before removing")
+        .option("-n, --dry-run", "Preview what would be deleted without removing any files")
+        .option("-g, --global", "Remove from globally managed tool config")
+        .action((source, bundle, opts) => {
+        const includeItems = opts.include;
+        const selectItems = opts.selectItems ?? false;
+        const dryRun = opts.dryRun ?? false;
+        const global = opts.global ?? false;
+        if (!source && !bundle) {
+            if (selectItems || includeItems.length > 0) {
+                context.result = {
+                    kind: "command",
+                    command: "remove",
+                    options: {
+                        ...(includeItems.length > 0 ? { includeItems } : {}),
+                        ...(selectItems ? { selectItems } : {}),
+                        dryRun,
+                        global,
+                    },
+                };
+                return;
+            }
+            throw new Error("Command remove requires a source or bundle name\nHint: run 'skul remove <source>' to select a bundle from that source, or 'skul remove <bundle>' for an active bundle");
+        }
+        if (source && !bundle) {
+            try {
+                const normalizedSource = (0, bundle_discovery_1.normalizeBundleSource)(source);
+                const repoSlug = normalizedSource.split("/").at(-1);
+                context.result = {
+                    kind: "command",
+                    command: "remove",
+                    options: {
+                        source: normalizedSource,
+                        bundle: repoSlug,
+                        ...(includeItems.length > 0 ? { includeItems } : {}),
+                        ...(selectItems ? { selectItems } : {}),
+                        dryRun,
+                        inferredBundleFromSource: true,
+                        global,
+                    },
+                };
+            }
+            catch {
+                context.result = {
+                    kind: "command",
+                    command: "remove",
+                    options: {
+                        bundle: source,
+                        ...(includeItems.length > 0 ? { includeItems } : {}),
+                        ...(selectItems ? { selectItems } : {}),
+                        dryRun,
+                        global,
+                    },
+                };
+            }
+            return;
+        }
+        context.result = {
+            kind: "command",
+            command: "remove",
+            options: {
+                source: (0, bundle_discovery_1.normalizeBundleSource)(source),
+                bundle: bundle,
+                ...(includeItems.length > 0 ? { includeItems } : {}),
+                ...(selectItems ? { selectItems } : {}),
+                dryRun,
+                global,
+            },
+        };
+    });
+    return program;
+}
+function normalizeParseError(error, command) {
+    if (!(error instanceof commander_1.CommanderError)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    if (error.code === "commander.excessArguments") {
+        if (command === "add") {
+            return new Error("Command add accepts at most 2 positional arguments");
+        }
+        if (command === "remove") {
+            return new Error("Command remove accepts at most 2 positional arguments");
+        }
+        if (command === "check" || command === "update") {
+            return new Error(`Command ${command} accepts at most 1 positional argument`);
+        }
+        return new Error(`Command ${command} does not accept positional arguments`);
+    }
+    return new Error(error.message.replace(/^error: /, ""));
+}
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findClosestCommand(input, commands) {
+    const MAX_DISTANCE = 3;
+    let best;
+    let bestDistance = Infinity;
+    for (const cmd of commands) {
+        const d = levenshtein(input, cmd);
+        if (d < bestDistance) {
+            bestDistance = d;
+            best = cmd;
+        }
+    }
+    return bestDistance <= MAX_DISTANCE ? best : undefined;
+}
+function formatBundleSelectionLabel(selection, availableBundles) {
+    const hasDuplicateBundleName = availableBundles.some((bundle) => bundle.bundle === selection.bundle && bundle.source !== selection.source);
+    if (hasDuplicateBundleName && selection.source) {
+        return `${selection.bundle} (${selection.source})`;
+    }
+    return selection.bundle;
+}
+//# sourceMappingURL=cli.js.map