@cleocode/caamp 0.4.1 → 0.5.1

package/dist/{chunk-6HQDRJLS.js → chunk-YCSZGZ5W.js}

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/core/paths/standard.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
@@ -70,6 +76,33 @@ function getCanonicalSkillsDir() {
 function getLockFilePath() {
   return join(getAgentsHome(), ".caamp-lock.json");
 }
+function getAgentsMcpDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "mcp");
+  return join(projectDir ?? process.cwd(), ".agents", "mcp");
+}
+function getAgentsMcpServersPath(scope = "global", projectDir) {
+  return join(getAgentsMcpDir(scope, projectDir), "servers.json");
+}
+function getAgentsInstructFile(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "AGENTS.md");
+  return join(projectDir ?? process.cwd(), ".agents", "AGENTS.md");
+}
+function getAgentsConfigPath(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "config.toml");
+  return join(projectDir ?? process.cwd(), ".agents", "config.toml");
+}
+function getAgentsWikiDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "wiki");
+  return join(projectDir ?? process.cwd(), ".agents", "wiki");
+}
+function getAgentsSpecDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "spec");
+  return join(projectDir ?? process.cwd(), ".agents", "spec");
+}
+function getAgentsLinksDir(scope = "global", projectDir) {
+  if (scope === "global") return join(getAgentsHome(), "links");
+  return join(projectDir ?? process.cwd(), ".agents", "links");
+}
 function resolveRegistryTemplatePath(template) {
   const locations = getPlatformLocations();
   return template.replace(/\$HOME/g, locations.home).replace(/\$CONFIG/g, locations.config).replace(/\$VSCODE_CONFIG/g, locations.vscodeConfig).replace(/\$ZED_CONFIG/g, locations.zedConfig).replace(/\$CLAUDE_DESKTOP_CONFIG/g, locations.claudeDesktopConfig).replace(/\$AGENTS_HOME/g, getAgentsHome());
@@ -205,16 +238,17 @@ function ensureProviders() {
 }
 function getAllProviders() {
   ensureProviders();
+  if (!_providers) return [];
   return Array.from(_providers.values());
 }
 function getProvider(idOrAlias) {
   ensureProviders();
-  const resolved = _aliasMap.get(idOrAlias) ?? idOrAlias;
-  return _providers.get(resolved);
+  const resolved = _aliasMap?.get(idOrAlias) ?? idOrAlias;
+  return _providers?.get(resolved);
 }
 function resolveAlias(idOrAlias) {
   ensureProviders();
-  return _aliasMap.get(idOrAlias) ?? idOrAlias;
+  return _aliasMap?.get(idOrAlias) ?? idOrAlias;
 }
 function getProvidersByPriority(priority) {
   return getAllProviders().filter((p) => p.priority === priority);
@@ -234,7 +268,7 @@ function getInstructionFiles() {
 }
 function getProviderCount() {
   ensureProviders();
-  return _providers.size;
+  return _providers?.size ?? 0;
 }
 function getRegistryVersion() {
   return loadRegistry().version;
@@ -411,13 +445,15 @@ function inferName(source, type) {
       const url = new URL(source);
       const parts = url.hostname.split(".");
       if (parts.length >= 2) {
-        const brand = parts.length === 3 ? parts[parts.length - 2] : parts[0];
+        const fallback = parts[0] ?? source;
+        const secondLevel = parts[parts.length - 2] ?? fallback;
+        const brand = parts.length === 3 ? secondLevel : fallback;
         if (brand !== "www" && brand !== "api" && brand !== "mcp") {
           return brand;
         }
-        return parts[parts.length - 2] ?? parts[0];
+        return secondLevel;
       }
-      return parts[0];
+      return parts[0] ?? source;
     } catch {
       return source;
     }
@@ -434,6 +470,11 @@ function inferName(source, type) {
     const match = source.match(/\/([^/]+?)(?:\.git)?$/);
     return match?.[1] ?? source;
   }
+  if (type === "local") {
+    const normalized = source.replace(/\\/g, "/").replace(/\/+$/, "");
+    const lastSegment = normalized.split("/").pop();
+    return lastSegment ?? source;
+  }
   if (type === "command") {
     const parts = source.split(/\s+/);
     const command = parts.find((p) => !p.startsWith("-") && p !== "npx" && p !== "node" && p !== "python" && p !== "python3");
@@ -444,24 +485,34 @@ function inferName(source, type) {
 function parseSource(input) {
   const ghUrlMatch = input.match(GITHUB_URL);
   if (ghUrlMatch) {
+    const owner = ghUrlMatch[1];
+    const repo = ghUrlMatch[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "github",
       value: input,
-      inferredName: ghUrlMatch[2],
-      owner: ghUrlMatch[1],
-      repo: ghUrlMatch[2],
+      inferredName: repo,
+      owner,
+      repo,
       ref: ghUrlMatch[3],
       path: ghUrlMatch[4]
     };
   }
   const glUrlMatch = input.match(GITLAB_URL);
   if (glUrlMatch) {
+    const owner = glUrlMatch[1];
+    const repo = glUrlMatch[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "gitlab",
       value: input,
-      inferredName: glUrlMatch[2],
-      owner: glUrlMatch[1],
-      repo: glUrlMatch[2],
+      inferredName: repo,
+      owner,
+      repo,
       ref: glUrlMatch[3],
       path: glUrlMatch[4]
     };
@@ -482,12 +533,17 @@ function parseSource(input) {
   }
   const ghShorthand = input.match(GITHUB_SHORTHAND);
   if (ghShorthand && !NPM_SCOPED.test(input)) {
+    const owner = ghShorthand[1];
+    const repo = ghShorthand[2];
+    if (!owner || !repo) {
+      return { type: "command", value: input, inferredName: inferName(input, "command") };
+    }
     return {
       type: "github",
-      value: `https://github.com/${ghShorthand[1]}/${ghShorthand[2]}`,
-      inferredName: ghShorthand[2],
-      owner: ghShorthand[1],
-      repo: ghShorthand[2],
+      value: `https://github.com/${owner}/${repo}`,
+      inferredName: repo,
+      owner,
+      repo,
       path: ghShorthand[3]
     };
   }
@@ -524,6 +580,9 @@ import { join as join3 } from "path";
 var AGENTS_HOME = getAgentsHome();
 var LOCK_FILE_PATH = getLockFilePath();
 var CANONICAL_SKILLS_DIR = getCanonicalSkillsDir();
+var AGENTS_MCP_DIR = getAgentsMcpDir();
+var AGENTS_MCP_SERVERS_PATH = getAgentsMcpServersPath();
+var AGENTS_CONFIG_PATH = getAgentsConfigPath();
 
 // src/core/skills/installer.ts
 async function ensureCanonicalDir() {
@@ -630,7 +689,7 @@ async function listCanonicalSkills() {
 }
 
 // src/core/lock-utils.ts
-import { open, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm as rm2, rename } from "fs/promises";
+import { open, readFile, writeFile, mkdir as mkdir2, rm as rm2, rename } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 var LOCK_GUARD_PATH = `${LOCK_FILE_PATH}.lock`;
 function sleep(ms) {
@@ -657,7 +716,7 @@ async function releaseLockGuard() {
 }
 async function writeLockFileUnsafe(lock) {
   const tmpPath = `${LOCK_FILE_PATH}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile2(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+  await writeFile(tmpPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
   await rename(tmpPath, LOCK_FILE_PATH);
 }
 async function readLockFile() {
@@ -665,7 +724,7 @@ async function readLockFile() {
     if (!existsSync4(LOCK_FILE_PATH)) {
       return { version: 1, skills: {}, mcpServers: {} };
     }
-    const content = await readFile2(LOCK_FILE_PATH, "utf-8");
+    const content = await readFile(LOCK_FILE_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, skills: {}, mcpServers: {} };
@@ -691,16 +750,16 @@ async function recordSkillInstall(skillName, scopedName, source, sourceType, age
     const existing = lock.skills[skillName];
     lock.skills[skillName] = {
       name: skillName,
-      scopedName,
-      source,
-      sourceType,
-      version,
+      scopedName: existing?.scopedName ?? scopedName,
+      source: existing?.source ?? source,
+      sourceType: existing?.sourceType ?? sourceType,
+      version: version ?? existing?.version,
       installedAt: existing?.installedAt ?? now,
       updatedAt: now,
       agents: [.../* @__PURE__ */ new Set([...existing?.agents ?? [], ...agents])],
       canonicalPath,
-      isGlobal,
-      projectDir
+      isGlobal: existing?.isGlobal ?? isGlobal,
+      projectDir: existing?.projectDir ?? projectDir
     };
   });
 }
@@ -1023,26 +1082,26 @@ var MarketplaceClient = class {
 };
 
 // src/core/skills/discovery.ts
-import { readFile as readFile3, readdir } from "fs/promises";
+import { readFile as readFile2, readdir } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { join as join4 } from "path";
 import matter from "gray-matter";
 async function parseSkillFile(filePath) {
   try {
-    const content = await readFile3(filePath, "utf-8");
+    const content = await readFile2(filePath, "utf-8");
     const { data } = matter(content);
-    if (!data["name"] || !data["description"]) {
+    if (!data.name || !data.description) {
       return null;
     }
-    const allowedTools = data["allowed-tools"] ?? data["allowedTools"];
+    const allowedTools = data["allowed-tools"] ?? data.allowedTools;
     return {
-      name: String(data["name"]),
-      description: String(data["description"]),
-      license: data["license"] ? String(data["license"]) : void 0,
-      compatibility: data["compatibility"] ? String(data["compatibility"]) : void 0,
-      metadata: data["metadata"],
+      name: String(data.name),
+      description: String(data.description),
+      license: data.license ? String(data.license) : void 0,
+      compatibility: data.compatibility ? String(data.compatibility) : void 0,
+      metadata: data.metadata,
       allowedTools: typeof allowedTools === "string" ? allowedTools.split(/\s+/) : Array.isArray(allowedTools) ? allowedTools.map(String) : void 0,
-      version: data["version"] ? String(data["version"]) : void 0
+      version: data.version ? String(data.version) : void 0
     };
   } catch {
     return null;
@@ -1089,6 +1148,135 @@ async function discoverSkillsMulti(dirs) {
   return all;
 }
 
+// src/core/skills/catalog.ts
+var catalog_exports = {};
+__export(catalog_exports, {
+  getCoreSkills: () => getCoreSkills,
+  getDispatchMatrix: () => getDispatchMatrix,
+  getLibraryRoot: () => getLibraryRoot,
+  getManifest: () => getManifest,
+  getProfile: () => getProfile,
+  getProtocolPath: () => getProtocolPath,
+  getSharedResourcePath: () => getSharedResourcePath,
+  getSkill: () => getSkill,
+  getSkillDependencies: () => getSkillDependencies,
+  getSkillDir: () => getSkillDir,
+  getSkillPath: () => getSkillPath,
+  getSkills: () => getSkills,
+  getSkillsByCategory: () => getSkillsByCategory,
+  getVersion: () => getVersion,
+  isCatalogAvailable: () => isCatalogAvailable,
+  listProfiles: () => listProfiles,
+  listProtocols: () => listProtocols,
+  listSharedResources: () => listSharedResources,
+  listSkills: () => listSkills,
+  readProtocol: () => readProtocol,
+  readSharedResource: () => readSharedResource,
+  readSkillContent: () => readSkillContent,
+  resolveDependencyTree: () => resolveDependencyTree,
+  resolveProfile: () => resolveProfile,
+  validateAll: () => validateAll,
+  validateSkillFrontmatter: () => validateSkillFrontmatter
+});
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var _ctSkills;
+function getCtSkills() {
+  if (!_ctSkills) {
+    try {
+      _ctSkills = require2("@cleocode/ct-skills");
+    } catch {
+      throw new Error(
+        "@cleocode/ct-skills is not installed. Run: npm install @cleocode/ct-skills"
+      );
+    }
+  }
+  return _ctSkills;
+}
+function getSkills() {
+  return getCtSkills().skills;
+}
+function getManifest() {
+  return getCtSkills().manifest;
+}
+function listSkills() {
+  return getCtSkills().listSkills();
+}
+function getSkill(name) {
+  return getCtSkills().getSkill(name);
+}
+function getSkillPath(name) {
+  return getCtSkills().getSkillPath(name);
+}
+function getSkillDir(name) {
+  return getCtSkills().getSkillDir(name);
+}
+function readSkillContent(name) {
+  return getCtSkills().readSkillContent(name);
+}
+function getCoreSkills() {
+  return getCtSkills().getCoreSkills();
+}
+function getSkillsByCategory(category) {
+  return getCtSkills().getSkillsByCategory(category);
+}
+function getSkillDependencies(name) {
+  return getCtSkills().getSkillDependencies(name);
+}
+function resolveDependencyTree(names) {
+  return getCtSkills().resolveDependencyTree(names);
+}
+function listProfiles() {
+  return getCtSkills().listProfiles();
+}
+function getProfile(name) {
+  return getCtSkills().getProfile(name);
+}
+function resolveProfile(name) {
+  return getCtSkills().resolveProfile(name);
+}
+function listSharedResources() {
+  return getCtSkills().listSharedResources();
+}
+function getSharedResourcePath(name) {
+  return getCtSkills().getSharedResourcePath(name);
+}
+function readSharedResource(name) {
+  return getCtSkills().readSharedResource(name);
+}
+function listProtocols() {
+  return getCtSkills().listProtocols();
+}
+function getProtocolPath(name) {
+  return getCtSkills().getProtocolPath(name);
+}
+function readProtocol(name) {
+  return getCtSkills().readProtocol(name);
+}
+function validateSkillFrontmatter(name) {
+  return getCtSkills().validateSkillFrontmatter(name);
+}
+function validateAll() {
+  return getCtSkills().validateAll();
+}
+function getDispatchMatrix() {
+  return getCtSkills().getDispatchMatrix();
+}
+function getVersion() {
+  return getCtSkills().version;
+}
+function getLibraryRoot() {
+  return getCtSkills().libraryRoot;
+}
+function isCatalogAvailable() {
+  try {
+    getCtSkills();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/core/skills/recommendation.ts
 var RECOMMENDATION_ERROR_CODES = {
   QUERY_INVALID: "E_SKILLS_QUERY_INVALID",
@@ -1357,8 +1545,8 @@ async function recommendSkills2(query, criteria, options = {}) {
 }
 
 // src/core/skills/audit/scanner.ts
-import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
 
 // src/core/skills/audit/rules.ts
 function rule(id, name, description, severity, category, pattern) {
@@ -1428,7 +1616,7 @@ var AUDIT_RULES = [
     "Invisible characters or zero-width spaces",
     "medium",
     "prompt-injection",
-    /[\u200B\u200C\u200D\u2060\uFEFF]/
+    /(?:\u200B|\u200C|\u200D|\u2060|\uFEFF)/
   ),
   // ── Command Injection ───────────────────────────────────────
   rule(
@@ -1740,13 +1928,13 @@ async function scanFile(filePath, rules) {
   if (!existsSync6(filePath)) {
     return { file: filePath, findings: [], score: 100, passed: true };
   }
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile3(filePath, "utf-8");
   const lines = content.split("\n");
   const activeRules = rules ?? AUDIT_RULES;
   const findings = [];
   for (const rule2 of activeRules) {
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
+      const line = lines[i] ?? "";
       const match = line.match(rule2.pattern);
       if (match) {
         findings.push({
@@ -1828,7 +2016,7 @@ function toSarif(results) {
 }
 
 // src/core/skills/validator.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import matter2 from "gray-matter";
 var RESERVED_NAMES = [
@@ -1857,7 +2045,7 @@ async function validateSkill(filePath) {
       metadata: null
     };
   }
-  const content = await readFile5(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   if (!content.startsWith("---")) {
     issues.push({
       level: "error",
@@ -1880,10 +2068,10 @@ async function validateSkill(filePath) {
     });
     return { valid: false, issues, metadata: null };
   }
-  if (!data["name"]) {
+  if (!data.name) {
     issues.push({ level: "error", field: "name", message: "Missing required field: name" });
   } else {
-    const name = String(data["name"]);
+    const name = String(data.name);
     if (name.length > MAX_NAME_LENGTH) {
       issues.push({
         level: "error",
@@ -1913,10 +2101,10 @@ async function validateSkill(filePath) {
       });
     }
   }
-  if (!data["description"]) {
+  if (!data.description) {
     issues.push({ level: "error", field: "description", message: "Missing required field: description" });
   } else {
-    const desc = String(data["description"]);
+    const desc = String(data.description);
     if (desc.length > MAX_DESCRIPTION_LENGTH) {
       issues.push({
         level: "error",
@@ -1990,17 +2178,17 @@ function getNestedValue(obj, keyPath) {
 }
 async function ensureDir(filePath) {
   const { mkdir: mkdir5 } = await import("fs/promises");
-  const { dirname: dirname6 } = await import("path");
-  await mkdir5(dirname6(filePath), { recursive: true });
+  const { dirname: dirname5 } = await import("path");
+  await mkdir5(dirname5(filePath), { recursive: true });
 }
 
 // src/core/formats/json.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import * as jsonc from "jsonc-parser";
 async function readJsonConfig(filePath) {
   if (!existsSync8(filePath)) return {};
-  const content = await readFile6(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   if (!content.trim()) return {};
   const errors = [];
   const result = jsonc.parse(content, errors);
@@ -2027,7 +2215,7 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   await ensureDir(filePath);
   let content;
   if (existsSync8(filePath)) {
-    content = await readFile6(filePath, "utf-8");
+    content = await readFile5(filePath, "utf-8");
     if (!content.trim()) {
       content = "{}";
     }
@@ -2049,11 +2237,11 @@ async function writeJsonConfig(filePath, configKey, serverName, serverConfig) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
 }
 async function removeJsonConfig(filePath, configKey, serverName) {
   if (!existsSync8(filePath)) return false;
-  let content = await readFile6(filePath, "utf-8");
+  let content = await readFile5(filePath, "utf-8");
   if (!content.trim()) return false;
   const { tabSize, insertSpaces } = detectIndent(content);
   const formatOptions = {
@@ -2069,17 +2257,17 @@ async function removeJsonConfig(filePath, configKey, serverName) {
   if (!content.endsWith("\n")) {
     content += "\n";
   }
-  await writeFile3(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/yaml.ts
-import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
 import yaml from "js-yaml";
 async function readYamlConfig(filePath) {
   if (!existsSync9(filePath)) return {};
-  const content = await readFile7(filePath, "utf-8");
+  const content = await readFile6(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = yaml.load(content);
   return result ?? {};
@@ -2089,8 +2277,8 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
   const existing = await readYamlConfig(filePath);
   const keyParts = configKey.split(".");
   let newEntry = { [serverName]: serverConfig };
-  for (let i = keyParts.length - 1; i >= 0; i--) {
-    newEntry = { [keyParts[i]]: newEntry };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
   const merged = deepMerge(existing, newEntry);
   const content = yaml.dump(merged, {
@@ -2099,7 +2287,7 @@ async function writeYamlConfig(filePath, configKey, serverName, serverConfig) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
 }
 async function removeYamlConfig(filePath, configKey, serverName) {
   if (!existsSync9(filePath)) return false;
@@ -2119,17 +2307,17 @@ async function removeYamlConfig(filePath, configKey, serverName) {
     noRefs: true,
     sortKeys: false
   });
-  await writeFile4(filePath, content, "utf-8");
+  await writeFile3(filePath, content, "utf-8");
   return true;
 }
 
 // src/core/formats/toml.ts
-import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
 import TOML from "@iarna/toml";
 async function readTomlConfig(filePath) {
   if (!existsSync10(filePath)) return {};
-  const content = await readFile8(filePath, "utf-8");
+  const content = await readFile7(filePath, "utf-8");
   if (!content.trim()) return {};
   const result = TOML.parse(content);
   return result;
@@ -2139,12 +2327,12 @@ async function writeTomlConfig(filePath, configKey, serverName, serverConfig) {
   const existing = await readTomlConfig(filePath);
   const keyParts = configKey.split(".");
   let newEntry = { [serverName]: serverConfig };
-  for (let i = keyParts.length - 1; i >= 0; i--) {
-    newEntry = { [keyParts[i]]: newEntry };
+  for (const part of [...keyParts].reverse()) {
+    newEntry = { [part]: newEntry };
   }
   const merged = deepMerge(existing, newEntry);
   const content = TOML.stringify(merged);
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
 }
 async function removeTomlConfig(filePath, configKey, serverName) {
   if (!existsSync10(filePath)) return false;
@@ -2159,7 +2347,7 @@ async function removeTomlConfig(filePath, configKey, serverName) {
   if (!(serverName in current)) return false;
   delete current[serverName];
   const content = TOML.stringify(existing);
-  await writeFile5(filePath, content, "utf-8");
+  await writeFile4(filePath, content, "utf-8");
   return true;
 }
 
@@ -2206,6 +2394,83 @@ async function removeConfig(filePath, format, key, serverName) {
   }
 }
 
+// src/core/mcp/reader.ts
+import { existsSync as existsSync11 } from "fs";
+function resolveConfigPath(provider, scope, projectDir) {
+  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
+}
+async function listMcpServers(provider, scope, projectDir) {
+  const configPath = resolveConfigPath(provider, scope, projectDir);
+  debug(`listing MCP servers for ${provider.id} (${scope}) at ${configPath ?? "(none)"}`);
+  if (!configPath || !existsSync11(configPath)) return [];
+  try {
+    const config = await readConfig(configPath, provider.configFormat);
+    const servers = getNestedValue(config, provider.configKey);
+    if (!servers || typeof servers !== "object") return [];
+    const entries = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+      entries.push({
+        name,
+        providerId: provider.id,
+        providerName: provider.toolName,
+        scope,
+        configPath,
+        config: cfg ?? {}
+      });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function listAgentsMcpServers(scope, projectDir) {
+  const serversPath = getAgentsMcpServersPath(scope, projectDir);
+  debug(`listing .agents/ MCP servers (${scope}) at ${serversPath}`);
+  if (!existsSync11(serversPath)) return [];
+  try {
+    const config = await readConfig(serversPath, "json");
+    const servers = config["servers"];
+    if (!servers || typeof servers !== "object") return [];
+    const entries = [];
+    for (const [name, cfg] of Object.entries(servers)) {
+      entries.push({
+        name,
+        providerId: ".agents",
+        providerName: ".agents/ standard",
+        scope,
+        configPath: serversPath,
+        config: cfg ?? {}
+      });
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function listAllMcpServers(providers, scope, projectDir) {
+  const seen = /* @__PURE__ */ new Set();
+  const allEntries = [];
+  const agentsServersPath = getAgentsMcpServersPath(scope, projectDir);
+  const agentsEntries = await listAgentsMcpServers(scope, projectDir);
+  if (agentsEntries.length > 0) {
+    allEntries.push(...agentsEntries);
+    seen.add(agentsServersPath);
+  }
+  for (const provider of providers) {
+    const configPath = resolveConfigPath(provider, scope, projectDir);
+    if (!configPath || seen.has(configPath)) continue;
+    seen.add(configPath);
+    const entries = await listMcpServers(provider, scope, projectDir);
+    allEntries.push(...entries);
+  }
+  return allEntries;
+}
+async function removeMcpServer(provider, serverName, scope, projectDir) {
+  const configPath = resolveConfigPath(provider, scope, projectDir);
+  if (!configPath) return false;
+  return removeConfig(configPath, provider.configFormat, provider.configKey, serverName);
+}
+
 // src/core/mcp/transforms.ts
 function transformGoose(serverName, config) {
   if (config.url) {
@@ -2229,7 +2494,7 @@ function transformGoose(serverName, config) {
     timeout: 300
   };
 }
-function transformZed(serverName, config) {
+function transformZed(_serverName, config) {
   if (config.url) {
     return {
       source: "custom",
@@ -2245,7 +2510,7 @@ function transformZed(serverName, config) {
     ...config.env ? { env: config.env } : {}
   };
 }
-function transformOpenCode(serverName, config) {
+function transformOpenCode(_serverName, config) {
   if (config.url) {
     return {
       type: "remote",
@@ -2262,7 +2527,7 @@ function transformOpenCode(serverName, config) {
     ...config.env ? { environment: config.env } : {}
   };
 }
-function transformCodex(serverName, config) {
+function transformCodex(_serverName, config) {
   if (config.url) {
     return {
       type: config.type ?? "http",
@@ -2276,7 +2541,7 @@ function transformCodex(serverName, config) {
     ...config.env ? { env: config.env } : {}
   };
 }
-function transformCursor(serverName, config) {
+function transformCursor(_serverName, config) {
   if (config.url) {
     return {
       url: config.url,
@@ -2302,53 +2567,6 @@ function getTransform(providerId) {
   }
 }
 
-// src/core/mcp/reader.ts
-import { existsSync as existsSync11 } from "fs";
-function resolveConfigPath(provider, scope, projectDir) {
-  return resolveProviderConfigPath(provider, scope, projectDir ?? process.cwd());
-}
-async function listMcpServers(provider, scope, projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  debug(`listing MCP servers for ${provider.id} (${scope}) at ${configPath ?? "(none)"}`);
-  if (!configPath || !existsSync11(configPath)) return [];
-  try {
-    const config = await readConfig(configPath, provider.configFormat);
-    const servers = getNestedValue(config, provider.configKey);
-    if (!servers || typeof servers !== "object") return [];
-    const entries = [];
-    for (const [name, cfg] of Object.entries(servers)) {
-      entries.push({
-        name,
-        providerId: provider.id,
-        providerName: provider.toolName,
-        scope,
-        configPath,
-        config: cfg ?? {}
-      });
-    }
-    return entries;
-  } catch {
-    return [];
-  }
-}
-async function listAllMcpServers(providers, scope, projectDir) {
-  const seen = /* @__PURE__ */ new Set();
-  const allEntries = [];
-  for (const provider of providers) {
-    const configPath = resolveConfigPath(provider, scope, projectDir);
-    if (!configPath || seen.has(configPath)) continue;
-    seen.add(configPath);
-    const entries = await listMcpServers(provider, scope, projectDir);
-    allEntries.push(...entries);
-  }
-  return allEntries;
-}
-async function removeMcpServer(provider, serverName, scope, projectDir) {
-  const configPath = resolveConfigPath(provider, scope, projectDir);
-  if (!configPath) return false;
-  return removeConfig(configPath, provider.configFormat, provider.configKey, serverName);
-}
-
 // src/core/mcp/installer.ts
 function buildConfig(provider, serverName, config) {
   const transform = getTransform(provider.id);
@@ -2419,9 +2637,10 @@ function buildServerConfig(source, transport, headers) {
       args: ["-y", source.value]
     };
   }
-  const parts = source.value.split(/\s+/);
+  const parts = source.value.trim().split(/\s+/);
+  const command = parts[0] ?? source.value;
   return {
-    command: parts[0],
+    command,
     args: parts.slice(1)
   };
 }
@@ -2468,16 +2687,16 @@ async function getLastSelectedAgents() {
 }
 
 // src/core/instructions/injector.ts
-import { readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import { join as join5, dirname as dirname4 } from "path";
+import { join as join5, dirname as dirname3 } from "path";
 import { mkdir as mkdir3 } from "fs/promises";
 var MARKER_START = "<!-- CAAMP:START -->";
 var MARKER_END = "<!-- CAAMP:END -->";
 var MARKER_PATTERN = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/;
 async function checkInjection(filePath, expectedContent) {
   if (!existsSync12(filePath)) return "missing";
-  const content = await readFile9(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!MARKER_PATTERN.test(content)) return "none";
   if (expectedContent) {
     const blockContent = extractBlock(content);
@@ -2500,31 +2719,35 @@ ${MARKER_END}`;
 }
 async function inject(filePath, content) {
   const block = buildBlock(content);
-  await mkdir3(dirname4(filePath), { recursive: true });
+  await mkdir3(dirname3(filePath), { recursive: true });
   if (!existsSync12(filePath)) {
-    await writeFile6(filePath, block + "\n", "utf-8");
+    await writeFile5(filePath, `${block}
+`, "utf-8");
     return "created";
   }
-  const existing = await readFile9(filePath, "utf-8");
+  const existing = await readFile8(filePath, "utf-8");
   if (MARKER_PATTERN.test(existing)) {
     const updated2 = existing.replace(MARKER_PATTERN, block);
-    await writeFile6(filePath, updated2, "utf-8");
+    await writeFile5(filePath, updated2, "utf-8");
     return "updated";
   }
-  const updated = block + "\n\n" + existing;
-  await writeFile6(filePath, updated, "utf-8");
+  const updated = `${block}
+
+${existing}`;
+  await writeFile5(filePath, updated, "utf-8");
   return "added";
 }
 async function removeInjection(filePath) {
   if (!existsSync12(filePath)) return false;
-  const content = await readFile9(filePath, "utf-8");
+  const content = await readFile8(filePath, "utf-8");
   if (!MARKER_PATTERN.test(content)) return false;
   const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
   if (!cleaned) {
     const { rm: rm4 } = await import("fs/promises");
     await rm4(filePath);
   } else {
-    await writeFile6(filePath, cleaned + "\n", "utf-8");
+    await writeFile5(filePath, `${cleaned}
+`, "utf-8");
   }
   return true;
 }
@@ -2591,20 +2814,19 @@ import { existsSync as existsSync13, lstatSync as lstatSync2 } from "fs";
 import {
   cp as cp2,
   mkdir as mkdir4,
-  readFile as readFile10,
-  readlink as readlink2,
+  readFile as readFile9,
+  readlink,
   rm as rm3,
   symlink as symlink2,
-  writeFile as writeFile7
+  writeFile as writeFile6
 } from "fs/promises";
-import { homedir as homedir2, tmpdir } from "os";
-import { basename as basename2, dirname as dirname5, join as join6 } from "path";
+import { tmpdir } from "os";
+import { basename, dirname as dirname4, join as join6 } from "path";
 var PRIORITY_ORDER = {
   high: 0,
   medium: 1,
   low: 2
 };
-var CANONICAL_SKILLS_DIR2 = join6(homedir2(), ".agents", "skills");
 function selectProvidersByMinimumPriority(providers, minimumPriority = "low") {
   const maxRank = PRIORITY_ORDER[minimumPriority];
   return [...providers].filter((provider) => PRIORITY_ORDER[provider.priority] <= maxRank).sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
@@ -2621,7 +2843,7 @@ async function snapshotConfigs(paths) {
       snapshots.set(path, null);
       continue;
     }
-    snapshots.set(path, await readFile10(path, "utf-8"));
+    snapshots.set(path, await readFile9(path, "utf-8"));
   }
   return snapshots;
 }
@@ -2631,18 +2853,18 @@ async function restoreConfigSnapshots(snapshots) {
       await rm3(path, { force: true });
       continue;
     }
-    await mkdir4(dirname5(path), { recursive: true });
-    await writeFile7(path, content, "utf-8");
+    await mkdir4(dirname4(path), { recursive: true });
+    await writeFile6(path, content, "utf-8");
   }
 }
 async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
   const skillName = operation.skillName;
   const isGlobal = operation.isGlobal ?? true;
-  const canonicalPath = join6(CANONICAL_SKILLS_DIR2, skillName);
+  const canonicalPath = join6(CANONICAL_SKILLS_DIR, skillName);
   const canonicalExisted = existsSync13(canonicalPath);
   const canonicalBackupPath = join6(backupRoot, "canonical", skillName);
   if (canonicalExisted) {
-    await mkdir4(dirname5(canonicalBackupPath), { recursive: true });
+    await mkdir4(dirname4(canonicalBackupPath), { recursive: true });
     await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
   }
   const pathSnapshots = [];
@@ -2657,12 +2879,12 @@ async function snapshotSkillState(providerTargets, operation, projectDir, backup
       pathSnapshots.push({
         linkPath,
         state: "symlink",
-        symlinkTarget: await readlink2(linkPath)
+        symlinkTarget: await readlink(linkPath)
       });
       continue;
     }
-    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
-    await mkdir4(dirname5(backupPath), { recursive: true });
+    const backupPath = join6(backupRoot, "links", provider.id, `${skillName}-${basename(linkPath)}`);
+    await mkdir4(dirname4(backupPath), { recursive: true });
     if (stat.isDirectory()) {
       await cp2(linkPath, backupPath, { recursive: true });
       pathSnapshots.push({ linkPath, state: "directory", backupPath });
@@ -2685,13 +2907,13 @@ async function restoreSkillSnapshot(snapshot) {
     await rm3(snapshot.canonicalPath, { recursive: true, force: true });
   }
   if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync13(snapshot.canonicalBackupPath)) {
-    await mkdir4(dirname5(snapshot.canonicalPath), { recursive: true });
+    await mkdir4(dirname4(snapshot.canonicalPath), { recursive: true });
     await cp2(snapshot.canonicalBackupPath, snapshot.canonicalPath, { recursive: true });
   }
   for (const pathSnapshot of snapshot.pathSnapshots) {
     await rm3(pathSnapshot.linkPath, { recursive: true, force: true });
     if (pathSnapshot.state === "missing") continue;
-    await mkdir4(dirname5(pathSnapshot.linkPath), { recursive: true });
+    await mkdir4(dirname4(pathSnapshot.linkPath), { recursive: true });
     if (pathSnapshot.state === "symlink" && pathSnapshot.symlinkTarget) {
       const linkType = process.platform === "win32" ? "junction" : "dir";
       await symlink2(pathSnapshot.symlinkTarget, pathSnapshot.linkPath, linkType);
@@ -2916,7 +3138,7 @@ async function updateInstructionsSingleOperation(providers, content, scope = "pr
       const expectedPath = scope === "global" ? join6(provider.pathGlobal, provider.instructFile) : join6(projectDir, provider.instructFile);
       return expectedPath === filePath;
     });
-    const fallback = groupedByFile.get(basename2(filePath)) ?? [];
+    const fallback = groupedByFile.get(basename(filePath)) ?? [];
     const selected = providersForFile.length > 0 ? providersForFile : fallback;
     summary.actions.push({
       file: filePath,
@@ -2984,6 +3206,13 @@ export {
   getProjectAgentsDir,
   getCanonicalSkillsDir,
   getLockFilePath,
+  getAgentsMcpDir,
+  getAgentsMcpServersPath,
+  getAgentsInstructFile,
+  getAgentsConfigPath,
+  getAgentsWikiDir,
+  getAgentsSpecDir,
+  getAgentsLinksDir,
   resolveRegistryTemplatePath,
   resolveProviderConfigPath,
   resolvePreferredConfigScope,
@@ -3009,6 +3238,7 @@ export {
   resetDetectionCache,
   parseSource,
   isMarketplaceScoped,
+  CANONICAL_SKILLS_DIR,
   installSkill,
   removeSkill,
   listCanonicalSkills,
@@ -3023,6 +3253,13 @@ export {
   discoverSkill,
   discoverSkills,
   discoverSkillsMulti,
+  listSkills,
+  getSkill,
+  getSkillDir,
+  listProfiles,
+  resolveProfile,
+  isCatalogAvailable,
+  catalog_exports,
   RECOMMENDATION_ERROR_CODES,
   tokenizeCriteriaValue,
   validateRecommendationCriteria,
@@ -3042,11 +3279,12 @@ export {
   readConfig,
   writeConfig,
   removeConfig,
-  getTransform,
   resolveConfigPath,
   listMcpServers,
+  listAgentsMcpServers,
   listAllMcpServers,
   removeMcpServer,
+  getTransform,
   installMcpServer,
   installMcpServerToAll,
   buildServerConfig,
@@ -3069,4 +3307,4 @@ export {
   updateInstructionsSingleOperation,
   configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-6HQDRJLS.js.map
+//# sourceMappingURL=chunk-YCSZGZ5W.js.map