@agents-inc/cli 0.85.0 → 0.87.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ Each release has detailed notes in its own file under [`changelogs/`](./changelo
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.87.0] - 2026-03-26
+
+**Declarative commands, operation dissolution, global skill discovery fix**
+
+- 14 commands restructured with declarative two-tier pattern — `run()` reads like pseudocode
+- 12 single-use operations dissolved back into their respective commands; operations layer trimmed to 17 shared files
+- Fix: init/edit/update now discover all skills (global + project) before compiling agents
+
+See [changelogs/0.87.0.md](./changelogs/0.87.0.md) for full details.
+
+## [0.86.0] - 2026-03-26
+
+**Operations layer — composable building blocks for all CLI commands**
+
+- 26 typed operations extracted from 15 commands into `src/cli/lib/operations/` (D-145)
+- All commands refactored to use operations layer; compile.ts reduced 40%, uninstall.tsx 39%, import/skill.ts 47%
+- Shared utilities: `truncateText()`, `warn({ suppressInTest })`, `buildSourceSkillsMap()`
+
+See [changelogs/0.86.0.md](./changelogs/0.86.0.md) for full details.
+
 ## [0.85.0] - 2026-03-25
 
 **Exclusive incompatibility markers, filter deselection, declarative test data**

package/dist/{chunk-6VGBO6SZ.js → chunk-5M6Q5UQO.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-4QA5TIBU.js";
 import {
   useWizardStore
-} from "./chunk-2XVLQDNI.js";
+} from "./chunk-HSLVCKVQ.js";
 import {
   matrix
 } from "./chunk-ANXHMG32.js";
@@ -191,4 +191,4 @@ var StackSelection = ({ onCancel }) => {
 export {
   StackSelection
 };
-//# sourceMappingURL=chunk-6VGBO6SZ.js.map
+//# sourceMappingURL=chunk-5M6Q5UQO.js.map

package/dist/chunk-5UJJQFET.js

@@ -0,0 +1,564 @@
+#!/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,
+  detectGlobalInstallation,
+  detectInstallation,
+  detectProjectInstallation,
+  discoverAllPluginSkills,
+  discoverLocalSkills,
+  ensureBlankGlobalConfig,
+  fetchMarketplace,
+  loadProjectConfig,
+  loadProjectConfigFromDir,
+  loadSkillsMatrixFromSource,
+  resolveInstallPaths,
+  writeScopedConfigs
+} from "./chunk-TMTUTUEV.js";
+import {
+  loadAllAgents,
+  parseFrontmatter
+} from "./chunk-B6MYECV6.js";
+import {
+  typedEntries,
+  typedKeys
+} from "./chunk-ANXHMG32.js";
+import {
+  directoryExists,
+  disableBuffering,
+  drainBuffer,
+  enableBuffering,
+  ensureDir,
+  fileExists,
+  getErrorMessage,
+  glob,
+  listDirectories,
+  readFile,
+  verbose,
+  warn
+} from "./chunk-NUU3U43A.js";
+import {
+  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/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/discover-skills.ts
+init_esm_shims();
+import os5 from "os";
+import path3 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 = path3.join(skillsDir, skillFile);
+    const skillDir = path3.dirname(skillPath);
+    const relativePath = path3.relative(skillsDir, skillDir);
+    const skillDirName = path3.basename(skillDir);
+    const metadataPath = path3.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 = path3.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 = path3.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 };
+}
+
+// src/cli/lib/operations/resolve-skill-info.ts
+init_esm_shims();
+import path4 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 = path4.join(projectDir, skill.localPath, STANDARD_FILES.SKILL_MD);
+    } else {
+      const sourceDir = isLocal ? sourcePath : path4.dirname(sourcePath);
+      skillMdPath = path4.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/index.ts
+init_esm_shims();
+
+export {
+  detectBothInstallations,
+  loadSource,
+  detectProject,
+  loadAgentDefs,
+  copyLocalSkills,
+  installPluginSkills,
+  uninstallPluginSkills,
+  collectScopedSkillDirs,
+  buildSourceSkillsMap,
+  compareSkillsWithSource,
+  ensureMarketplace,
+  writeProjectConfig,
+  compileAgents,
+  discoverInstalledSkills,
+  findSkillMatch,
+  resolveSkillInfo
+};
+//# sourceMappingURL=chunk-5UJJQFET.js.map