agents-inc 0.149.2 → 0.151.0

package/dist/chunk-QTFQEYDA.js

@@ -0,0 +1,789 @@
+#!/usr/bin/env node
+import {
+  promptValue
+} from "./chunk-C55DN7GE.js";
+import {
+  runWizardSession
+} from "./chunk-SI5FOARI.js";
+import {
+  Spinner
+} from "./chunk-OZZGXBCN.js";
+import {
+  useTerminalDimensions
+} from "./chunk-UTFN6UJS.js";
+import {
+  SelectList
+} from "./chunk-DUVWGO6E.js";
+import {
+  STATUS_MESSAGES,
+  SUCCESS_MESSAGES
+} from "./chunk-GYG5SE2D.js";
+import {
+  compileAgentsAllScopes,
+  loadSource,
+  writeProjectConfig
+} from "./chunk-Y4CXDA3I.js";
+import {
+  discoverInstalledSkills,
+  installPluginSkills,
+  pluginInstallFailureError
+} from "./chunk-4R6PGHQQ.js";
+import {
+  copyLocalSkills
+} from "./chunk-3XFUQ6OL.js";
+import {
+  loadAgentDefs
+} from "./chunk-YBVA7GPW.js";
+import {
+  orderDomains
+} from "./chunk-44LLPS2N.js";
+import {
+  BaseCommand,
+  EXIT_CODES
+} from "./chunk-7QIHKQL5.js";
+import {
+  clearTerminalScreen
+} from "./chunk-P3PN5SVI.js";
+import {
+  INSTALL_MODE_LABELS,
+  buildAgentScopeMap,
+  deriveInstallMode,
+  detectGlobalInstallation,
+  detectInstallation,
+  getInstallationInfo,
+  isHomeDirectory,
+  loadProjectConfig,
+  loadProjectConfigFromDir,
+  resolveInstallPaths
+} from "./chunk-TVHRMRD3.js";
+import {
+  AGENT_NAMES,
+  fileExists,
+  getErrorMessage,
+  readFileSafe,
+  settingsFileSchema,
+  warn
+} from "./chunk-3LIU2ZEF.js";
+import {
+  getCategoryDomain
+} from "./chunk-DG2NGZ7S.js";
+import {
+  ASCII_LOGO,
+  CLAUDE_DIR,
+  CLAUDE_SRC_DIR,
+  CLI_COLORS,
+  CLI_INVOKE_COMMAND,
+  DEFAULT_BRANDING,
+  DEFAULT_PUBLIC_SOURCE_NAME,
+  EDIT_PROJECT_SETUP_FLAG,
+  EJECT_SOURCE,
+  MAX_CONFIG_FILE_SIZE,
+  STANDARD_FILES
+} from "./chunk-O5ASLZ2K.js";
+import {
+  init_esm_shims
+} from "./chunk-P56WJ5FA.js";
+
+// src/cli/commands/init.tsx
+init_esm_shims();
+import os from "os";
+import { Flags } from "@oclif/core";
+import { render, Box as Box2, Text as Text2, useApp } from "ink";
+
+// src/cli/lib/seed/fetch-seed.ts
+init_esm_shims();
+
+// src/cli/lib/seed/seed-schema.ts
+init_esm_shims();
+import { z } from "zod";
+var SEED_VERSION = 3;
+var seedModelSchema = z.enum(["opus", "fable", "sonnet", "haiku"]);
+var seedEffortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var seedLoadStateSchema = z.enum(["lazy", "preloaded"]);
+var seedSkillSchema = z.object({
+  install: z.enum(["plugin", "eject"]),
+  scope: z.enum(["project", "global"]),
+  /** Sub-agent id -> load state; presence is assignment. */
+  assignments: z.record(z.string(), seedLoadStateSchema)
+});
+var seedAgentSchema = z.object({
+  /** Explicitly switched on (bare) or off. Absent means "whatever the assignments imply". */
+  on: z.boolean().optional(),
+  model: seedModelSchema.optional(),
+  effort: seedEffortSchema.optional(),
+  /**
+   * Which `.claude/agents` directory this sub-agent's front-matter is written to. Absent means
+   * `project` — the CLI's own default, so a resting choice never has to travel.
+   */
+  scope: z.enum(["project", "global"]).optional()
+});
+var seedPayloadSchema = z.object({
+  v: z.literal(SEED_VERSION),
+  /**
+   * Diagnostics only. A mismatch with this CLI's matrix must never fail a decode — it explains
+   * why some ids were skipped, it does not decide whether to try.
+   */
+  matrixVersion: z.string(),
+  stackId: z.string().nullable(),
+  /** Sparse — presence is selection. `remembered` never leaves the browser. */
+  skills: z.record(z.string(), seedSkillSchema),
+  /** Sparse — an agent with nothing to say has no entry. */
+  agents: z.record(z.string(), seedAgentSchema)
+});
+
+// src/cli/lib/seed/fetch-seed.ts
+var SEED_API_URL = process.env.AGENTS_INC_API_URL ?? "https://api.agentsinc.sh";
+var SEED_USER_AGENT = "agents-inc-cli";
+async function fetchSeedConfig(id) {
+  const url = `${SEED_API_URL}/configs/${encodeURIComponent(id)}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { accept: "application/json", "user-agent": SEED_USER_AGENT }
+    });
+  } catch {
+    return { ok: false, error: `Could not reach ${SEED_API_URL} \u2014 check your connection.` };
+  }
+  if (response.status === 404) {
+    return { ok: false, error: `No configuration found for id '${id}'.` };
+  }
+  if (!response.ok) {
+    return { ok: false, error: `Fetching configuration failed (HTTP ${response.status}).` };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { ok: false, error: "The configuration store returned something that is not JSON." };
+  }
+  const parsed = seedPayloadSchema.safeParse(body);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      error: `Configuration '${id}' does not match the expected format \u2014 it may have been created by a newer version.`
+    };
+  }
+  return { ok: true, payload: parsed.data };
+}
+
+// src/cli/lib/seed/seed-to-wizard.ts
+init_esm_shims();
+
+// src/cli/types/agents.ts
+init_esm_shims();
+
+// src/cli/lib/seed/seed-to-wizard.ts
+var KNOWN_AGENTS = new Set(AGENT_NAMES);
+function sourceForSkill(skill) {
+  return skill?.availableSources?.find((s) => s.primary)?.name ?? DEFAULT_PUBLIC_SOURCE_NAME;
+}
+function addToDomainSelections(selections, domain, category, skillId) {
+  const categorySelections = selections[domain] ??= {};
+  const skillList = categorySelections[category] ??= [];
+  if (!skillList.includes(skillId)) skillList.push(skillId);
+}
+function addToAgentStack(stack, agent, category, assignment) {
+  const agentStack = stack[agent] ??= {};
+  const assignments = agentStack[category] ??= [];
+  assignments.push(assignment);
+}
+function toSkillAssignment(skillId, load) {
+  return { id: skillId, preloaded: load === "preloaded" };
+}
+function readAgentMap(agents) {
+  const known = /* @__PURE__ */ new Map();
+  const switchedOff = /* @__PURE__ */ new Set();
+  const unknown = [];
+  for (const [name, entry] of Object.entries(agents)) {
+    if (!KNOWN_AGENTS.has(name)) unknown.push(name);
+    else if (entry.on === false) switchedOff.add(name);
+    else known.set(name, entry);
+  }
+  return { known, switchedOff, unknown };
+}
+function agentScopeConfig(name, entry) {
+  return {
+    name,
+    scope: entry?.scope ?? "project",
+    ...entry?.model !== void 0 && { model: entry.model },
+    ...entry?.effort !== void 0 && { effort: entry.effort }
+  };
+}
+function seedToWizardResult(payload, matrix) {
+  const domainSelections = {};
+  const assignedStack = {};
+  const skills = [];
+  const skippedSkillIds = [];
+  const agentNames = /* @__PURE__ */ new Set();
+  const agentMap = readAgentMap(payload.agents);
+  const skippedAgentNames = new Set(agentMap.unknown);
+  for (const [skillId, entry] of Object.entries(payload.skills)) {
+    const skill = matrix.skills[skillId];
+    const domain = skill?.category ? getCategoryDomain(skill.category) : void 0;
+    if (!skill?.category || !domain) {
+      skippedSkillIds.push(skillId);
+      continue;
+    }
+    const id = skillId;
+    const category = skill.category;
+    addToDomainSelections(domainSelections, domain, category, id);
+    skills.push({
+      id,
+      scope: entry.scope,
+      // "eject" is a source in its own right; anything else names the marketplace it came from.
+      source: entry.install === "eject" ? "eject" : sourceForSkill(skill)
+    });
+    for (const [agentName, load] of Object.entries(entry.assignments)) {
+      if (agentMap.switchedOff.has(agentName)) continue;
+      if (!KNOWN_AGENTS.has(agentName)) {
+        skippedAgentNames.add(agentName);
+        continue;
+      }
+      const agent = agentName;
+      agentNames.add(agent);
+      addToAgentStack(assignedStack, agent, category, toSkillAssignment(id, load));
+    }
+  }
+  for (const [name, entry] of agentMap.known) {
+    if (entry.on === true) agentNames.add(name);
+  }
+  const selectedAgents = [...agentNames];
+  return {
+    result: {
+      skills,
+      selectedAgents,
+      agentConfigs: selectedAgents.map((name) => agentScopeConfig(name, agentMap.known.get(name))),
+      assignedStack,
+      selectedStackId: payload.stackId,
+      domainSelections,
+      selectedDomains: orderDomains(Object.keys(domainSelections)),
+      // Nothing was dropped from a *saved config* — the skipped ids came off the wire and are
+      // reported to the user directly, so there is no existing entry to preserve.
+      unresolvableSkillIds: [],
+      cancelled: false,
+      // A shared configuration was already validated by the app that built it; this path has no
+      // interactive step in which a validation warning could be acted on.
+      validation: { valid: true, errors: [], warnings: [] }
+    },
+    skippedSkillIds,
+    skippedAgentNames: [...skippedAgentNames]
+  };
+}
+
+// src/cli/lib/permission-checker.tsx
+init_esm_shims();
+import { Text, Box } from "ink";
+import path from "path";
+import { jsx, jsxs } from "react/jsx-runtime";
+async function readSettingsPermissions(filePath) {
+  if (!await fileExists(filePath)) return void 0;
+  try {
+    const content = await readFileSafe(filePath, MAX_CONFIG_FILE_SIZE);
+    const raw = JSON.parse(content);
+    const result = settingsFileSchema.safeParse(raw);
+    const parsed = result.success ? result.data : {};
+    return parsed.permissions;
+  } catch {
+    warn(`Malformed settings file at '${filePath}' \u2014 skipping`);
+    return void 0;
+  }
+}
+async function loadPermissions(projectRoot) {
+  const settingsPath = path.join(projectRoot, CLAUDE_DIR, STANDARD_FILES.SETTINGS_JSON);
+  const localSettingsPath = path.join(projectRoot, CLAUDE_DIR, STANDARD_FILES.SETTINGS_LOCAL_JSON);
+  for (const filePath of [localSettingsPath, settingsPath]) {
+    const permissions = await readSettingsPermissions(filePath);
+    if (permissions) return permissions;
+  }
+  return void 0;
+}
+async function checkPermissions(projectRoot) {
+  const permissions = await loadPermissions(projectRoot);
+  if (!permissions) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: CLI_COLORS.WARNING, padding: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: CLI_COLORS.WARNING, children: "Permission Notice" }),
+      /* @__PURE__ */ jsx(Text, { children: "No permissions configured in .claude/settings.json" }),
+      /* @__PURE__ */ jsx(Text, { children: "Agents will prompt for approval on each tool use." }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { children: "For autonomous operation, add to .claude/settings.json:" }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: "{" }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '  "permissions": {' }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '    "allow": [' }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '      "Read(*)",' }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '      "Bash(git *)",' }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: '      "Bash(bun *)"' }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: "    ]" }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: "  }" }),
+      /* @__PURE__ */ jsx(Text, { color: CLI_COLORS.DIM, children: "}" })
+    ] });
+  }
+  const hasRestrictiveBash = permissions.deny?.some(
+    (rule) => rule === "Bash(*)" || rule === "Bash"
+  );
+  const hasNoAllows = !permissions.allow || permissions.allow.length === 0;
+  if (hasRestrictiveBash || hasNoAllows) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: CLI_COLORS.WARNING, padding: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: CLI_COLORS.WARNING, children: "Permission Warnings" }),
+      hasRestrictiveBash && /* @__PURE__ */ jsx(Text, { children: "\u26A0 Bash is denied in permissions. Some agents require Bash for git, testing, and build commands." }),
+      hasNoAllows && /* @__PURE__ */ jsx(Text, { children: "\u26A0 No allow rules configured. Agents will prompt for each tool use." })
+    ] });
+  }
+  return null;
+}
+
+// src/cli/commands/init.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var DASHBOARD_OPTIONS = [
+  { label: "Edit", value: "edit" },
+  { label: "Compile", value: "compile" },
+  { label: "Doctor", value: "doctor" },
+  { label: "List", value: "list" }
+];
+var Dashboard = ({ onSelect, onCancel }) => {
+  const { exit } = useApp();
+  const { rows: terminalHeight } = useTerminalDimensions();
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: terminalHeight, children: [
+    /* @__PURE__ */ jsx2(Box2, { marginBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { children: ASCII_LOGO }) }),
+    /* @__PURE__ */ jsx2(
+      SelectList,
+      {
+        items: DASHBOARD_OPTIONS,
+        onSelect: (command) => {
+          onSelect(command);
+          exit();
+        },
+        onCancel: () => {
+          onCancel();
+          exit();
+        }
+      }
+    )
+  ] });
+};
+function formatDashboardText(data) {
+  const modeLabel = INSTALL_MODE_LABELS[data.mode];
+  const lines = [
+    DEFAULT_BRANDING.NAME,
+    "",
+    `  Skills:  ${data.skillCount} installed`,
+    `  Agents:  ${data.agentCount} compiled`,
+    `  Mode:    ${modeLabel}`
+  ];
+  if (data.source) {
+    lines.push(`  Source:  ${data.source}`);
+  }
+  lines.push("");
+  lines.push(`  [Edit]  [Compile]  [Doctor]  [List]`);
+  return lines.join("\n");
+}
+async function showDashboard(projectDir, log) {
+  const data = await getDashboardData(projectDir);
+  if (!process.stdin.isTTY) {
+    const output = log ?? console.log;
+    output(formatDashboardText(data));
+    return null;
+  }
+  const selectedCommand = await promptValue(
+    (resolve) => /* @__PURE__ */ jsx2(Dashboard, { onSelect: (command) => resolve(command), onCancel: () => resolve(null) }),
+    { onExit: null, clearOnResolve: true }
+  );
+  clearTerminalScreen();
+  return selectedCommand;
+}
+function dashboardCommandArgv(command, origin) {
+  if (command !== "edit" || origin !== "init") return [];
+  return [`--${EDIT_PROJECT_SETUP_FLAG}`];
+}
+async function runDashboardFlow(projectDir, config, origin, log) {
+  const installation = await detectInstallation(projectDir);
+  if (!installation) return false;
+  const selectedCommand = await showDashboard(projectDir, log);
+  if (selectedCommand) {
+    await config.runCommand(selectedCommand, dashboardCommandArgv(selectedCommand, origin));
+  }
+  return true;
+}
+var Init = class _Init extends BaseCommand {
+  static summary = `Initialize ${DEFAULT_BRANDING.NAME} in this project`;
+  static description = "Interactive wizard to set up skills and agents. Supports Plugin Mode (native install) and Eject Mode (copy to .claude/).";
+  static examples = [
+    {
+      description: "Start the setup wizard",
+      command: "<%= config.bin %> <%= command.id %>"
+    },
+    {
+      description: "Initialize from a custom marketplace",
+      command: "<%= config.bin %> <%= command.id %> --source github:org/marketplace"
+    },
+    {
+      description: "Force refresh skills from remote",
+      command: "<%= config.bin %> <%= command.id %> --refresh"
+    }
+  ];
+  static flags = {
+    ...BaseCommand.baseFlags,
+    refresh: Flags.boolean({
+      description: "Force refresh from remote source",
+      default: false
+    }),
+    from: Flags.string({
+      description: "Install a configuration shared from agentsinc.sh by its id, without the wizard",
+      helpValue: "<id>"
+    })
+  };
+  /**
+   * One spine, two producers. The wizard and a shared id differ only in *where the selection
+   * comes from* — everything after it (the empty guard, the install pipeline) is identical, so it
+   * lives here once rather than being written twice and drifting.
+   */
+  async run() {
+    const { flags } = await this.parse(_Init);
+    const projectDir = process.cwd();
+    if (!flags.from && await this.showDashboardIfInitialized(projectDir)) return;
+    const selection = flags.from ? await this.selectionFromSharedConfig(flags.from, flags) : await this.selectionFromWizard(flags, projectDir);
+    if (!selection) this.exit(EXIT_CODES.CANCELLED);
+    if (selection.result.skills.length === 0 && selection.result.selectedAgents.length === 0) {
+      this.error(selection.emptyMessage, { exit: EXIT_CODES.ERROR });
+    }
+    await this.handleInstallation(
+      selection.result,
+      selection.sourceResult,
+      flags,
+      selection.interactive
+    );
+  }
+  /** The interactive producer: load the source, run the wizard, return what was chosen. */
+  async selectionFromWizard(flags, projectDir) {
+    const isGlobalRoot = isHomeDirectory(projectDir);
+    const { unmount, clear: clearSpinner } = render(
+      /* @__PURE__ */ jsx2(Spinner, { label: STATUS_MESSAGES.LOADING_SKILLS })
+    );
+    const [{ sourceResult, startupMessages }, globalConfig] = await Promise.all([
+      this.loadSourceOrFail(flags),
+      this.loadGlobalConfigIfExists()
+    ]);
+    clearSpinner();
+    unmount();
+    const result = await this.runWizard(
+      sourceResult,
+      startupMessages,
+      projectDir,
+      globalConfig,
+      isGlobalRoot
+    );
+    if (!result) return null;
+    return {
+      result,
+      sourceResult,
+      // A person is already at the terminal, so the permission notice can wait for them.
+      interactive: true,
+      emptyMessage: "No skills selected"
+    };
+  }
+  /**
+   * The `--from <id>` producer: fetch and map, no wizard. Nothing here may assume a TTY — running
+   * headless is most of why the flag exists.
+   */
+  async selectionFromSharedConfig(id, flags) {
+    this.log(`Fetching configuration ${id}...`);
+    const fetched = await fetchSeedConfig(id);
+    if (!fetched.ok) {
+      this.error(fetched.error, { exit: EXIT_CODES.ERROR });
+    }
+    const { sourceResult } = await this.loadSourceOrFail(flags);
+    const { result, skippedSkillIds, skippedAgentNames } = seedToWizardResult(
+      fetched.payload,
+      sourceResult.matrix
+    );
+    if (skippedSkillIds.length > 0) {
+      this.warn(
+        `Skipped ${skippedSkillIds.length} skill(s) this catalog does not know: ${skippedSkillIds.join(", ")}`
+      );
+    }
+    if (skippedAgentNames.length > 0) {
+      this.warn(
+        `Skipped ${skippedAgentNames.length} unknown sub-agent(s): ${skippedAgentNames.join(", ")}`
+      );
+    }
+    if (result.skills.length > 0) {
+      this.log(
+        `Installing ${result.skills.length} skill(s) across ${result.selectedAgents.length} sub-agent(s)
+`
+      );
+    }
+    return {
+      result,
+      sourceResult,
+      interactive: false,
+      emptyMessage: `Configuration '${id}' contains no skills this catalog can install.`
+    };
+  }
+  async showDashboardIfInitialized(projectDir) {
+    return runDashboardFlow(projectDir, this.config, "init", (msg) => this.log(msg));
+  }
+  async loadGlobalConfigIfExists() {
+    const globalInstall = await detectGlobalInstallation();
+    if (!globalInstall) return null;
+    const loaded = await loadProjectConfigFromDir(os.homedir());
+    return loaded?.config ?? null;
+  }
+  async loadSourceOrFail(flags) {
+    try {
+      const loaded = await loadSource({
+        sourceFlag: flags.source,
+        projectDir: process.cwd(),
+        forceRefresh: flags.refresh,
+        captureStartupMessages: true
+      });
+      return { sourceResult: loaded.sourceResult, startupMessages: loaded.startupMessages };
+    } catch (error) {
+      this.error(getErrorMessage(error), {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+  }
+  async runWizard(sourceResult, startupMessages, projectDir, globalConfig, isGlobalRoot) {
+    return runWizardSession({
+      hydrate: {
+        initialAgents: globalConfig?.selectedAgents,
+        installedSkillIds: globalConfig?.skills?.map((s) => s.id),
+        installedSkillConfigs: globalConfig?.skills,
+        installedAgentConfigs: globalConfig?.agents,
+        isEditingFromGlobalScope: isGlobalRoot
+      },
+      props: {
+        version: this.config.version,
+        logo: ASCII_LOGO,
+        initialAgents: globalConfig?.selectedAgents,
+        installedSkillIds: globalConfig?.skills?.map((s) => s.id),
+        projectDir,
+        startupMessages
+      },
+      onCancel: () => this.log("Setup cancelled"),
+      clearTerminal: () => this.clearTerminal()
+    });
+  }
+  async handleInstallation(result, sourceResult, flags, interactive = true) {
+    const projectDir = process.cwd();
+    const activeSkills = result.skills.filter((s) => !s.excluded);
+    const installMode = deriveInstallMode(activeSkills);
+    const ejectedSkills = activeSkills.filter((s) => s.source === EJECT_SOURCE);
+    const pluginSkills = activeSkills.filter((s) => s.source !== EJECT_SOURCE);
+    this.logInstallPlan(installMode, ejectedSkills, pluginSkills);
+    const resolvedMarketplace = pluginSkills.length > 0 ? await this.requireMarketplaceOrExit(
+      sourceResult,
+      "install plugin skills",
+      (marketplace) => this.log(`Registering marketplace "${marketplace}"...`)
+    ) : null;
+    const copyResult = installMode === "eject" || installMode === "mixed" ? await this.copyEjectSkillsStep(ejectedSkills, projectDir, sourceResult, installMode) : null;
+    if (resolvedMarketplace !== null) {
+      await this.installPluginsStep(pluginSkills, resolvedMarketplace, projectDir);
+    }
+    const pluginModeSucceeded = resolvedMarketplace !== null;
+    try {
+      const { configResult, compileResult, agentScopeMap } = await this.writeConfigAndCompile(
+        result,
+        sourceResult,
+        flags
+      );
+      this.reportSuccess(
+        configResult,
+        compileResult,
+        agentScopeMap,
+        installMode,
+        pluginModeSucceeded,
+        copyResult
+      );
+      const permissionWarning = await checkPermissions(projectDir);
+      if (permissionWarning) {
+        if (interactive) {
+          const { waitUntilExit } = render(permissionWarning);
+          await waitUntilExit();
+        } else {
+          const { unmount } = render(permissionWarning);
+          unmount();
+        }
+      }
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  logInstallPlan(installMode, ejectedSkills, pluginSkills) {
+    this.log("\n");
+    this.log(`Selected ${ejectedSkills.length + pluginSkills.length} skills`);
+    this.log(
+      `Install mode: ${installMode === "plugin" ? `${INSTALL_MODE_LABELS.plugin} (native install)` : installMode === "mixed" ? `${INSTALL_MODE_LABELS.mixed} (${ejectedSkills.length} eject, ${pluginSkills.length} plugin)` : `${INSTALL_MODE_LABELS.eject} (copy to .claude/skills/)`}`
+    );
+  }
+  async copyEjectSkillsStep(localSkills, projectDir, sourceResult, installMode) {
+    this.log("Copying skills to local directory...");
+    const copyResult = await copyLocalSkills(localSkills, projectDir, sourceResult);
+    if (installMode === "mixed") {
+      if (copyResult.projectCopied.length > 0 && copyResult.globalCopied.length > 0) {
+        this.log(
+          `Copied ${copyResult.totalCopied} local skills (${copyResult.projectCopied.length} project, ${copyResult.globalCopied.length} global)`
+        );
+      } else if (copyResult.globalCopied.length > 0) {
+        this.log(`Copied ${copyResult.globalCopied.length} local skills to ~/.claude/skills/`);
+      } else {
+        this.log(`Copied ${copyResult.projectCopied.length} local skills to .claude/skills/`);
+      }
+    } else {
+      this.log(`Copied ${copyResult.totalCopied} skills to .claude/skills/
+`);
+    }
+    return copyResult;
+  }
+  async installPluginsStep(pluginSkills, marketplace, projectDir) {
+    this.log("Installing skill plugins...");
+    const pluginResult = await installPluginSkills(pluginSkills, marketplace, projectDir);
+    for (const item of pluginResult.installed) {
+      this.log(`  Installed ${item.ref}`);
+    }
+    for (const item of pluginResult.failed) {
+      this.warn(`Failed to install plugin ${item.id}: ${item.error}`);
+    }
+    if (pluginResult.failed.length > 0) {
+      this.error(pluginInstallFailureError(pluginResult.failed.length), {
+        exit: EXIT_CODES.ERROR
+      });
+    }
+    this.log(`Installed ${pluginResult.installed.length} skill plugins
+`);
+  }
+  async writeConfigAndCompile(result, sourceResult, flags) {
+    this.log("Generating configuration...");
+    const configResult = await writeProjectConfig({
+      wizardResult: result,
+      sourceResult,
+      projectDir: process.cwd(),
+      sourceFlag: flags.source
+    });
+    if (configResult.wasMerged) {
+      this.log(`Merged with existing config at ${configResult.existingConfigPath}`);
+    }
+    this.log(`Configuration saved (${configResult.config.agents.length} agents)
+`);
+    this.log(STATUS_MESSAGES.COMPILING_AGENTS);
+    const cwd = process.cwd();
+    const agentDefs = await loadAgentDefs();
+    const { allSkills } = await discoverInstalledSkills(cwd);
+    const agentScopeMap = buildAgentScopeMap(configResult.config);
+    const compileResult = await compileAgentsAllScopes({
+      projectDir: cwd,
+      sourcePath: agentDefs.sourcePath,
+      skills: allSkills,
+      agentScopeMap
+    });
+    this.log(`Compiled ${compileResult.compiled.length} agents
+`);
+    this.reportPropagatedRecompile(configResult.propagation);
+    return { configResult, compileResult, agentScopeMap };
+  }
+  /**
+   * Renders the recompile the gated write already performed on every OTHER
+   * registered project this run's global change was propagated into.
+   */
+  reportPropagatedRecompile(propagation) {
+    if (propagation.propagated.updated.length === 0) return;
+    const { recompiledCount, failedCount, warnings } = propagation.recompile;
+    for (const warning of warnings) {
+      this.warn(warning);
+    }
+    const failureSuffix = failedCount > 0 ? ` (${failedCount} failed)` : "";
+    this.log(`Recompiled agents in ${recompiledCount} registered projects${failureSuffix}
+`);
+  }
+  reportSuccess(configResult, compileResult, agentScopeMap, installMode, pluginModeSucceeded, copyResult) {
+    this.log(`${SUCCESS_MESSAGES.INIT_SUCCESS}
+`);
+    const isEjectOutput = installMode === "eject" || installMode === "mixed" && !pluginModeSucceeded;
+    if (isEjectOutput && copyResult && copyResult.totalCopied > 0) {
+      this.reportSkillsCopied(copyResult);
+    }
+    this.reportAgentsCompiled(compileResult.compiled, agentScopeMap);
+    this.log("Configuration:");
+    this.log(`  ${configResult.configPath}`);
+    this.log("");
+    this.log("To customize agent-skill assignments:");
+    this.log(`  1. Edit ${CLAUDE_SRC_DIR}/${STANDARD_FILES.CONFIG_TS}`);
+    this.log(`  2. Run '${CLI_INVOKE_COMMAND} compile' to regenerate agents`);
+    this.log("");
+  }
+  /**
+   * Reports where the skills actually landed. `copyLocalSkills` splits by scope,
+   * so a default install driven from a project directory writes every skill
+   * under HOME — reporting the project path there names a directory that was
+   * never written.
+   *
+   * This block is a filesystem listing, so the entries are the on-disk directory
+   * names — skill ids, not display names. `copySkillsToLocalFlattened` names each
+   * destination directory after `skill.id`, so a user can copy any line and `cd`
+   * into it.
+   */
+  reportSkillsCopied(copyResult) {
+    const cwd = process.cwd();
+    const groups = isHomeDirectory(cwd) ? [
+      {
+        dir: resolveInstallPaths(cwd, "project").skillsDir,
+        copied: [...copyResult.globalCopied, ...copyResult.projectCopied]
+      }
+    ] : [
+      { dir: resolveInstallPaths(cwd, "global").skillsDir, copied: copyResult.globalCopied },
+      { dir: resolveInstallPaths(cwd, "project").skillsDir, copied: copyResult.projectCopied }
+    ].filter((group) => group.copied.length > 0);
+    for (const group of groups) {
+      this.log("Skills copied to:");
+      this.log(`  ${group.dir}`);
+      for (const copied of group.copied) {
+        this.log(`    ${copied.skillId}/`);
+      }
+      this.log("");
+    }
+  }
+  /**
+   * Reports where the agents actually landed, mirroring the scope split
+   * `compileAgentsAllScopes` performs: one pass at the home root, otherwise a
+   * global pass under HOME and a project pass under the project directory.
+   */
+  reportAgentsCompiled(compiled, agentScopeMap) {
+    const cwd = process.cwd();
+    const groups = isHomeDirectory(cwd) ? [{ dir: resolveInstallPaths(cwd, "project").agentsDir, agents: compiled }] : [
+      {
+        dir: resolveInstallPaths(cwd, "global").agentsDir,
+        agents: compiled.filter((name) => agentScopeMap.get(name) === "global")
+      },
+      {
+        dir: resolveInstallPaths(cwd, "project").agentsDir,
+        agents: compiled.filter((name) => agentScopeMap.get(name) !== "global")
+      }
+    ].filter((group) => group.agents.length > 0);
+    for (const group of groups) {
+      this.log("Agents compiled to:");
+      this.log(`  ${group.dir}`);
+      for (const agentName of group.agents) {
+        this.log(`    ${agentName}.md`);
+      }
+      this.log("");
+    }
+  }
+};
+async function getDashboardData(projectDir) {
+  const [info, loaded] = await Promise.all([getInstallationInfo(), loadProjectConfig(projectDir)]);
+  const activeSkills = loaded?.config?.skills?.filter((s) => !s.excluded);
+  const skillCount = info?.skillCount ?? 0;
+  const agentCount = info?.agentCount ?? 0;
+  const mode = info?.mode ?? (activeSkills ? deriveInstallMode(activeSkills) : "eject");
+  const source = loaded?.config?.source;
+  return { skillCount, agentCount, mode, source };
+}
+
+export {
+  formatDashboardText,
+  showDashboard,
+  runDashboardFlow,
+  Init,
+  getDashboardData
+};
+//# sourceMappingURL=chunk-QTFQEYDA.js.map