@agent-native/skills 0.0.0-beta-20260819155526

package/dist/index.js

@@ -0,0 +1,1335 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { docsUrl } from "@agent-native/core/shared";
+import { resolveAppForSkill } from "./built-in-apps.js";
+import { registerMcpServer } from "./connect.js";
+import { createCliTelemetry } from "./telemetry.js";
+const HELP = `@agent-native/skills
+
+Usage:
+  npx @agent-native/skills@latest add [options]
+  npx @agent-native/skills@latest list
+  npx @agent-native/skills@latest status [skill|scaffold] [options]
+  npx @agent-native/skills@latest update [skill|scaffold] [options]
+
+Options:
+  --skill <name>              Install only this skill (repeatable)
+  --client, -a <client>       codex, claude-code, cowork, pi, cursor, opencode, github-copilot, or all
+                              (default: all; repeatable or comma-separated)
+  --scope <user|project>      Install globally or into the current project (default: user)
+  -g, --global                Alias for --scope user
+  --project                   Alias for --scope project
+  --update-instructions       Add managed AGENTS.md / CLAUDE.md instructions when useful
+  --no-update-instructions    Skip managed instruction file updates
+  --instructions-file <path>  File to receive managed instructions (repeatable)
+  --with-github-action        Add .github/workflows/pr-visual-recap.yml when visual-recap is installed
+  --mode <mode>               App-backed skill mode: hosted, local-files, or self-hosted
+  --mcp-url <url>             Self-hosted app/MCP URL for app-backed skills
+  --force                     Overwrite a different existing PR Visual Recap workflow
+  --no-mcp                    Install skill files only; skip registering the app's MCP server
+  --no-connect                Register MCP where possible but skip inline browser/device authentication
+  -y, --yes                   Use defaults in non-interactive mode
+  --dry-run                   Print intended writes without changing files
+  --json                      Print the result as JSON
+
+App-backed skills (visual-plan, visual-recap, visualize-repo, content) register
+their hosted MCP server in your agent config by default so the agent can
+actually use them. Use --no-mcp to skip that and copy the files only.
+For visual-plan/visual-recap/visualize-repo/content, choose --mode local-files
+for local-file workflows, or --mode self-hosted --mcp-url <url> for your own app.
+
+Examples:
+  npx @agent-native/skills@latest add
+  npx @agent-native/skills@latest add --skill quick-recap
+  npx @agent-native/skills@latest add --skill visual-recap --with-github-action
+  npx @agent-native/skills@latest update scaffold --project
+`;
+const CLIENTS = [
+    "codex",
+    "claude-code",
+    "cowork",
+    "pi",
+    "cursor",
+    "opencode",
+    "github-copilot",
+];
+const DEFAULT_SKILLS_SOURCE = "BuilderIO/skills";
+const MANAGED_INSTRUCTIONS_START = "<!-- BEGIN @agent-native/skills -->";
+const MANAGED_INSTRUCTIONS_END = "<!-- END @agent-native/skills -->";
+export function parseSkillsCliArgs(argv) {
+    const first = argv[0];
+    if (!first || first === "help" || first === "--help" || first === "-h") {
+        return defaultArgs("help");
+    }
+    const command = first === "list" ||
+        first === "status" ||
+        first === "update" ||
+        first === "add"
+        ? first
+        : "add";
+    const args = first === "add" ||
+        first === "list" ||
+        first === "status" ||
+        first === "update"
+        ? argv.slice(1)
+        : argv;
+    const out = defaultArgs(command);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const eat = (flag) => {
+            if (arg === flag) {
+                const next = args[++i];
+                if (!next || next.startsWith("-")) {
+                    throw new Error(`Missing value for ${flag}.`);
+                }
+                return next;
+            }
+            if (arg.startsWith(`${flag}=`)) {
+                const value = arg.slice(flag.length + 1);
+                if (!value)
+                    throw new Error(`Missing value for ${flag}.`);
+                return value;
+            }
+            return undefined;
+        };
+        let value;
+        if ((value = eat("--skill")) !== undefined)
+            out.skillNames.push(value);
+        else if ((value = eat("-s")) !== undefined)
+            out.skillNames.push(value);
+        else if ((value = eat("--client")) !== undefined)
+            out.clients.push(...normalizeClients(value));
+        else if ((value = eat("--agent")) !== undefined)
+            out.clients.push(...normalizeClients(value));
+        else if ((value = eat("-a")) !== undefined)
+            out.clients.push(...normalizeClients(value));
+        else if ((value = eat("--scope")) !== undefined) {
+            out.scope = parseScope(value);
+            out.scopeExplicit = true;
+        }
+        else if ((value = eat("--instructions-file")) !== undefined)
+            out.instructionFiles.push(value);
+        else if ((value = eat("--cwd")) !== undefined)
+            out.baseDir = value;
+        else if (arg === "-g" || arg === "--global") {
+            out.scope = "user";
+            out.scopeExplicit = true;
+        }
+        else if (arg === "--project") {
+            out.scope = "project";
+            out.scopeExplicit = true;
+        }
+        else if (arg === "--copy") {
+            // Compatibility with the open `skills` CLI. This installer always copies.
+            out.copySource = true;
+        }
+        else if (arg === "-y" || arg === "--yes")
+            out.yes = true;
+        else if (arg === "--dry-run")
+            out.dryRun = true;
+        else if (arg === "--json")
+            out.printJson = true;
+        else if (arg === "--quiet")
+            out.quiet = true;
+        else if (arg === "--update-instructions")
+            out.updateInstructions = true;
+        else if (arg === "--no-update-instructions")
+            out.updateInstructions = false;
+        else if (arg === "--with-github-action" || arg === "--with-github-actions")
+            out.withGithubAction = true;
+        else if ((value = eat("--mode")) !== undefined) {
+            out.planMode = parsePlanMode(value);
+        }
+        else if ((value = eat("--mcp-url")) !== undefined) {
+            out.mcpUrl = value;
+        }
+        else if (arg === "--force")
+            out.force = true;
+        else if (arg === "--no-mcp")
+            out.mcp = false;
+        else if (arg === "--mcp")
+            out.mcp = true;
+        else if (arg === "--no-connect" || arg === "--skip-connect")
+            out.connect = false;
+        else if (arg === "--connect")
+            out.connect = true;
+        else if (arg.startsWith("-"))
+            throw new Error(`Unknown option: ${arg}`);
+        else if (!out.source)
+            out.source = arg;
+        else
+            throw new Error(`Unexpected argument: ${arg}`);
+    }
+    if (out.command === "add" &&
+        out.source &&
+        out.source !== DEFAULT_SKILLS_SOURCE &&
+        !out.copySource) {
+        throw new Error(`Unexpected argument: ${out.source}. @agent-native/skills installs the BuilderIO skills collection; use --skill <name> to choose a skill.`);
+    }
+    if (out.command === "add" &&
+        out.source === DEFAULT_SKILLS_SOURCE &&
+        !out.copySource) {
+        out.source = undefined;
+    }
+    out.skillNames = unique(out.skillNames.map(normalizeSkillName));
+    out.clients = unique(out.clients);
+    out.instructionFiles = unique(out.instructionFiles);
+    if (out.planMode && out.mcpUrl && out.planMode !== "self-hosted") {
+        throw new Error("--mcp-url can only be used with --mode self-hosted.");
+    }
+    if (out.mcpUrl && !out.planMode)
+        out.planMode = "self-hosted";
+    return out;
+}
+/**
+ * Translate this package's parsed args into the argv shape `@agent-native/core`
+ * skills expects. Core takes a single positional target + compatible flags; we
+ * forward one explicit skill as that target and let core's interactive picker
+ * handle 0-or-many selections.
+ */
+function toCoreSkillsArgv(parsed) {
+    const out = [parsed.command];
+    if (parsed.command === "add") {
+        if (parsed.copySource && parsed.source && parsed.skillNames.length > 0) {
+            out.push(parsed.source);
+            for (const skill of parsed.skillNames)
+                out.push("--skill", skill);
+        }
+        else if (parsed.skillNames.length === 1) {
+            out.push(parsed.skillNames[0]);
+        }
+        else if (parsed.skillNames.length > 1) {
+            const appIds = unique(parsed.skillNames
+                .map((name) => resolveAppForSkill(name)?.appId)
+                .filter((appId) => Boolean(appId)));
+            if (appIds.length === 1 &&
+                parsed.skillNames.every((name) => resolveAppForSkill(name))) {
+                out.push(appIds[0]);
+            }
+            else {
+                for (const skill of parsed.skillNames)
+                    out.push("--skill", skill);
+            }
+        }
+    }
+    else if (parsed.command === "status" || parsed.command === "update") {
+        if (parsed.source)
+            out.push(parsed.source);
+        else if (parsed.skillNames.length === 1)
+            out.push(parsed.skillNames[0]);
+    }
+    if ((parsed.command === "add" ||
+        parsed.command === "status" ||
+        parsed.command === "update") &&
+        parsed.clients.length) {
+        out.push("--client", parsed.clients.join(","));
+    }
+    if ((parsed.command === "add" ||
+        parsed.command === "status" ||
+        parsed.command === "update") &&
+        parsed.scopeExplicit) {
+        out.push("--scope", parsed.scope);
+    }
+    if (parsed.command === "add" && parsed.yes)
+        out.push("--yes");
+    if (parsed.dryRun)
+        out.push("--dry-run");
+    if (parsed.printJson)
+        out.push("--json");
+    if (parsed.command === "add" && parsed.withGithubAction)
+        out.push("--with-github-action");
+    if (parsed.command === "add" && parsed.planMode)
+        out.push("--mode", parsed.planMode);
+    if (parsed.command === "add" && parsed.mcpUrl)
+        out.push("--mcp-url", parsed.mcpUrl);
+    if (parsed.command === "add" && parsed.force)
+        out.push("--force");
+    if (parsed.command === "add" && parsed.mcp === false)
+        out.push("--no-mcp");
+    if (parsed.command === "add" && parsed.connect === false)
+        out.push("--no-connect");
+    if (parsed.command === "add" && parsed.updateInstructions === true)
+        out.push("--update-instructions");
+    if (parsed.command === "add" && parsed.updateInstructions === false)
+        out.push("--no-update-instructions");
+    return out;
+}
+function shouldLoadPublicCatalog(parsed) {
+    if (parsed.command === "list")
+        return true;
+    if (parsed.command !== "add")
+        return false;
+    if (parsed.copySource && parsed.source)
+        return true;
+    if (parsed.skillNames.length === 0)
+        return true;
+    return parsed.skillNames.some((name) => !isCoreDelegatedSkill(name));
+}
+const REWIND_SKILL_TARGETS = new Set([
+    "rewind",
+    "screen-memory",
+    "clips-rewind",
+    "agent-native-rewind",
+]);
+function isRewindSkillTarget(skillName) {
+    return REWIND_SKILL_TARGETS.has(skillName.trim().toLowerCase());
+}
+function isCoreDelegatedSkill(skillName) {
+    // Rewind uses Core's local Screen Memory installer, not the standalone
+    // package's hosted MCP descriptor path.
+    return (isRewindSkillTarget(skillName) || Boolean(resolveAppForSkill(skillName)));
+}
+const HIDDEN_STANDALONE_BUILT_INS = [
+    "assets",
+    "content",
+    "design-exploration",
+    "visual-edit",
+    "context-xray",
+];
+function shouldShowDelegatedStartupProgress(parsed, options) {
+    return (parsed.command !== "help" &&
+        !parsed.printJson &&
+        !parsed.quiet &&
+        cliInteractive(parsed, options));
+}
+export async function runSkillsCli(argv, options = {}) {
+    const parsed = parseSkillsCliArgs(argv);
+    // `@agent-native/skills` normally uses the exact same core flow as
+    // `agent-native skills`; it only passes a broader public skill catalog.
+    // AGENT_NATIVE_SKILLS_DIRECT=1 is set by core when it shells out to this
+    // package as a headless file-copy worker for public/plain skill repos. That
+    // direct mode is intentionally non-user-facing prompt plumbing.
+    if (process.env.AGENT_NATIVE_SKILLS_DIRECT !== "1") {
+        if (parsed.command === "help") {
+            process.stdout.write(`${HELP}\n`);
+            return;
+        }
+        if (shouldShowDelegatedStartupProgress(parsed, options)) {
+            process.stderr.write("Preparing Agent Native skills...\n");
+        }
+        const loadedSource = shouldLoadPublicCatalog(parsed)
+            ? await materializeSource(parsed.source ?? DEFAULT_SKILLS_SOURCE)
+            : null;
+        try {
+            const { runSkills } = (await import("@agent-native/core/cli/skills"));
+            const publicSkillEntries = loadedSource
+                ? discoverSkills(loadedSource.root).map((entry) => ({
+                    name: entry.name,
+                    description: entry.description,
+                }))
+                : [];
+            await runSkills(toCoreSkillsArgv(parsed), {
+                log: options.log,
+                isInteractive: options.isInteractive,
+                baseDir: parsed.baseDir ?? options.baseDir,
+                catalogMode: "all",
+                hiddenBuiltInSkillTargets: HIDDEN_STANDALONE_BUILT_INS,
+                publicSkillSource: loadedSource?.root ?? parsed.source ?? DEFAULT_SKILLS_SOURCE,
+                publicSkillEntries,
+                promptSkills: options.promptSkills
+                    ? async (context) => options.promptSkills?.({
+                        initialSkills: context.initialTargets,
+                        options: context.options,
+                    }) ?? null
+                    : undefined,
+                promptClients: options.promptClients,
+                promptScope: options.promptScope,
+                promptGithubAction: options.promptGithubAction
+                    ? async (context) => options.promptGithubAction?.({
+                        workflowPath: context.workflowPath,
+                        setupCommand: context.setupCommand,
+                        docsUrl: context.docsUrl,
+                    }) ?? null
+                    : undefined,
+                promptPlanMode: options.promptPlanMode,
+                promptPlanMcpUrl: options.promptPlanMcpUrl,
+                promptUpdateInstructions: options.promptUpdateInstructions,
+            });
+            return;
+        }
+        finally {
+            loadedSource?.cleanup?.();
+        }
+    }
+    const startedAt = Date.now();
+    const telemetry = createCliTelemetry({
+        cli: "skills-installer",
+        cliVersion: readCliVersion(),
+        command: parsed.command,
+        interactive: cliInteractive(parsed, options),
+    });
+    try {
+        if (parsed.command === "help") {
+            process.stdout.write(`${HELP}\n`);
+            return;
+        }
+        telemetry.track("skills_cli started");
+        const skillSource = parsed.source ?? DEFAULT_SKILLS_SOURCE;
+        if (parsed.command === "list") {
+            const source = await materializeSource(skillSource);
+            try {
+                const skills = discoverSkills(source.root);
+                telemetry.track("skills_cli skills listed", {
+                    availableCount: skills.length,
+                    available: skills.map((skill) => skill.name).join(","),
+                });
+                if (parsed.printJson) {
+                    process.stdout.write(`${JSON.stringify(skills, null, 2)}\n`);
+                    return;
+                }
+                for (const skill of skills) {
+                    process.stdout.write(`${skill.name}${skill.description ? ` - ${skill.description}` : ""}\n`);
+                }
+                return;
+            }
+            finally {
+                source.cleanup?.();
+            }
+        }
+        const stdoutLog = parsed.printJson || options.log
+            ? options.log
+            : (message) => process.stdout.write(`${message}\n`);
+        const result = await installSkills({
+            source: skillSource,
+            skillNames: parsed.skillNames,
+            clients: parsed.clients,
+            // Leave scope undefined unless the user passed --scope/-g/--project so the
+            // installer can prompt for it interactively.
+            scope: parsed.scopeExplicit ? parsed.scope : undefined,
+            baseDir: parsed.baseDir ?? options.baseDir,
+            yes: parsed.yes,
+            dryRun: parsed.dryRun,
+            updateInstructions: parsed.updateInstructions,
+            instructionFiles: parsed.instructionFiles,
+            withGithubAction: parsed.withGithubAction,
+            force: parsed.force,
+            connect: parsed.connect,
+            quiet: parsed.printJson || parsed.quiet,
+            log: parsed.printJson || parsed.quiet ? undefined : stdoutLog,
+            isInteractive: options.isInteractive,
+            promptSkills: options.promptSkills,
+            promptClients: options.promptClients,
+            promptScope: options.promptScope,
+            promptUpdateInstructions: options.promptUpdateInstructions,
+            promptGithubAction: options.promptGithubAction,
+            promptPlanMode: options.promptPlanMode,
+            promptPlanMcpUrl: options.promptPlanMcpUrl,
+            telemetry,
+            mcp: parsed.mcp,
+            planMode: parsed.planMode,
+            mcpUrl: parsed.mcpUrl,
+        });
+        telemetry.track("skills_cli completed", {
+            skills: result.skills.join(","),
+            clients: result.clients.join(","),
+            scope: result.scope,
+            dryRun: result.dryRun,
+            durationMs: Date.now() - startedAt,
+        });
+        if (parsed.printJson) {
+            process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+            return;
+        }
+        if (parsed.quiet)
+            return;
+        await printInstallResult(result, {
+            baseDir: parsed.baseDir ?? options.baseDir ?? process.cwd(),
+            dryRun: parsed.dryRun,
+        });
+    }
+    catch (error) {
+        telemetry.track("skills_cli failed", {
+            command: parsed.command,
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: Date.now() - startedAt,
+        });
+        telemetry.captureException(error, {
+            handled: false,
+            tags: { source: "skills-command", command: parsed.command },
+            extra: { durationMs: Date.now() - startedAt },
+        });
+        throw error;
+    }
+    finally {
+        await telemetry.flush();
+    }
+}
+function readCliVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        // dist/index.js → ../package.json
+        const pkg = JSON.parse(fs.readFileSync(path.resolve(here, "../package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function cliInteractive(parsed, options) {
+    if (parsed.yes)
+        return false;
+    if (options.isInteractive)
+        return options.isInteractive();
+    if (process.env.CI === "true")
+        return false;
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export async function installSkills(options) {
+    const baseDir = path.resolve(options.baseDir ?? process.cwd());
+    const log = options.log ?? (() => { });
+    const sourceInput = options.source ?? DEFAULT_SKILLS_SOURCE;
+    const source = await materializeSource(sourceInput);
+    try {
+        const entries = discoverSkills(source.root);
+        if (entries.length === 0) {
+            throw new Error(`No skills found in ${sourceInput}. Expected skills/*/SKILL.md.`);
+        }
+        const preselected = (options.skillNames ?? []).length > 0;
+        const selected = await resolveSelectedSkills(entries, options);
+        options.telemetry?.track("skills_cli skills selected", {
+            selected: selected.map((skill) => skill.name).join(","),
+            selectedCount: selected.length,
+            selectedAll: selected.length === entries.length,
+            preselected,
+        });
+        const skillNames = selected.map((skill) => skill.name);
+        const modeAwareApp = selectedModeAwareApp(skillNames);
+        const planMode = await resolvePlanModeForSkills(skillNames, options);
+        const planMcpOverride = await resolvePlanMcpOverrideForMode(planMode, options, modeAwareApp?.appId);
+        const clients = await resolveSelectedClients(options);
+        options.telemetry?.track("skills_cli clients selected", {
+            clients: clients.join(","),
+            clientCount: clients.length,
+        });
+        const scope = await resolveSelectedScope(options);
+        options.telemetry?.track("skills_cli scope selected", { scope });
+        const instructionBlocks = managedInstructionBlocksForSkills(skillNames);
+        const shouldUpdateInstructions = await shouldUpdateManagedInstructions(instructionBlocks, options);
+        const shouldWriteGithubAction = await shouldWritePrVisualRecapWorkflow(selected.some((skill) => skill.name === "visual-recap"), options, baseDir);
+        const mcpApps = options.mcp === false || planMode === "local-files"
+            ? []
+            : mcpAppsForSkills(skillNames, planMcpOverride);
+        const skillFileClients = clients.filter(supportsSkillFiles);
+        if (skillFileClients.length === 0 && mcpApps.length === 0) {
+            throw new Error("Claude Cowork is MCP-only for Agent Native skills. Choose Codex, Claude Code, Pi, Cursor, OpenCode, or GitHub Copilot for local skill files, or install an app-backed skill with MCP enabled.");
+        }
+        const progress = await createInstallProgress(options, 1 +
+            (shouldUpdateInstructions ? 1 : 0) +
+            (shouldWriteGithubAction ? 1 : 0) +
+            mcpApps.length);
+        const written = [];
+        let instructionFiles = [];
+        let githubActionPath;
+        const mcpServers = [];
+        try {
+            progress?.start("Installing skill files...");
+            for (const root of unique(skillFileClients.map((client) => installRootForClient(client, scope, baseDir)))) {
+                for (const skill of selected) {
+                    const destination = path.join(root, skill.name);
+                    written.push(destination);
+                    if (!options.dryRun) {
+                        fs.rmSync(destination, { recursive: true, force: true });
+                        fs.mkdirSync(path.dirname(destination), { recursive: true });
+                        fs.cpSync(skill.dir, destination, { recursive: true });
+                    }
+                }
+            }
+            progress?.advance("Skill files installed");
+            options.telemetry?.track("skills_cli install completed", {
+                skills: skillNames.join(","),
+                clients: clients.join(","),
+                scope,
+                writtenCount: written.length,
+                dryRun: Boolean(options.dryRun),
+            });
+            if (shouldUpdateInstructions) {
+                progress?.message("Updating managed instructions...");
+                instructionFiles = writeManagedInstructions(instructionBlocks, baseDir, skillFileClients, scope, options);
+                progress?.advance("Managed instructions updated");
+                if (instructionFiles.length) {
+                    options.telemetry?.track("skills_cli instructions updated", {
+                        fileCount: instructionFiles.length,
+                    });
+                }
+            }
+            if (shouldWriteGithubAction) {
+                progress?.message("Writing PR Visual Recap workflow...");
+                githubActionPath = writePrVisualRecapWorkflow(baseDir, options);
+                progress?.advance("PR Visual Recap workflow ready");
+                if (githubActionPath) {
+                    options.telemetry?.track("skills_cli github action added");
+                }
+            }
+            // Register the hosted MCP server for app-backed skills (visual-plan /
+            // visual-recap → Agent-Native Plan) so the agent can actually call them,
+            // not just read the SKILL.md. On by default; `--no-mcp` installs the
+            // skill files only. One registration per app, so visual-plan +
+            // visual-recap share a single "plan" server.
+            if (mcpApps.length > 0) {
+                const mcpClients = clients
+                    .map(skillClientToMcpClient)
+                    .filter((client) => Boolean(client));
+                if (mcpClients.length === 0) {
+                    throw new Error("MCP setup supports Claude Code, Codex, Cursor, OpenCode, GitHub Copilot / VS Code, or Claude Cowork. Use --mode local-files or --no-mcp for Pi.");
+                }
+                for (const app of mcpApps) {
+                    progress?.message(`Registering ${app.displayName} MCP server...`);
+                    if (!options.dryRun) {
+                        const registration = await registerMcpServer({
+                            descriptor: {
+                                serverName: app.serverName,
+                                mcpUrl: app.mcpUrl,
+                                aliases: app.aliases,
+                                authMode: app.authMode,
+                                hostedUrl: app.hostedUrl,
+                            },
+                            clients: mcpClients,
+                            scope,
+                            baseDir,
+                            interactive: options.connect !== false && isInteractive(options),
+                            log,
+                            deviceFlowTimeoutMs: options.deviceFlowTimeoutMs,
+                        });
+                        mcpServers.push({
+                            serverName: app.serverName,
+                            mcpUrl: app.mcpUrl,
+                            clients,
+                            registeredClients: unique(registration.written.map((entry) => entry.client)),
+                            files: [
+                                ...new Set(registration.written.map((entry) => entry.file)),
+                            ],
+                            authenticated: registration.authenticated,
+                            guidance: registration.guidance,
+                        });
+                        options.telemetry?.track("skills_cli mcp registered", {
+                            serverName: app.serverName,
+                            clients: clients.join(","),
+                            authenticated: registration.authenticated,
+                        });
+                    }
+                    else {
+                        mcpServers.push({
+                            serverName: app.serverName,
+                            mcpUrl: app.mcpUrl,
+                            clients,
+                            registeredClients: clients,
+                            files: [],
+                            authenticated: false,
+                            guidance: [],
+                        });
+                    }
+                    progress?.advance(`${app.displayName} MCP server ready`);
+                }
+            }
+            progress?.stop("Installation complete");
+        }
+        catch (err) {
+            progress?.error("Installation failed");
+            throw err;
+        }
+        return {
+            source: source.root,
+            skills: skillNames,
+            clients,
+            scope,
+            written,
+            instructionFiles,
+            githubActionPath,
+            mcpServers,
+            planMode,
+            dryRun: Boolean(options.dryRun),
+        };
+    }
+    finally {
+        source.cleanup?.();
+    }
+}
+function defaultArgs(command) {
+    return {
+        command,
+        copySource: false,
+        skillNames: [],
+        clients: [],
+        scope: "user",
+        scopeExplicit: false,
+        yes: false,
+        dryRun: false,
+        printJson: false,
+        instructionFiles: [],
+        withGithubAction: false,
+        force: false,
+        connect: true,
+        mcp: true,
+        quiet: false,
+    };
+}
+function selectedModeAwareApp(skillNames) {
+    return skillNames
+        .map((skillName) => resolveAppForSkill(skillName))
+        .find((app) => app?.appId === "visual-plans" || app?.appId === "content");
+}
+async function resolvePlanModeForSkills(skillNames, options) {
+    const modeAwareApp = selectedModeAwareApp(skillNames);
+    if (options.planMode && !modeAwareApp) {
+        throw new Error("--mode only applies to visual-plan / visual-recap / visualize-repo / content.");
+    }
+    if (options.mcpUrl && !modeAwareApp) {
+        throw new Error("--mcp-url only applies to visual-plan / visual-recap / visualize-repo / content.");
+    }
+    if (!modeAwareApp)
+        return undefined;
+    if (options.mcpUrl && !options.planMode)
+        return "self-hosted";
+    if (options.planMode)
+        return options.planMode;
+    return modeAwareApp.appId === "visual-plans" ? "hosted" : undefined;
+}
+function resolvePlanMcpUrlOverride(input) {
+    let parsed;
+    try {
+        parsed = new URL(input);
+    }
+    catch {
+        throw new Error(`--mcp-url must be a valid URL (got "${input}").`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("--mcp-url must use http:// or https://.");
+    }
+    const publicMcpSuffix = "/mcp";
+    const legacyMcpSuffix = "/_agent-native/mcp";
+    const trimmedPath = parsed.pathname.replace(/\/+$/, "");
+    const mcpSuffix = trimmedPath.endsWith(legacyMcpSuffix)
+        ? legacyMcpSuffix
+        : trimmedPath.endsWith(publicMcpSuffix)
+            ? publicMcpSuffix
+            : undefined;
+    const appPath = mcpSuffix
+        ? trimmedPath.slice(0, -mcpSuffix.length)
+        : trimmedPath;
+    const mcpPath = `${appPath || ""}${publicMcpSuffix}`;
+    return {
+        hostedUrl: `${parsed.origin}${appPath}`,
+        mcpUrl: `${parsed.origin}${mcpPath}`,
+    };
+}
+async function resolvePlanMcpOverrideForMode(planMode, options, appId) {
+    if (planMode === "local-files" && options.mcpUrl) {
+        throw new Error("--mode local-files cannot be combined with --mcp-url.");
+    }
+    if (planMode !== "self-hosted")
+        return undefined;
+    if (!options.mcpUrl) {
+        throw new Error("--mode self-hosted requires --mcp-url <url> in direct mode.");
+    }
+    if (!appId) {
+        throw new Error("--mode self-hosted requires an app-backed skill.");
+    }
+    return { appId, ...resolvePlanMcpUrlOverride(options.mcpUrl) };
+}
+function parsePlanMode(value) {
+    if (value === "hosted" || value === "local-files" || value === "self-hosted")
+        return value;
+    throw new Error('--mode must be "hosted", "local-files", or "self-hosted".');
+}
+function parseScope(value) {
+    if (value === "user" || value === "project")
+        return value;
+    throw new Error("--scope must be user or project.");
+}
+function normalizeClients(value) {
+    return value.split(",").flatMap((raw) => {
+        const client = raw.trim().toLowerCase();
+        if (!client)
+            return [];
+        if (client === "all")
+            return CLIENTS;
+        if (client === "codex")
+            return ["codex"];
+        if (client === "cowork" || client === "claude-cowork") {
+            return ["cowork"];
+        }
+        if (client === "pi")
+            return ["pi"];
+        if (client === "cursor")
+            return ["cursor"];
+        if (client === "opencode" || client === "open-code") {
+            return ["opencode"];
+        }
+        if (client === "github-copilot" ||
+            client === "copilot" ||
+            client === "vscode" ||
+            client === "vs-code") {
+            return ["github-copilot"];
+        }
+        if (client === "claude" ||
+            client === "claude-code" ||
+            client === "claude-code-cli") {
+            return ["claude-code"];
+        }
+        throw new Error(`Unsupported client "${raw}". Use codex, claude-code, cowork, pi, cursor, opencode, github-copilot, or all.`);
+    });
+}
+function skillClientToMcpClient(client) {
+    if (client === "pi")
+        return null;
+    if (client === "claude-code")
+        return "claude-code";
+    return client;
+}
+function supportsSkillFiles(client) {
+    return client !== "cowork";
+}
+function normalizeSkillName(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(normalized)) {
+        throw new Error(`Invalid skill name "${value}".`);
+    }
+    return normalized;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function plural(count, singular, pluralForm = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}
+function shortenPathForOutput(file, baseDir) {
+    const resolved = path.resolve(file);
+    const home = process.env.HOME || os.homedir();
+    if (resolved === home || resolved.startsWith(`${home}${path.sep}`)) {
+        return `~${resolved.slice(home.length)}`;
+    }
+    const base = path.resolve(baseDir);
+    const relative = path.relative(base, resolved);
+    if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+        return `.${path.sep}${relative}`;
+    }
+    return file;
+}
+function summarizePaths(files, baseDir, max = 4) {
+    const shortened = unique(files).map((file) => shortenPathForOutput(file, baseDir));
+    if (shortened.length <= max)
+        return shortened.join(", ");
+    return `${shortened.slice(0, max).join(", ")} +${shortened.length - max} more`;
+}
+async function createInstallProgress(options, max) {
+    if (options.quiet || !isInteractive(options) || max <= 0)
+        return null;
+    const clack = await import("@clack/prompts");
+    const progress = clack.progress({ max, indicator: "timer" });
+    let active = false;
+    return {
+        start(message) {
+            active = true;
+            progress.start(message);
+        },
+        message(message) {
+            if (active)
+                progress.message(message);
+        },
+        advance(message) {
+            if (active)
+                progress.advance(1, message);
+        },
+        stop(message) {
+            if (!active)
+                return;
+            progress.stop(message);
+            active = false;
+        },
+        error(message) {
+            if (!active)
+                return;
+            progress.error(message);
+            active = false;
+        },
+    };
+}
+function mcpAppsForSkills(skillNames, planOverride) {
+    const apps = [];
+    const seen = new Set();
+    for (const skillName of skillNames) {
+        const app = resolveAppForSkill(skillName);
+        if (!app || seen.has(app.appId))
+            continue;
+        seen.add(app.appId);
+        if (app.appId === planOverride?.appId) {
+            apps.push({
+                ...app,
+                hostedUrl: planOverride.hostedUrl,
+                mcpUrl: planOverride.mcpUrl,
+            });
+        }
+        else {
+            apps.push(app);
+        }
+    }
+    return apps;
+}
+function mcpStatus(server, dryRun) {
+    if (dryRun)
+        return `would register for ${server.clients.join(", ")}`;
+    const registered = server.registeredClients;
+    const pending = server.clients.filter((client) => !registered.includes(client));
+    const parts = [];
+    if (registered.length > 0) {
+        parts.push(`${server.authenticated ? "registered and authenticated" : "registered"} for ${registered.join(", ")}`);
+    }
+    if (pending.length > 0) {
+        parts.push(`authentication pending for ${pending.join(", ")}`);
+    }
+    return (parts.join("; ") ||
+        `authentication pending for ${server.clients.join(", ")}`);
+}
+async function printInstallResult(result, options) {
+    const clack = await import("@clack/prompts");
+    const verb = options.dryRun ? "Would install" : "Installed";
+    const summary = [
+        `Skills        ${result.skills.join(", ") || "none"}`,
+        `Agents        ${result.clients.join(", ") || "none"}`,
+        `Scope         ${result.scope}`,
+        result.planMode ? `Install mode  ${result.planMode}` : "",
+        result.written.length
+            ? `Skill folders ${plural(result.written.length, "folder")} (${summarizePaths(result.written, options.baseDir)})`
+            : "",
+    ].filter(Boolean);
+    clack.note(summary.join("\n"), verb);
+    if (result.instructionFiles.length) {
+        clack.note(summarizePaths(result.instructionFiles, options.baseDir), "Managed instructions");
+    }
+    if (result.githubActionPath) {
+        clack.note(shortenPathForOutput(result.githubActionPath, options.baseDir), "PR Visual Recap workflow");
+    }
+    if (result.mcpServers.length) {
+        const mcpLines = result.mcpServers.map((server) => {
+            const status = mcpStatus(server, options.dryRun);
+            const files = server.files.length
+                ? ` (${summarizePaths(server.files, options.baseDir, 2)})`
+                : "";
+            return `${server.serverName}: ${status}${files}`;
+        });
+        clack.note(mcpLines.join("\n"), "MCP");
+        const guidance = result.mcpServers.flatMap((server) => server.guidance);
+        if (guidance.length) {
+            clack.note(guidance.join("\n"), "Next steps");
+        }
+    }
+    if (result.planMode === "local-files" &&
+        result.skills.some((skill) => ["visual-plan", "visual-recap", "visualize-repo"].includes(skill))) {
+        clack.note([
+            "No sharing, all local.",
+            "Run: npx @agent-native/core@latest plan blocks --out plan-blocks.md",
+            "Check: npx @agent-native/core@latest plan local check --dir plans/<slug>",
+            "Serve: npx @agent-native/core@latest plan local serve --dir plans/<slug> --open",
+            "Verify: npx @agent-native/core@latest plan local verify --dir plans/<slug>",
+        ].join("\n"), "Local Plan files");
+    }
+    if (!options.dryRun) {
+        clack.note("Restart or reload selected agent clients if needed.", "Reload");
+    }
+    clack.outro(`${options.dryRun ? "Dry run complete" : "All set"} ✅`);
+}
+async function resolveSelectedSkills(entries, options) {
+    const byName = new Map(entries.map((entry) => [entry.name, entry]));
+    const requested = unique((options.skillNames ?? []).map(normalizeSkillName));
+    if (requested.length > 0) {
+        const missing = requested.filter((name) => !byName.has(name));
+        if (missing.length > 0) {
+            throw new Error(`Unknown skill${missing.length === 1 ? "" : "s"}: ${missing.join(", ")}. Available: ${entries
+                .map((entry) => entry.name)
+                .join(", ")}.`);
+        }
+        return requested.map((name) => byName.get(name));
+    }
+    return entries;
+}
+async function resolveSelectedScope(options) {
+    if (options.scope)
+        return options.scope;
+    return "user";
+}
+async function resolveSelectedClients(options) {
+    const requested = unique(options.clients ?? []);
+    if (requested.length > 0)
+        return requested;
+    return CLIENTS;
+}
+function isInteractive(options) {
+    if (options.isInteractive)
+        return options.isInteractive();
+    if (process.env.CI === "true")
+        return false;
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function installRootForClient(client, scope, baseDir) {
+    const home = process.env.HOME || os.homedir();
+    if (scope === "project") {
+        if (client !== "claude-code") {
+            return path.join(baseDir, ".agents", "skills");
+        }
+        return path.join(baseDir, ".claude", "skills");
+    }
+    if (client === "codex") {
+        return process.env.CODEX_HOME
+            ? path.join(process.env.CODEX_HOME, "skills")
+            : path.join(home, ".codex", "skills");
+    }
+    if (client === "pi") {
+        return path.join(home, ".agents", "skills");
+    }
+    if (client === "cursor" ||
+        client === "opencode" ||
+        client === "github-copilot") {
+        return path.join(home, ".agents", "skills");
+    }
+    return path.join(home, ".claude", "skills");
+}
+function discoverSkills(root) {
+    const skillsRoot = resolveSkillsRoot(root);
+    const directSkill = path.join(skillsRoot, "SKILL.md");
+    if (fs.existsSync(directSkill)) {
+        const entry = skillEntry(skillsRoot);
+        return entry ? [entry] : [];
+    }
+    const entries = fs
+        .readdirSync(skillsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+        .map((entry) => skillEntry(path.join(skillsRoot, entry.name)))
+        .filter((entry) => Boolean(entry));
+    return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveSkillsRoot(root) {
+    for (const manifestPath of [
+        path.join(root, ".codex-plugin", "plugin.json"),
+        path.join(root, ".claude-plugin", "plugin.json"),
+    ]) {
+        if (!fs.existsSync(manifestPath))
+            continue;
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+            if (typeof manifest.skills === "string") {
+                const resolved = path.resolve(root, manifest.skills);
+                if (fs.existsSync(resolved))
+                    return resolved;
+            }
+        }
+        catch { }
+    }
+    const conventional = path.join(root, "skills");
+    if (fs.existsSync(conventional))
+        return conventional;
+    return root;
+}
+function skillEntry(dir) {
+    const skillFile = path.join(dir, "SKILL.md");
+    if (!fs.existsSync(skillFile))
+        return null;
+    const body = fs.readFileSync(skillFile, "utf-8");
+    const frontmatter = body.match(/^---\n([\s\S]*?)\n---/);
+    const name = frontmatterField(frontmatter?.[1], "name") ?? path.basename(dir);
+    const description = frontmatterField(frontmatter?.[1], "description");
+    return { name: normalizeSkillName(name), dir, description };
+}
+function frontmatterField(frontmatter, field) {
+    if (!frontmatter)
+        return undefined;
+    const lines = frontmatter.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = lines[i].match(new RegExp(`^${field}:\\s*(.*)$`));
+        if (!match)
+            continue;
+        const raw = match[1].trim();
+        if (raw === ">-" || raw === ">" || raw === "|-" || raw === "|") {
+            const block = [];
+            for (let j = i + 1; j < lines.length; j += 1) {
+                const line = lines[j];
+                if (line.trim() && !/^\s/.test(line))
+                    break;
+                block.push(line.replace(/^\s+/, ""));
+            }
+            const value = raw.startsWith("|") ? block.join("\n") : block.join(" ");
+            return value.replace(/\s+/g, " ").trim() || undefined;
+        }
+        return raw.replace(/^["']|["']$/g, "").trim() || undefined;
+    }
+    return undefined;
+}
+async function materializeSource(input) {
+    const local = path.resolve(input);
+    if (fs.existsSync(local))
+        return { root: local };
+    const parsed = parseGitHubSource(input);
+    if (!parsed) {
+        throw new Error(`Skill source not found: ${input}. Use a local path, GitHub owner/repo, or GitHub URL.`);
+    }
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agent-native-skills-"));
+    const archive = path.join(tmpRoot, "source.tgz");
+    const ref = parsed.ref ?? "main";
+    const url = `https://codeload.github.com/${parsed.owner}/${parsed.repo}/tar.gz/${encodeURIComponent(ref)}`;
+    const response = await fetch(url, {
+        headers: { "user-agent": "@agent-native/skills" },
+    });
+    if (!response.ok) {
+        fs.rmSync(tmpRoot, { recursive: true, force: true });
+        throw new Error(`Could not download ${parsed.owner}/${parsed.repo}@${ref}: HTTP ${response.status}.`);
+    }
+    fs.writeFileSync(archive, Buffer.from(await response.arrayBuffer()));
+    const extractDir = path.join(tmpRoot, "extract");
+    fs.mkdirSync(extractDir, { recursive: true });
+    const extracted = spawnSync("tar", ["-xzf", archive, "-C", extractDir], {
+        stdio: "pipe",
+        encoding: "utf-8",
+    });
+    if (extracted.status !== 0) {
+        fs.rmSync(tmpRoot, { recursive: true, force: true });
+        throw new Error(`Could not extract ${input}: ${extracted.stderr || extracted.stdout}`);
+    }
+    const [first] = fs
+        .readdirSync(extractDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory());
+    if (!first) {
+        fs.rmSync(tmpRoot, { recursive: true, force: true });
+        throw new Error(`Downloaded archive for ${input} did not contain a repo directory.`);
+    }
+    return {
+        root: path.join(extractDir, first.name),
+        cleanup: () => fs.rmSync(tmpRoot, { recursive: true, force: true }),
+    };
+}
+function parseGitHubSource(input) {
+    const shorthand = input.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:#(.+))?$/);
+    if (shorthand) {
+        return {
+            owner: shorthand[1],
+            repo: shorthand[2].replace(/\.git$/, ""),
+            ref: shorthand[3],
+        };
+    }
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        return null;
+    }
+    if (url.hostname !== "github.com")
+        return null;
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    const treeIndex = parts.indexOf("tree");
+    return {
+        owner: parts[0],
+        repo: parts[1].replace(/\.git$/, ""),
+        ref: treeIndex >= 0 && parts[treeIndex + 1]
+            ? parts.slice(treeIndex + 1).join("/")
+            : url.hash.slice(1) || undefined,
+    };
+}
+function instructionContentForSkill(skillName) {
+    if (skillName === "quick-recap") {
+        return "When writing final response status indicators, use the /quick-recap skill always.";
+    }
+    if (skillName === "efficient-fable") {
+        return "When operating as Claude Fable, use the /efficient-fable skill always.";
+    }
+    if (skillName === "efficient-frontier") {
+        return "When using a high-cost frontier model for codebase-heavy work, use the /efficient-frontier skill always.";
+    }
+    if (skillName === "stay-within-limits") {
+        return "When long-running or parallel work needs usage-limit checks, use the /stay-within-limits skill always.";
+    }
+    if (skillName === "visual-plan") {
+        return "When work needs an interactive visual plan before implementation, use the /visual-plan skill always.";
+    }
+    if (skillName === "visual-recap") {
+        return "When a PR, branch, commit, or diff needs an interactive visual recap, use the /visual-recap skill always.";
+    }
+    if (skillName === "visualize-repo") {
+        return "When a repository needs local visual docs or a navigable Plan-backed repo viewer, use the /visualize-repo skill always.";
+    }
+    return null;
+}
+function managedInstructionBlocksForSkills(skillNames) {
+    return skillNames
+        .map((name) => instructionContentForSkill(name))
+        .filter((block) => Boolean(block));
+}
+async function shouldUpdateManagedInstructions(blocks, options) {
+    if (blocks.length === 0)
+        return false;
+    let shouldUpdate = options.updateInstructions;
+    if (shouldUpdate !== undefined)
+        return shouldUpdate;
+    if (options.yes)
+        return true;
+    return false;
+}
+function writeManagedInstructions(blocks, baseDir, clients, scope, options) {
+    if (blocks.length === 0)
+        return [];
+    const files = resolveInstructionFiles(baseDir, options.instructionFiles, clients, scope);
+    const content = `${MANAGED_INSTRUCTIONS_START}
+${blocks.join("\n")}
+${MANAGED_INSTRUCTIONS_END}`;
+    for (const file of files) {
+        if (options.dryRun)
+            continue;
+        upsertManagedBlock(file, content);
+    }
+    return files;
+}
+async function maybeUpdateInstructions(skillNames, baseDir, options) {
+    const blocks = managedInstructionBlocksForSkills(skillNames);
+    const clients = options.clients?.length ? options.clients : CLIENTS;
+    const scope = options.scope ?? "user";
+    if (!(await shouldUpdateManagedInstructions(blocks, options)))
+        return [];
+    return writeManagedInstructions(blocks, baseDir, clients, scope, options);
+}
+function resolveInstructionFiles(baseDir, explicit, clients, scope) {
+    if (explicit && explicit.length > 0) {
+        return explicit.map((file) => path.resolve(baseDir, file));
+    }
+    const instructionClients = clients.filter(supportsSkillFiles);
+    if (instructionClients.length === 0)
+        return [];
+    if (scope === "user") {
+        const home = process.env.HOME || os.homedir();
+        const files = [];
+        if (instructionClients.includes("codex")) {
+            const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
+            files.push(path.join(codexHome, "AGENTS.md"));
+        }
+        if (instructionClients.includes("claude-code")) {
+            files.push(path.join(home, ".claude", "CLAUDE.md"));
+        }
+        return unique(files);
+    }
+    const candidates = ["AGENTS.md", "CLAUDE.md"].map((file) => path.join(baseDir, file));
+    const existing = candidates.filter((file) => fs.existsSync(file));
+    return existing.length > 0 ? existing : [path.join(baseDir, "AGENTS.md")];
+}
+function stripManagedInstructionBlocks(text) {
+    const pattern = new RegExp(`${escapeRegExp(MANAGED_INSTRUCTIONS_START)}[\\s\\S]*?${escapeRegExp(MANAGED_INSTRUCTIONS_END)}`, "g");
+    return text.replace(pattern, "");
+}
+function upsertManagedBlock(file, block) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const existing = fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : "";
+    const firstAt = existing.indexOf(MANAGED_INSTRUCTIONS_START);
+    let next;
+    if (firstAt >= 0) {
+        // Collapse EVERY managed block into a single fresh one re-inserted where the
+        // first one began, so repeated installs or pre-existing duplicates never
+        // leave the same instructions written more than once.
+        const before = existing.slice(0, firstAt).trimEnd();
+        const after = stripManagedInstructionBlocks(existing.slice(firstAt)).trimStart();
+        next =
+            (before ? `${before}\n\n` : "") +
+                `${block.trimEnd()}\n` +
+                (after ? `\n${after}` : "");
+    }
+    else {
+        next = `${existing.trimEnd()}${existing.trim() ? "\n\n" : ""}${block.trimEnd()}\n`;
+    }
+    fs.writeFileSync(file, next, "utf-8");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const PR_VISUAL_RECAP_DOCS_URL = docsUrl("pr-visual-recap");
+function prVisualRecapWorkflowPath(baseDir) {
+    return path.join(baseDir, ".github", "workflows", "pr-visual-recap.yml");
+}
+function prVisualRecapSetupCommand() {
+    return "npx @agent-native/core@latest recap setup";
+}
+async function promptForGithubAction(context) {
+    const clack = await import("@clack/prompts");
+    const result = await clack.confirm({
+        message: "Optional: add automatic PR Visual Recaps? (GitHub Action)\n" +
+            "  Posts a human-friendly recap on every pull request.\n" +
+            `  Learn more: ${context.docsUrl}\n` +
+            `  Writes ${context.workflowPath}; ${context.setupCommand} finishes the GitHub secrets.`,
+        initialValue: false,
+    });
+    if (clack.isCancel(result)) {
+        clack.cancel("Skipped PR Visual Recap workflow.");
+        return null;
+    }
+    return Boolean(result);
+}
+async function shouldWritePrVisualRecapWorkflow(hasVisualRecap, options, baseDir) {
+    if (!hasVisualRecap)
+        return false;
+    if (options.withGithubAction)
+        return true;
+    if (fs.existsSync(prVisualRecapWorkflowPath(baseDir)))
+        return false;
+    if (options.yes || !isInteractive(options))
+        return false;
+    const prompt = options.promptGithubAction ?? promptForGithubAction;
+    const choice = await prompt({
+        workflowPath: path.join(".github", "workflows", "pr-visual-recap.yml"),
+        setupCommand: prVisualRecapSetupCommand(),
+        docsUrl: PR_VISUAL_RECAP_DOCS_URL,
+    });
+    return choice === true;
+}
+const PR_VISUAL_RECAP_REUSABLE_WORKFLOW = `name: PR Visual Recap
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review, labeled, closed]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pr-visual-recap-\${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  visual-recap:
+    if: github.event.action != 'labeled' || vars.VISUAL_RECAP_REQUIRED_LABELS != ''
+    permissions:
+      checks: write
+      contents: read
+      issues: write
+      pull-requests: read
+    uses: BuilderIO/agent-native/.github/workflows/pr-visual-recap-reusable.yml@main
+    with:
+      skill-source: repo
+      runs-on: \${{ vars.VISUAL_RECAP_RUNS_ON || '"ubuntu-latest"' }}
+      gate-runs-on: \${{ vars.VISUAL_RECAP_GATE_RUNS_ON || 'ubuntu-latest' }}
+      required-labels: \${{ vars.VISUAL_RECAP_REQUIRED_LABELS || '' }}
+    secrets:
+      PLAN_RECAP_TOKEN: \${{ secrets.PLAN_RECAP_TOKEN }}
+      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+      OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+      PLAN_RECAP_APP_URL: \${{ secrets.PLAN_RECAP_APP_URL }}
+`;
+function writePrVisualRecapWorkflow(baseDir, options) {
+    const file = path.join(baseDir, ".github", "workflows", "pr-visual-recap.yml");
+    if (options.dryRun)
+        return file;
+    if (fs.existsSync(file)) {
+        const current = fs.readFileSync(file, "utf-8");
+        if (current === PR_VISUAL_RECAP_REUSABLE_WORKFLOW)
+            return file;
+        if (!options.force) {
+            throw new Error(`${file} already exists and differs. Re-run with --force to overwrite it.`);
+        }
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, PR_VISUAL_RECAP_REUSABLE_WORKFLOW, "utf-8");
+    return file;
+}
+export function createInstallId() {
+    return randomUUID();
+}
+//# sourceMappingURL=index.js.map