@agents-inc/cli 0.85.0 → 0.86.0

package/dist/chunk-DCVCFBQ7.js

@@ -0,0 +1,1800 @@
+#!/usr/bin/env node
+import {
+  truncateText
+} from "./chunk-N6A7A4RA.js";
+import {
+  getAgentDefinitions,
+  recompileAgents
+} from "./chunk-FBZR46GC.js";
+import {
+  buildAgentScopeMap,
+  buildAndMergeConfig,
+  claudePluginInstall,
+  claudePluginMarketplaceAdd,
+  claudePluginMarketplaceExists,
+  claudePluginMarketplaceUpdate,
+  claudePluginUninstall,
+  compareLocalSkillsWithSource,
+  copySkillsToLocalFlattened,
+  deriveInstallMode,
+  detectGlobalInstallation,
+  detectInstallation,
+  detectProjectInstallation,
+  discoverAllPluginSkills,
+  discoverLocalSkills,
+  ensureBlankGlobalConfig,
+  fetchFromSource,
+  fetchMarketplace,
+  getInstallationInfo,
+  getProjectPluginsDir,
+  injectForkedFromMetadata,
+  isClaudeCLIAvailable,
+  listPluginNames,
+  loadProjectConfig,
+  loadProjectConfigFromDir,
+  loadProjectSourceConfig,
+  loadSkillsMatrixFromSource,
+  readForkedFromMetadata,
+  resolveInstallPaths,
+  resolveSource,
+  writeScopedConfigs
+} from "./chunk-TMTUTUEV.js";
+import {
+  loadAllAgents,
+  parseFrontmatter
+} from "./chunk-B6MYECV6.js";
+import {
+  typedEntries,
+  typedKeys
+} from "./chunk-ANXHMG32.js";
+import {
+  copy,
+  directoryExists,
+  disableBuffering,
+  drainBuffer,
+  enableBuffering,
+  ensureDir,
+  fileExists,
+  getErrorMessage,
+  glob,
+  listDirectories,
+  readFile,
+  remove,
+  verbose,
+  warn,
+  writeFile
+} from "./chunk-NUU3U43A.js";
+import {
+  CLAUDE_DIR,
+  CLAUDE_SRC_DIR,
+  DEFAULT_SKILLS_SUBDIR,
+  DIRS,
+  GLOBAL_INSTALL_ROOT,
+  LOCAL_SKILLS_PATH,
+  PROJECT_ROOT,
+  STANDARD_FILES
+} from "./chunk-6PGL2XMY.js";
+import {
+  init_esm_shims
+} from "./chunk-DHET7RCE.js";
+
+// src/cli/lib/operations/detect-both-installations.ts
+init_esm_shims();
+import os from "os";
+async function detectBothInstallations(projectDir) {
+  const global = await detectGlobalInstallation();
+  const project = projectDir === os.homedir() ? null : await detectProjectInstallation(projectDir);
+  return { global, project, hasBoth: !!global && !!project };
+}
+
+// src/cli/lib/operations/load-source.ts
+init_esm_shims();
+async function loadSource(options) {
+  const { sourceFlag, projectDir, forceRefresh, captureStartupMessages } = options;
+  if (captureStartupMessages) {
+    enableBuffering();
+  }
+  let sourceResult;
+  try {
+    sourceResult = await loadSkillsMatrixFromSource({
+      sourceFlag,
+      projectDir,
+      forceRefresh
+    });
+  } catch (error) {
+    if (captureStartupMessages) {
+      disableBuffering();
+    }
+    throw error;
+  }
+  let startupMessages = [];
+  if (captureStartupMessages) {
+    startupMessages = drainBuffer();
+    disableBuffering();
+  }
+  return { sourceResult, startupMessages };
+}
+
+// src/cli/lib/operations/get-dashboard-data.ts
+init_esm_shims();
+async function getDashboardData(projectDir) {
+  const [info, loaded] = await Promise.all([getInstallationInfo(), loadProjectConfig(projectDir)]);
+  const skillCount = loaded?.config?.skills?.length ?? 0;
+  const agentCount = info?.agentCount ?? 0;
+  const mode = info?.mode ?? (loaded?.config?.skills ? deriveInstallMode(loaded.config.skills) : "local");
+  const source = loaded?.config?.source;
+  return { skillCount, agentCount, mode, source };
+}
+
+// src/cli/lib/operations/detect-project.ts
+init_esm_shims();
+async function detectProject(projectDir) {
+  const resolvedDir = projectDir ?? process.cwd();
+  const installation = await detectInstallation(resolvedDir);
+  if (!installation) {
+    return null;
+  }
+  const loaded = await loadProjectConfig(installation.projectDir);
+  return {
+    installation,
+    config: loaded?.config ?? null,
+    configPath: loaded?.configPath ?? null
+  };
+}
+
+// src/cli/lib/operations/load-agent-defs.ts
+init_esm_shims();
+async function loadAgentDefs(agentSource, options) {
+  const agentSourcePaths = await getAgentDefinitions(agentSource, options);
+  const cliAgents = await loadAllAgents(PROJECT_ROOT);
+  const sourceAgents = await loadAllAgents(agentSourcePaths.sourcePath);
+  const agents = { ...cliAgents, ...sourceAgents };
+  return {
+    agents,
+    sourcePath: agentSourcePaths.sourcePath,
+    agentSourcePaths
+  };
+}
+
+// src/cli/lib/operations/copy-local-skills.ts
+init_esm_shims();
+async function copyLocalSkills(skills, projectDir, sourceResult) {
+  const projectLocalSkills = skills.filter((s) => s.scope !== "global");
+  const globalLocalSkills = skills.filter((s) => s.scope === "global");
+  const projectPaths = resolveInstallPaths(projectDir, "project");
+  const globalPaths = resolveInstallPaths(projectDir, "global");
+  let projectCopied = [];
+  if (projectLocalSkills.length > 0) {
+    await ensureDir(projectPaths.skillsDir);
+    projectCopied = await copySkillsToLocalFlattened(
+      projectLocalSkills.map((s) => s.id),
+      projectPaths.skillsDir,
+      sourceResult.matrix,
+      sourceResult
+    );
+  }
+  let globalCopied = [];
+  if (globalLocalSkills.length > 0) {
+    await ensureDir(globalPaths.skillsDir);
+    globalCopied = await copySkillsToLocalFlattened(
+      globalLocalSkills.map((s) => s.id),
+      globalPaths.skillsDir,
+      sourceResult.matrix,
+      sourceResult
+    );
+  }
+  return {
+    projectCopied,
+    globalCopied,
+    totalCopied: projectCopied.length + globalCopied.length
+  };
+}
+
+// src/cli/lib/operations/install-plugin-skills.ts
+init_esm_shims();
+async function installPluginSkills(skills, marketplace, projectDir) {
+  const pluginSkills = skills.filter((s) => s.source !== "local");
+  const installed = [];
+  const failed = [];
+  for (const skill of pluginSkills) {
+    const pluginRef = `${skill.id}@${marketplace}`;
+    const pluginScope = skill.scope === "global" ? "user" : "project";
+    try {
+      await claudePluginInstall(pluginRef, pluginScope, projectDir);
+      installed.push({ id: skill.id, ref: pluginRef });
+    } catch (error) {
+      failed.push({ id: skill.id, error: getErrorMessage(error) });
+    }
+  }
+  return { installed, failed };
+}
+
+// src/cli/lib/operations/uninstall-plugin-skills.ts
+init_esm_shims();
+async function uninstallPluginSkills(skillIds, oldSkills, projectDir) {
+  const uninstalled = [];
+  const failed = [];
+  for (const skillId of skillIds) {
+    const oldSkill = oldSkills.find((s) => s.id === skillId);
+    const pluginScope = oldSkill?.scope === "global" ? "user" : "project";
+    try {
+      await claudePluginUninstall(skillId, pluginScope, projectDir);
+      uninstalled.push(skillId);
+    } catch (error) {
+      failed.push({ id: skillId, error: getErrorMessage(error) });
+    }
+  }
+  return { uninstalled, failed };
+}
+
+// src/cli/lib/operations/collect-scoped-skill-dirs.ts
+init_esm_shims();
+import os2 from "os";
+import path from "path";
+async function collectScopedSkillDirs(projectDir) {
+  const homeDir = os2.homedir();
+  const projectLocalPath = path.join(projectDir, LOCAL_SKILLS_PATH);
+  const globalLocalPath = path.join(homeDir, LOCAL_SKILLS_PATH);
+  const hasProject = await fileExists(projectLocalPath);
+  const hasGlobal = projectDir !== homeDir && await fileExists(globalLocalPath);
+  const dirs = [];
+  if (hasProject) {
+    for (const dirName of await listDirectories(projectLocalPath)) {
+      dirs.push({ dirName, localSkillsPath: projectLocalPath, scope: "project" });
+    }
+  }
+  if (hasGlobal) {
+    const projectDirNames = new Set(dirs.map((d) => d.dirName));
+    for (const dirName of await listDirectories(globalLocalPath)) {
+      if (!projectDirNames.has(dirName)) {
+        dirs.push({ dirName, localSkillsPath: globalLocalPath, scope: "global" });
+      }
+    }
+  }
+  return { dirs, hasProject, hasGlobal, projectLocalPath, globalLocalPath };
+}
+
+// src/cli/lib/operations/compare-skills.ts
+init_esm_shims();
+import os3 from "os";
+function buildSourceSkillsMap(matrix) {
+  const sourceSkills = {};
+  for (const [skillId, skill] of typedEntries(matrix.skills)) {
+    if (!skill) continue;
+    if (!skill.local) {
+      sourceSkills[skillId] = { path: skill.path };
+    }
+  }
+  return sourceSkills;
+}
+async function compareSkillsWithSource(projectDir, sourcePath, matrix) {
+  const sourceSkills = buildSourceSkillsMap(matrix);
+  const { hasProject, hasGlobal } = await collectScopedSkillDirs(projectDir);
+  const homeDir = os3.homedir();
+  const projectResults = hasProject ? await compareLocalSkillsWithSource(projectDir, sourcePath, sourceSkills) : [];
+  const globalResults = hasGlobal ? await compareLocalSkillsWithSource(homeDir, sourcePath, sourceSkills) : [];
+  const seenIds = new Set(projectResults.map((r) => r.id));
+  const merged = [...projectResults, ...globalResults.filter((r) => !seenIds.has(r.id))];
+  return { projectResults, globalResults, merged };
+}
+
+// src/cli/lib/operations/ensure-marketplace.ts
+init_esm_shims();
+async function ensureMarketplace(sourceResult) {
+  if (!sourceResult.marketplace) {
+    try {
+      const marketplaceResult = await fetchMarketplace(sourceResult.sourceConfig.source, {});
+      sourceResult.marketplace = marketplaceResult.marketplace.name;
+    } catch {
+      return { marketplace: null, registered: false };
+    }
+  }
+  const marketplace = sourceResult.marketplace;
+  const exists = await claudePluginMarketplaceExists(marketplace);
+  if (!exists) {
+    const marketplaceSource = sourceResult.sourceConfig.source.replace(/^github:/, "");
+    await claudePluginMarketplaceAdd(marketplaceSource);
+    return { marketplace, registered: true };
+  }
+  try {
+    await claudePluginMarketplaceUpdate(marketplace);
+  } catch {
+    warn("Could not update marketplace \u2014 continuing with cached version");
+  }
+  return { marketplace, registered: false };
+}
+
+// src/cli/lib/operations/write-project-config.ts
+init_esm_shims();
+import fs from "fs";
+import os4 from "os";
+import path2 from "path";
+async function writeProjectConfig(options) {
+  const { wizardResult, sourceResult, projectDir, sourceFlag } = options;
+  const projectPaths = resolveInstallPaths(projectDir, "project");
+  await ensureDir(path2.dirname(projectPaths.configPath));
+  let agents;
+  if (options.agents) {
+    agents = options.agents;
+  } else {
+    const cliAgents = await loadAllAgents(PROJECT_ROOT);
+    const sourceAgents = await loadAllAgents(sourceResult.sourcePath);
+    agents = { ...cliAgents, ...sourceAgents };
+  }
+  const mergeResult = await buildAndMergeConfig(wizardResult, sourceResult, projectDir, sourceFlag);
+  const finalConfig = mergeResult.config;
+  const isProjectContext = fs.realpathSync(projectDir) !== fs.realpathSync(os4.homedir());
+  if (isProjectContext) {
+    await ensureBlankGlobalConfig();
+  }
+  await writeScopedConfigs(
+    finalConfig,
+    sourceResult.matrix,
+    agents,
+    projectDir,
+    projectPaths.configPath,
+    isProjectContext
+  );
+  return {
+    config: finalConfig,
+    configPath: projectPaths.configPath,
+    wasMerged: mergeResult.merged,
+    existingConfigPath: mergeResult.existingConfigPath,
+    filesWritten: isProjectContext ? 4 : 2
+  };
+}
+
+// src/cli/lib/operations/compile-agents.ts
+init_esm_shims();
+async function compileAgents(options) {
+  let resolvedAgents = options.agents;
+  let resolvedAgentScopeMap = options.agentScopeMap;
+  if (options.scopeFilter) {
+    const loadedConfig = await loadProjectConfigFromDir(options.projectDir);
+    if (!resolvedAgentScopeMap && loadedConfig?.config) {
+      resolvedAgentScopeMap = buildAgentScopeMap(loadedConfig.config);
+    }
+    const filteredAgents = loadedConfig?.config?.agents?.filter((a) => a.scope === options.scopeFilter).map((a) => a.name);
+    if (resolvedAgents && filteredAgents) {
+      const filterSet = new Set(filteredAgents);
+      resolvedAgents = resolvedAgents.filter((a) => filterSet.has(a));
+    } else if (filteredAgents) {
+      resolvedAgents = filteredAgents;
+    }
+  }
+  const recompileResult = await recompileAgents({
+    pluginDir: options.pluginDir ?? options.projectDir,
+    sourcePath: options.sourcePath,
+    agents: resolvedAgents,
+    skills: options.skills,
+    projectDir: options.projectDir,
+    outputDir: options.outputDir,
+    installMode: options.installMode,
+    agentScopeMap: resolvedAgentScopeMap
+  });
+  return {
+    compiled: recompileResult.compiled,
+    failed: recompileResult.failed,
+    warnings: recompileResult.warnings
+  };
+}
+
+// src/cli/lib/operations/detect-config-changes.ts
+init_esm_shims();
+function detectConfigChanges(oldConfig, wizardResult, currentSkillIds) {
+  const newSkillIds = wizardResult.skills.map((s) => s.id);
+  const addedSkills = newSkillIds.filter((id) => !currentSkillIds.includes(id));
+  const removedSkills = currentSkillIds.filter((id) => !newSkillIds.includes(id));
+  const oldAgentNames = oldConfig?.agents?.map((a) => a.name) ?? [];
+  const newAgentNames = wizardResult.agentConfigs.map((a) => a.name);
+  const addedAgents = newAgentNames.filter((name) => !oldAgentNames.includes(name));
+  const removedAgents = oldAgentNames.filter((name) => !newAgentNames.includes(name));
+  const sourceChanges = /* @__PURE__ */ new Map();
+  const scopeChanges = /* @__PURE__ */ new Map();
+  if (oldConfig?.skills) {
+    for (const newSkill of wizardResult.skills) {
+      const oldSkill = oldConfig.skills.find((s) => s.id === newSkill.id);
+      if (oldSkill && oldSkill.source !== newSkill.source) {
+        sourceChanges.set(newSkill.id, {
+          from: oldSkill.source,
+          to: newSkill.source
+        });
+      }
+      if (oldSkill && oldSkill.scope !== newSkill.scope) {
+        scopeChanges.set(newSkill.id, {
+          from: oldSkill.scope,
+          to: newSkill.scope
+        });
+      }
+    }
+  }
+  const agentScopeChanges = /* @__PURE__ */ new Map();
+  if (oldConfig?.agents) {
+    for (const newAgent of wizardResult.agentConfigs) {
+      const oldAgent = oldConfig.agents.find((a) => a.name === newAgent.name);
+      if (oldAgent && oldAgent.scope !== newAgent.scope) {
+        agentScopeChanges.set(newAgent.name, {
+          from: oldAgent.scope,
+          to: newAgent.scope
+        });
+      }
+    }
+  }
+  return {
+    addedSkills,
+    removedSkills,
+    addedAgents,
+    removedAgents,
+    sourceChanges,
+    scopeChanges,
+    agentScopeChanges
+  };
+}
+
+// src/cli/lib/operations/update-local-skills.ts
+init_esm_shims();
+import path3 from "path";
+async function updateLocalSkills(options) {
+  const { skills, sourceResult, skillBaseDir, onProgress } = options;
+  const updated = [];
+  const failed = [];
+  for (const skill of skills) {
+    onProgress?.(skill.id);
+    if (!skill.sourcePath || !skill.sourceHash) {
+      failed.push({
+        id: skill.id,
+        success: false,
+        newHash: null,
+        error: "No source path available"
+      });
+      continue;
+    }
+    const baseDir = skillBaseDir.get(skill.id) ?? process.cwd();
+    const localSkillsPath = path3.join(baseDir, LOCAL_SKILLS_PATH);
+    const destPath = path3.join(localSkillsPath, skill.dirName);
+    const srcPath = path3.join(sourceResult.sourcePath, "src", skill.sourcePath);
+    try {
+      await copy(srcPath, destPath);
+      await injectForkedFromMetadata(destPath, skill.id, skill.sourceHash);
+      updated.push({ id: skill.id, success: true, newHash: skill.sourceHash });
+    } catch (error) {
+      failed.push({ id: skill.id, success: false, newHash: null, error: getErrorMessage(error) });
+    }
+  }
+  return {
+    updated,
+    failed,
+    totalUpdated: updated.length,
+    totalFailed: failed.length
+  };
+}
+
+// src/cli/lib/operations/discover-skills.ts
+init_esm_shims();
+import os5 from "os";
+import path4 from "path";
+async function loadSkillsFromDir(skillsDir, pathPrefix = "") {
+  const skills = {};
+  if (!await directoryExists(skillsDir)) {
+    return skills;
+  }
+  const skillFiles = await glob("**/SKILL.md", skillsDir);
+  for (const skillFile of skillFiles) {
+    const skillPath = path4.join(skillsDir, skillFile);
+    const skillDir = path4.dirname(skillPath);
+    const relativePath = path4.relative(skillsDir, skillDir);
+    const skillDirName = path4.basename(skillDir);
+    const metadataPath = path4.join(skillDir, STANDARD_FILES.METADATA_YAML);
+    if (!await fileExists(metadataPath)) {
+      const displayPath = pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`;
+      warn(
+        `Skill '${skillDirName}' in '${displayPath}' is missing ${STANDARD_FILES.METADATA_YAML} \u2014 skipped. Add ${STANDARD_FILES.METADATA_YAML} to register it with the CLI.`
+      );
+      continue;
+    }
+    try {
+      const content = await readFile(skillPath);
+      const frontmatter = parseFrontmatter(content, skillPath);
+      if (!frontmatter?.name) {
+        warn(`Skipping skill in '${skillDirName}': missing or invalid frontmatter name`);
+        continue;
+      }
+      const canonicalId = frontmatter.name;
+      const skill = {
+        id: canonicalId,
+        path: pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`,
+        description: frontmatter?.description || ""
+      };
+      skills[canonicalId] = skill;
+      verbose(`  Loaded skill: ${canonicalId}`);
+    } catch (error) {
+      verbose(`  Failed to load skill: ${skillFile} - ${error}`);
+    }
+  }
+  return skills;
+}
+async function discoverLocalProjectSkills(projectDir) {
+  const localSkillsDir = path4.join(projectDir, LOCAL_SKILLS_PATH);
+  return loadSkillsFromDir(localSkillsDir, LOCAL_SKILLS_PATH);
+}
+function mergeSkills(...skillSources) {
+  const merged = {};
+  for (const source of skillSources) {
+    for (const [id, skill] of typedEntries(source)) {
+      if (skill) {
+        merged[id] = skill;
+      }
+    }
+  }
+  return merged;
+}
+async function discoverInstalledSkills(projectDir) {
+  const isGlobalProject = projectDir === os5.homedir();
+  const globalPluginSkills = isGlobalProject ? {} : await discoverAllPluginSkills(os5.homedir());
+  const globalPluginSkillCount = typedKeys(globalPluginSkills).length;
+  if (globalPluginSkillCount > 0) {
+    verbose(`  Found ${globalPluginSkillCount} skills from global plugins`);
+  }
+  const globalLocalSkillsDir = path4.join(GLOBAL_INSTALL_ROOT, LOCAL_SKILLS_PATH);
+  const globalLocalSkills = isGlobalProject ? {} : await loadSkillsFromDir(globalLocalSkillsDir, LOCAL_SKILLS_PATH);
+  const globalLocalSkillCount = typedKeys(globalLocalSkills).length;
+  if (globalLocalSkillCount > 0) {
+    verbose(`  Found ${globalLocalSkillCount} global local skills from ~/.claude/skills/`);
+  }
+  const pluginSkills = await discoverAllPluginSkills(projectDir);
+  const pluginSkillCount = typedKeys(pluginSkills).length;
+  verbose(`  Found ${pluginSkillCount} skills from installed plugins`);
+  const localSkills = await discoverLocalProjectSkills(projectDir);
+  const localSkillCount = typedKeys(localSkills).length;
+  verbose(`  Found ${localSkillCount} local skills from .claude/skills/`);
+  const allSkills = mergeSkills(globalPluginSkills, globalLocalSkills, pluginSkills, localSkills);
+  const totalSkillCount = typedKeys(allSkills).length;
+  return {
+    allSkills,
+    totalSkillCount,
+    pluginSkillCount: globalPluginSkillCount + pluginSkillCount,
+    localSkillCount: globalLocalSkillCount + localSkillCount,
+    globalPluginSkillCount,
+    globalLocalSkillCount
+  };
+}
+
+// src/cli/lib/operations/find-skill-match.ts
+init_esm_shims();
+function findSkillMatch(skillName, results) {
+  const exact = results.find((r) => r.id === skillName);
+  if (exact) return { match: exact, similar: [] };
+  const partial = results.find((r) => {
+    const nameWithoutAuthor = r.id.replace(/\s*\(@\w+\)$/, "").toLowerCase();
+    return nameWithoutAuthor === skillName.toLowerCase();
+  });
+  if (partial) return { match: partial, similar: [] };
+  const byDir = results.find((r) => r.dirName.toLowerCase() === skillName.toLowerCase());
+  if (byDir) return { match: byDir, similar: [] };
+  const lowered = skillName.toLowerCase();
+  const similar = results.filter((r) => {
+    const name = r.id.toLowerCase();
+    const dir = r.dirName.toLowerCase();
+    return name.includes(lowered) || dir.includes(lowered) || lowered.includes(name.split(" ")[0]);
+  }).map((r) => r.id).slice(0, 3);
+  return { match: null, similar };
+}
+
+// node_modules/chalk/source/index.js
+init_esm_shims();
+
+// node_modules/chalk/source/vendor/ansi-styles/index.js
+init_esm_shims();
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// node_modules/chalk/source/vendor/supports-color/index.js
+init_esm_shims();
+import process2 from "process";
+import os6 from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os6.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/chalk/source/utilities.js
+init_esm_shims();
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/cli/lib/operations/generate-skill-diff.ts
+init_esm_shims();
+import path5 from "path";
+import { createTwoFilesPatch } from "diff";
+async function generateSkillDiff(localSkillsPath, skillDirName, sourcePath, sourceSkills) {
+  const skillDir = path5.join(localSkillsPath, skillDirName);
+  const forkedFrom = await readForkedFromMetadata(skillDir);
+  if (!forkedFrom) {
+    return {
+      skillDirName,
+      forkedFrom: null,
+      hasDiff: false,
+      diffOutput: ""
+    };
+  }
+  const sourceSkill = sourceSkills[forkedFrom.skillId];
+  if (!sourceSkill) {
+    return {
+      skillDirName,
+      forkedFrom,
+      hasDiff: false,
+      diffOutput: `Source skill '${forkedFrom.skillId}' no longer exists`
+    };
+  }
+  const sourceSkillMdPath = path5.join(sourcePath, "src", sourceSkill.path, STANDARD_FILES.SKILL_MD);
+  if (!await fileExists(sourceSkillMdPath)) {
+    return {
+      skillDirName,
+      forkedFrom,
+      hasDiff: false,
+      diffOutput: `Source ${STANDARD_FILES.SKILL_MD} not found at ${sourceSkillMdPath}`
+    };
+  }
+  const sourceContent = await readFile(sourceSkillMdPath);
+  const localSkillMdPath = path5.join(skillDir, STANDARD_FILES.SKILL_MD);
+  if (!await fileExists(localSkillMdPath)) {
+    return {
+      skillDirName,
+      forkedFrom,
+      hasDiff: false,
+      diffOutput: `Local ${STANDARD_FILES.SKILL_MD} not found at ${localSkillMdPath}`
+    };
+  }
+  const localContent = await readFile(localSkillMdPath);
+  const sourceLabel = `source/${sourceSkill.path}/SKILL.md`;
+  const localLabel = `local/${LOCAL_SKILLS_PATH}/${skillDirName}/SKILL.md`;
+  const diff = createTwoFilesPatch(
+    sourceLabel,
+    localLabel,
+    sourceContent,
+    localContent,
+    "",
+    // No source header
+    ""
+    // No local header
+  );
+  const hasDiff = diff.split("\n").some((line) => {
+    return (line.startsWith("+") || line.startsWith("-")) && !line.startsWith("+++") && !line.startsWith("---");
+  });
+  return {
+    skillDirName,
+    forkedFrom,
+    hasDiff,
+    diffOutput: diff
+  };
+}
+function formatColoredDiff(diffText) {
+  return diffText.split("\n").map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      return source_default.bold(line);
+    }
+    if (line.startsWith("+")) {
+      return source_default.green(line);
+    }
+    if (line.startsWith("-")) {
+      return source_default.red(line);
+    }
+    if (line.startsWith("@@")) {
+      return source_default.cyan(line);
+    }
+    return line;
+  }).join("\n");
+}
+
+// src/cli/lib/operations/resolve-skill-info.ts
+init_esm_shims();
+import path6 from "path";
+var CONTENT_PREVIEW_LINES = 10;
+var MAX_LINE_LENGTH = 80;
+var MAX_SUGGESTIONS = 5;
+function stripFrontmatter(content) {
+  const lines = content.split("\n");
+  let inFrontmatter = false;
+  let frontmatterEndIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "---") {
+      if (!inFrontmatter) {
+        inFrontmatter = true;
+      } else {
+        frontmatterEndIndex = i + 1;
+        break;
+      }
+    }
+  }
+  return lines.slice(frontmatterEndIndex).join("\n");
+}
+function getPreviewLines(content, maxLines) {
+  const body = stripFrontmatter(content);
+  const lines = body.split("\n");
+  const result = [];
+  for (const line of lines) {
+    if (result.length >= maxLines) break;
+    if (line.trim() || result.length > 0) {
+      result.push(truncateText(line, MAX_LINE_LENGTH));
+    }
+  }
+  return result;
+}
+function findSuggestions(skills, query, maxSuggestions) {
+  const lowerQuery = query.toLowerCase();
+  const matches = [];
+  for (const skill of Object.values(skills)) {
+    if (!skill) continue;
+    if (matches.length >= maxSuggestions) break;
+    if (skill.id.toLowerCase().includes(lowerQuery) || skill.displayName.toLowerCase().includes(lowerQuery) || skill.slug.toLowerCase().includes(lowerQuery)) {
+      matches.push(skill.id);
+    }
+  }
+  return matches;
+}
+async function resolveSkillInfo(options) {
+  const { query, skills, slugToId, projectDir, sourcePath, isLocal, includePreview } = options;
+  const slugResolvedId = slugToId[query];
+  const skill = skills[query] ?? (slugResolvedId ? skills[slugResolvedId] : void 0);
+  if (!skill) {
+    const suggestions = findSuggestions(skills, query, MAX_SUGGESTIONS);
+    return { resolved: null, suggestions };
+  }
+  const localSkillsResult = await discoverLocalSkills(projectDir);
+  const localSkillIds = localSkillsResult?.skills.map((s) => s.id) || [];
+  const isInstalled = localSkillIds.includes(skill.id);
+  let preview = [];
+  if (includePreview) {
+    let skillMdPath;
+    if (skill.local && skill.localPath) {
+      skillMdPath = path6.join(projectDir, skill.localPath, STANDARD_FILES.SKILL_MD);
+    } else {
+      const sourceDir = isLocal ? sourcePath : path6.dirname(sourcePath);
+      skillMdPath = path6.join(sourceDir, skill.path, STANDARD_FILES.SKILL_MD);
+    }
+    if (await fileExists(skillMdPath)) {
+      const content = await readFile(skillMdPath);
+      preview = getPreviewLines(content, CONTENT_PREVIEW_LINES);
+    }
+  }
+  return {
+    resolved: { skill, isInstalled, preview },
+    suggestions: []
+  };
+}
+
+// src/cli/lib/operations/eject-project.ts
+init_esm_shims();
+import path7 from "path";
+async function ejectAgentPartials(options) {
+  const { outputBase, force, directOutput = false, templatesOnly = false } = options;
+  const sourceDir = templatesOnly ? path7.join(PROJECT_ROOT, DIRS.templates) : path7.join(PROJECT_ROOT, DIRS.agents);
+  if (!await directoryExists(sourceDir)) {
+    return {
+      skipped: true,
+      skipReason: templatesOnly ? "No agent templates found in CLI." : "No agent partials found in CLI.",
+      templatesSkipped: false
+    };
+  }
+  const destDir = directOutput ? outputBase : templatesOnly ? path7.join(outputBase, path7.basename(DIRS.agents), path7.basename(DIRS.templates)) : path7.join(outputBase, path7.basename(DIRS.agents));
+  const templatesBasename = path7.basename(DIRS.templates);
+  if (await directoryExists(destDir) && !force) {
+    if (templatesOnly) {
+      return {
+        skipped: true,
+        skipReason: `Agent templates already exist at ${destDir}. Use --force to overwrite.`,
+        templatesSkipped: false
+      };
+    }
+    const hasTemplates = await directoryExists(path7.join(destDir, templatesBasename));
+    if (await hasAgentPartialDirs(destDir) && !hasTemplates) {
+      return {
+        skipped: true,
+        skipReason: `Agent partials already exist at ${destDir}. Use --force to overwrite.`,
+        templatesSkipped: false
+      };
+    }
+  }
+  await ensureDir(destDir);
+  const skipTemplates = !templatesOnly && !force && await directoryExists(path7.join(destDir, templatesBasename));
+  if (skipTemplates) {
+    const sourceEntries = await listDirectories(sourceDir);
+    const nonTemplateEntries = sourceEntries.filter((entry) => entry !== templatesBasename);
+    for (const entry of nonTemplateEntries) {
+      await copy(path7.join(sourceDir, entry), path7.join(destDir, entry));
+    }
+  } else {
+    await copy(sourceDir, destDir);
+  }
+  return {
+    skipped: false,
+    destDir,
+    templatesSkipped: skipTemplates
+  };
+}
+async function ejectSkills(options) {
+  const {
+    projectDir,
+    force,
+    sourceResult,
+    matrix,
+    directOutput = false,
+    customOutputBase
+  } = options;
+  const destDir = directOutput && customOutputBase ? customOutputBase : path7.join(projectDir, LOCAL_SKILLS_PATH);
+  if (await directoryExists(destDir) && !force) {
+    return {
+      skipped: true,
+      skipReason: `Skills already exist at ${destDir}. Use --force to overwrite.`,
+      copiedSkills: []
+    };
+  }
+  const skillIds = typedKeys(matrix.skills).filter(
+    (skillId) => !matrix.skills[skillId]?.local
+  );
+  if (skillIds.length === 0) {
+    return {
+      skipped: true,
+      skipReason: "No skills found in source to eject.",
+      copiedSkills: []
+    };
+  }
+  await ensureDir(destDir);
+  const copiedSkills = await copySkillsToLocalFlattened(skillIds, destDir, matrix, sourceResult);
+  const sourceLabel = sourceResult.isLocal ? sourceResult.sourcePath : sourceResult.marketplace || sourceResult.sourceConfig.source;
+  return {
+    skipped: false,
+    copiedSkills,
+    destDir,
+    sourceLabel
+  };
+}
+async function ensureMinimalConfig(options) {
+  const { projectDir, sourceFlag, sourceResult } = options;
+  const tsConfigPath = path7.join(projectDir, CLAUDE_SRC_DIR, STANDARD_FILES.CONFIG_TS);
+  if (await fileExists(tsConfigPath)) {
+    return { configPath: tsConfigPath, created: false };
+  }
+  const projectName = path7.basename(projectDir);
+  const config = {
+    name: projectName
+  };
+  const resolvedConfig = sourceResult?.sourceConfig ?? await resolveSource(sourceFlag, projectDir);
+  if (sourceFlag) {
+    config.source = sourceFlag;
+  } else if (resolvedConfig.source) {
+    config.source = resolvedConfig.source;
+  }
+  if (resolvedConfig.marketplace) {
+    config.marketplace = resolvedConfig.marketplace;
+  }
+  const existingProjectConfig = await loadProjectSourceConfig(projectDir);
+  if (existingProjectConfig?.author) {
+    config.author = existingProjectConfig.author;
+  }
+  if (existingProjectConfig?.agentsSource) {
+    config.agentsSource = existingProjectConfig.agentsSource;
+  }
+  await ensureDir(path7.join(projectDir, CLAUDE_SRC_DIR));
+  const cleaned = JSON.parse(JSON.stringify(config));
+  const body = JSON.stringify(cleaned, null, 2);
+  const content = `export default ${body};
+`;
+  await writeFile(tsConfigPath, content);
+  return { configPath: tsConfigPath, created: true };
+}
+async function hasAgentPartialDirs(agentsDir) {
+  const subdirs = await listDirectories(agentsDir);
+  const templatesBasename = path7.basename(DIRS.templates);
+  return subdirs.some((dir) => dir !== templatesBasename);
+}
+
+// src/cli/lib/operations/uninstall-project.ts
+init_esm_shims();
+import path8 from "path";
+import { readdir } from "fs/promises";
+function collectConfiguredAgents(config) {
+  if (!config?.agents) return [];
+  return config.agents.map((a) => a.name);
+}
+function getCliInstalledPluginKeys(config) {
+  if (!config?.skills) return /* @__PURE__ */ new Set();
+  return new Set(config.skills.map((skill) => `${skill.id}@${skill.source}`));
+}
+async function detectUninstallTarget(projectDir) {
+  const pluginsDir = getProjectPluginsDir(projectDir);
+  const skillsDir = path8.join(projectDir, CLAUDE_DIR, "skills");
+  const agentsDir = path8.join(projectDir, CLAUDE_DIR, "agents");
+  const claudeDir = path8.join(projectDir, CLAUDE_DIR);
+  const claudeSrcDir = path8.join(projectDir, CLAUDE_SRC_DIR);
+  const [hasLocalSkills, hasLocalAgents, hasClaudeDir, hasClaudeSrcDir, config] = await Promise.all(
+    [
+      directoryExists(skillsDir),
+      directoryExists(agentsDir),
+      directoryExists(claudeDir),
+      directoryExists(claudeSrcDir),
+      loadProjectConfigFromDir(projectDir).then((result) => result?.config ?? null)
+    ]
+  );
+  let pluginNames = [];
+  try {
+    pluginNames = await listPluginNames(projectDir);
+  } catch {
+  }
+  const configuredAgents = collectConfiguredAgents(config);
+  const cliInstalledKeys = getCliInstalledPluginKeys(config);
+  const cliPluginNames = pluginNames.filter((name) => cliInstalledKeys.has(name));
+  return {
+    hasPlugins: cliPluginNames.length > 0,
+    pluginNames,
+    cliPluginNames,
+    hasLocalSkills,
+    hasLocalAgents,
+    hasClaudeDir,
+    hasClaudeSrcDir,
+    pluginsDir,
+    skillsDir,
+    agentsDir,
+    claudeDir,
+    claudeSrcDir,
+    config,
+    configuredAgents
+  };
+}
+function shouldRemoveSkill(forkedFrom) {
+  return forkedFrom !== null;
+}
+async function removeMatchingSkills(target, onRemoved, onSkipped) {
+  if (!target.hasLocalSkills) {
+    return {
+      removedCount: 0,
+      skippedCount: 0,
+      removedNames: [],
+      skippedNames: [],
+      dirCleaned: false
+    };
+  }
+  const skillDirNames = await listDirectories(target.skillsDir);
+  const removedNames = [];
+  const skippedNames = [];
+  for (const skillDirName of skillDirNames) {
+    const skillDir = path8.join(target.skillsDir, skillDirName);
+    const forkedFrom = await readForkedFromMetadata(skillDir);
+    if (shouldRemoveSkill(forkedFrom)) {
+      await remove(skillDir);
+      removedNames.push(skillDirName);
+      onRemoved?.(skillDirName);
+    } else {
+      skippedNames.push(skillDirName);
+      onSkipped?.(skillDirName);
+    }
+  }
+  let dirCleaned = false;
+  if (skippedNames.length === 0 && await directoryExists(target.skillsDir)) {
+    if (await isDirectoryEmpty(target.skillsDir)) {
+      await remove(target.skillsDir);
+      dirCleaned = true;
+    }
+  }
+  return {
+    removedCount: removedNames.length,
+    skippedCount: skippedNames.length,
+    removedNames,
+    skippedNames,
+    dirCleaned
+  };
+}
+async function removeMatchingAgents(target, onRemoved) {
+  if (!target.hasLocalAgents) {
+    return { removedCount: 0, removedNames: [], dirCleaned: false };
+  }
+  if (target.configuredAgents.length === 0) {
+    return { removedCount: 0, removedNames: [], dirCleaned: false };
+  }
+  const agentFiles = await listAgentFiles(target.agentsDir);
+  const removedNames = [];
+  for (const agentFile of agentFiles) {
+    const agentName = agentFile.replace(/\.md$/, "");
+    if (!target.configuredAgents.includes(agentName)) continue;
+    await remove(path8.join(target.agentsDir, agentFile));
+    removedNames.push(agentName);
+    onRemoved?.(agentName);
+  }
+  let dirCleaned = false;
+  if (await directoryExists(target.agentsDir)) {
+    if (await isDirectoryEmpty(target.agentsDir)) {
+      await remove(target.agentsDir);
+      dirCleaned = true;
+    }
+  }
+  return {
+    removedCount: removedNames.length,
+    removedNames,
+    dirCleaned
+  };
+}
+async function uninstallPlugins(target, projectDir, onUninstalled) {
+  if (!target.hasPlugins) {
+    return { uninstalledNames: [], totalUninstalled: 0 };
+  }
+  const cliAvailable = await isClaudeCLIAvailable();
+  const uninstalledNames = [];
+  for (const pluginName of target.cliPluginNames) {
+    if (cliAvailable) {
+      try {
+        const skillId = pluginName.split("@")[0];
+        const skillConfig = target.config?.skills?.find((s) => s.id === skillId);
+        const pluginScope = skillConfig?.scope === "global" ? "user" : "project";
+        await claudePluginUninstall(pluginName, pluginScope, projectDir);
+      } catch {
+      }
+    }
+    const pluginPath = path8.join(target.pluginsDir, pluginName);
+    await remove(pluginPath);
+    uninstalledNames.push(pluginName);
+    onUninstalled?.(pluginName);
+  }
+  return {
+    uninstalledNames,
+    totalUninstalled: uninstalledNames.length
+  };
+}
+async function cleanupEmptyDirs(target, removeAll) {
+  let claudeSrcDirRemoved = false;
+  if (removeAll && target.hasClaudeSrcDir) {
+    await remove(target.claudeSrcDir);
+    claudeSrcDirRemoved = true;
+  }
+  let claudeDirRemoved = false;
+  let claudeDirKept = false;
+  if (target.hasClaudeDir && await directoryExists(target.claudeDir)) {
+    if (await isDirectoryEmpty(target.claudeDir)) {
+      await remove(target.claudeDir);
+      claudeDirRemoved = true;
+    } else {
+      claudeDirKept = true;
+    }
+  }
+  return { claudeDirRemoved, claudeSrcDirRemoved, claudeDirKept };
+}
+async function isDirectoryEmpty(dirPath) {
+  try {
+    const allEntries = await readdir(dirPath);
+    return allEntries.length === 0;
+  } catch {
+    return true;
+  }
+}
+async function listAgentFiles(agentsDir) {
+  try {
+    return (await readdir(agentsDir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+}
+
+// src/cli/lib/operations/search-skills.ts
+init_esm_shims();
+import path9 from "path";
+async function fetchSkillsFromExternalSource(source, forceRefresh) {
+  try {
+    const result = await fetchFromSource(source.url, { forceRefresh });
+    const skillsDir = path9.join(result.path, DEFAULT_SKILLS_SUBDIR);
+    if (!await fileExists(skillsDir)) {
+      return [];
+    }
+    const skillDirs = await listDirectories(skillsDir);
+    const skills = [];
+    for (const skillDir of skillDirs) {
+      const skillMdPath = path9.join(skillsDir, skillDir, STANDARD_FILES.SKILL_MD);
+      if (!await fileExists(skillMdPath)) continue;
+      const content = await readFile(skillMdPath);
+      const frontmatter = parseFrontmatter(content, skillMdPath);
+      if (!frontmatter) continue;
+      skills.push({
+        id: frontmatter.name,
+        description: frontmatter.description,
+        // Boundary cast: directory name used as slug for third-party source skill
+        slug: skillDir,
+        displayName: skillDir,
+        // Boundary cast: external source skills have no real category; "imported" is a display-only placeholder
+        category: "imported",
+        author: `@${source.name}`,
+        conflictsWith: [],
+        isRecommended: false,
+        requires: [],
+        alternatives: [],
+        discourages: [],
+        compatibleWith: [],
+        sourceName: source.name,
+        sourceUrl: source.url,
+        path: path9.join(skillsDir, skillDir)
+      });
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function matchesQuery(skill, query) {
+  const lowerQuery = query.toLowerCase();
+  if (skill.id.toLowerCase().includes(lowerQuery)) return true;
+  if (skill.displayName.toLowerCase().includes(lowerQuery)) return true;
+  if (skill.slug.toLowerCase().includes(lowerQuery)) return true;
+  if (skill.description.toLowerCase().includes(lowerQuery)) return true;
+  if (skill.category.toLowerCase().includes(lowerQuery)) return true;
+  return false;
+}
+function matchesCategory(skill, category) {
+  const lowerCategory = category.toLowerCase();
+  return skill.category.toLowerCase().includes(lowerCategory);
+}
+function filterSkillsByQuery(skills, options) {
+  let results = skills.filter((skill) => matchesQuery(skill, options.query));
+  if (options.category) {
+    results = results.filter((skill) => matchesCategory(skill, options.category));
+  }
+  return results;
+}
+function toSourcedSkill(skill, sourceName, sourceUrl) {
+  return {
+    ...skill,
+    sourceName,
+    sourceUrl
+  };
+}
+async function copySearchedSkillsToLocal(skills, projectDir) {
+  const destDir = path9.join(projectDir, LOCAL_SKILLS_PATH);
+  const results = [];
+  for (const skill of skills) {
+    if (skill.path) {
+      const destPath = path9.join(destDir, skill.id);
+      await ensureDir(path9.dirname(destPath));
+      await copy(skill.path, destPath);
+      results.push({ id: skill.id, copied: true });
+    } else {
+      results.push({ id: skill.id, copied: false, reason: "No source path available" });
+    }
+  }
+  return results;
+}
+
+// src/cli/lib/operations/scaffold-agent.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import matter from "gray-matter";
+import path10 from "path";
+var META_AGENT_NAME = "agent-summoner";
+function parseCompiledAgent(content) {
+  const { data: frontmatter, content: body } = matter(content);
+  const tools = typeof frontmatter.tools === "string" ? frontmatter.tools.split(",").map((t) => t.trim()) : frontmatter.tools;
+  return {
+    description: frontmatter.description || "Creates new agents",
+    prompt: body.trim(),
+    model: frontmatter.model,
+    tools
+  };
+}
+async function loadMetaAgent(options) {
+  const { projectDir, source, forceRefresh } = options;
+  const compiledFileName = `${META_AGENT_NAME}.md`;
+  const localAgentPath = path10.join(projectDir, CLAUDE_DIR, "agents", compiledFileName);
+  if (await fileExists(localAgentPath)) {
+    return parseCompiledAgent(await readFile(localAgentPath));
+  }
+  try {
+    const agentPaths = await getAgentDefinitions(source, { forceRefresh, projectDir });
+    const remoteAgentPath = path10.join(
+      agentPaths.sourcePath,
+      CLAUDE_DIR,
+      "agents",
+      compiledFileName
+    );
+    if (await fileExists(remoteAgentPath)) {
+      return parseCompiledAgent(await readFile(remoteAgentPath));
+    }
+  } catch {
+  }
+  throw new Error(
+    `Agent '${META_AGENT_NAME}' not found.
+
+Run 'compile' first to generate agents.`
+  );
+}
+function buildAgentPrompt(agentName, purpose, outputDir) {
+  return `Create a new Claude Code agent named "${agentName}" in the directory "${outputDir}".
+
+Agent Purpose: ${purpose}
+
+Requirements:
+1. Create the agent directory structure at ${outputDir}/${agentName}/
+2. Create metadata.yaml with appropriate configuration
+3. Create intro.md with the agent's role and context
+4. Create workflow.md with the agent's operational process
+5. Optionally create examples.md if relevant examples would help
+6. Optionally create critical-requirements.md for important rules
+7. Include \`custom: true\` in the metadata.yaml configuration
+
+Follow the existing agent patterns in the codebase. Keep the agent focused and practical.`;
+}
+async function invokeMetaAgent(options) {
+  const { agentDef, prompt, nonInteractive } = options;
+  const agentsJson = JSON.stringify({
+    [META_AGENT_NAME]: {
+      description: agentDef.description,
+      prompt: agentDef.prompt,
+      model: agentDef.model,
+      tools: agentDef.tools
+    }
+  });
+  const args = ["--agents", agentsJson, "--agent", META_AGENT_NAME];
+  if (nonInteractive) {
+    args.push("-p", prompt);
+  } else {
+    args.push("--prompt", prompt);
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn("claude", args, {
+      stdio: "inherit"
+    });
+    child.on("error", (error) => {
+      reject(new Error(`Failed to spawn claude CLI: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Claude CLI exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/cli/lib/operations/migrate-plugin-scope.ts
+init_esm_shims();
+async function migratePluginSkillScopes(scopeChanges, skills, marketplace, projectDir) {
+  const migrated = [];
+  const failed = [];
+  for (const [skillId, change] of scopeChanges) {
+    const skillConfig = skills.find((s) => s.id === skillId);
+    if (!skillConfig || skillConfig.source === "local") {
+      continue;
+    }
+    const oldPluginScope = change.from === "global" ? "user" : "project";
+    const newPluginScope = change.to === "global" ? "user" : "project";
+    const pluginRef = `${skillId}@${marketplace}`;
+    try {
+      await claudePluginUninstall(skillId, oldPluginScope, projectDir);
+      await claudePluginInstall(pluginRef, newPluginScope, projectDir);
+      migrated.push(skillId);
+    } catch (error) {
+      failed.push({ id: skillId, error: getErrorMessage(error) });
+    }
+  }
+  return { migrated, failed };
+}
+
+// src/cli/lib/operations/index.ts
+init_esm_shims();
+
+export {
+  detectBothInstallations,
+  loadSource,
+  getDashboardData,
+  detectProject,
+  loadAgentDefs,
+  copyLocalSkills,
+  installPluginSkills,
+  uninstallPluginSkills,
+  collectScopedSkillDirs,
+  buildSourceSkillsMap,
+  compareSkillsWithSource,
+  ensureMarketplace,
+  writeProjectConfig,
+  compileAgents,
+  detectConfigChanges,
+  updateLocalSkills,
+  discoverInstalledSkills,
+  findSkillMatch,
+  source_default,
+  generateSkillDiff,
+  formatColoredDiff,
+  resolveSkillInfo,
+  ejectAgentPartials,
+  ejectSkills,
+  ensureMinimalConfig,
+  detectUninstallTarget,
+  removeMatchingSkills,
+  removeMatchingAgents,
+  uninstallPlugins,
+  cleanupEmptyDirs,
+  fetchSkillsFromExternalSource,
+  filterSkillsByQuery,
+  toSourcedSkill,
+  copySearchedSkillsToLocal,
+  loadMetaAgent,
+  buildAgentPrompt,
+  invokeMetaAgent,
+  migratePluginSkillScopes
+};
+//# sourceMappingURL=chunk-DCVCFBQ7.js.map