@agents-inc/cli 0.86.0 → 0.87.0

package/dist/chunk-DCVCFBQ7.js

@@ -1,1800 +0,0 @@
-#!/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