@cleocode/caamp 0.3.0 → 0.4.0

package/dist/{chunk-PCWTRJV2.js → chunk-ZYINKJDE.js}

@@ -576,8 +576,66 @@ async function checkSkillUpdate(skillName) {
   };
 }
 
+// src/core/network/fetch.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var NetworkError = class extends Error {
+  kind;
+  url;
+  status;
+  constructor(message, kind, url, status) {
+    super(message);
+    this.name = "NetworkError";
+    this.kind = kind;
+    this.url = url;
+    this.status = status;
+  }
+};
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  try {
+    return await fetch(url, {
+      ...init,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw new NetworkError(`Request timed out after ${timeoutMs}ms`, "timeout", url);
+    }
+    throw new NetworkError("Network request failed", "network", url);
+  }
+}
+function ensureOkResponse(response, url) {
+  if (!response.ok) {
+    throw new NetworkError(`Request failed with status ${response.status}`, "http", url, response.status);
+  }
+  return response;
+}
+function formatNetworkError(error) {
+  if (error instanceof NetworkError) {
+    if (error.kind === "timeout") {
+      return "Network request timed out. Please check your connection and try again.";
+    }
+    if (error.kind === "http") {
+      return `Marketplace request failed with HTTP ${error.status ?? "unknown"}. Please try again shortly.`;
+    }
+    return "Network request failed. Please check your connection and try again.";
+  }
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
 // src/core/marketplace/skillsmp.ts
 var API_BASE = "https://www.agentskills.in/api/skills";
+function parseScopedName(value) {
+  const match = value.match(/^@([^/]+)\/([^/]+)$/);
+  if (!match) return null;
+  return {
+    author: match[1],
+    name: match[2]
+  };
+}
 function toResult(skill) {
   return {
     name: skill.name,
@@ -599,31 +657,34 @@ var SkillsMPAdapter = class {
       limit: String(limit),
       sortBy: "stars"
     });
-    try {
-      const response = await fetch(`${API_BASE}?${params}`);
-      if (!response.ok) return [];
-      const data = await response.json();
-      return data.skills.map(toResult);
-    } catch {
-      return [];
-    }
+    const url = `${API_BASE}?${params}`;
+    const response = ensureOkResponse(await fetchWithTimeout(url), url);
+    const data = await response.json();
+    return data.skills.map(toResult);
   }
   async getSkill(scopedName) {
-    const params = new URLSearchParams({
-      search: scopedName,
-      limit: "1"
-    });
-    try {
-      const response = await fetch(`${API_BASE}?${params}`);
-      if (!response.ok) return null;
+    const parts = parseScopedName(scopedName);
+    const searchTerms = parts ? [parts.name, `${parts.author} ${parts.name}`, scopedName] : [scopedName];
+    const seen = /* @__PURE__ */ new Set();
+    for (const term of searchTerms) {
+      if (seen.has(term)) continue;
+      seen.add(term);
+      const params = new URLSearchParams({
+        search: term,
+        limit: "50",
+        sortBy: "stars"
+      });
+      const url = `${API_BASE}?${params}`;
+      const response = ensureOkResponse(await fetchWithTimeout(url), url);
       const data = await response.json();
       const match = data.skills.find(
         (s) => s.scopedName === scopedName || `@${s.author}/${s.name}` === scopedName
       );
-      return match ? toResult(match) : null;
-    } catch {
-      return null;
+      if (match) {
+        return toResult(match);
+      }
     }
+    return null;
   }
 };
 
@@ -645,18 +706,14 @@ function toResult2(skill) {
 var SkillsShAdapter = class {
   name = "skills.sh";
   async search(query, limit = 20) {
-    try {
-      const params = new URLSearchParams({
-        q: query,
-        limit: String(limit)
-      });
-      const response = await fetch(`${API_BASE2}/search?${params}`);
-      if (!response.ok) return [];
-      const data = await response.json();
-      return data.results.map(toResult2);
-    } catch {
-      return [];
-    }
+    const params = new URLSearchParams({
+      q: query,
+      limit: String(limit)
+    });
+    const url = `${API_BASE2}/search?${params}`;
+    const response = ensureOkResponse(await fetchWithTimeout(url), url);
+    const data = await response.json();
+    return data.results.map(toResult2);
   }
   async getSkill(scopedName) {
     const results = await this.search(scopedName, 5);
@@ -665,6 +722,14 @@ var SkillsShAdapter = class {
 };
 
 // src/core/marketplace/client.ts
+var MarketplaceUnavailableError = class extends Error {
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "MarketplaceUnavailableError";
+    this.details = details;
+  }
+};
 var MarketplaceClient = class {
   adapters;
   /**
@@ -704,11 +769,21 @@ var MarketplaceClient = class {
    * ```
    */
   async search(query, limit = 20) {
-    const promises = this.adapters.map(
-      (adapter) => adapter.search(query, limit).catch(() => [])
-    );
-    const allResults = await Promise.all(promises);
-    const flat = allResults.flat();
+    const settled = await Promise.allSettled(this.adapters.map((adapter) => adapter.search(query, limit)));
+    const flat = [];
+    const failures = [];
+    for (const [index, result] of settled.entries()) {
+      const adapterName = this.adapters[index]?.name ?? "unknown";
+      if (result.status === "fulfilled") {
+        flat.push(...result.value);
+      } else {
+        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        failures.push(`${adapterName}: ${reason}`);
+      }
+    }
+    if (flat.length === 0 && failures.length > 0) {
+      throw new MarketplaceUnavailableError("All marketplace sources failed.", failures);
+    }
     const seen = /* @__PURE__ */ new Map();
     for (const result of flat) {
       const existing = seen.get(result.scopedName);
@@ -734,9 +809,18 @@ var MarketplaceClient = class {
    * ```
    */
   async getSkill(scopedName) {
+    const failures = [];
     for (const adapter of this.adapters) {
-      const result = await adapter.getSkill(scopedName).catch(() => null);
-      if (result) return result;
+      try {
+        const result = await adapter.getSkill(scopedName);
+        if (result) return result;
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        failures.push(`${adapter.name}: ${reason}`);
+      }
+    }
+    if (failures.length === this.adapters.length && this.adapters.length > 0) {
+      throw new MarketplaceUnavailableError("All marketplace sources failed.", failures);
     }
     return null;
   }
@@ -809,6 +893,273 @@ async function discoverSkillsMulti(dirs) {
   return all;
 }
 
+// src/core/skills/recommendation.ts
+var RECOMMENDATION_ERROR_CODES = {
+  QUERY_INVALID: "E_SKILLS_QUERY_INVALID",
+  NO_MATCHES: "E_SKILLS_NO_MATCHES",
+  SOURCE_UNAVAILABLE: "E_SKILLS_SOURCE_UNAVAILABLE",
+  CRITERIA_CONFLICT: "E_SKILLS_CRITERIA_CONFLICT"
+};
+var DEFAULT_WEIGHTS = {
+  mustHaveMatch: 10,
+  preferMatch: 4,
+  queryTokenMatch: 3,
+  starsFactor: 2,
+  metadataBoost: 2,
+  modernMarkerBoost: 3,
+  legacyMarkerPenalty: 3,
+  excludePenalty: 25,
+  missingMustHavePenalty: 20
+};
+var DEFAULT_MODERN_MARKERS = ["svelte 5", "runes", "lafs", "slsa", "drizzle", "better-auth"];
+var DEFAULT_LEGACY_MARKERS = ["svelte 3", "jquery", "bower", "legacy", "book.json", "gitbook-cli"];
+function tokenizeCriteriaValue(value) {
+  return value.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean);
+}
+function normalizeList(value) {
+  if (value === void 0) return [];
+  if (!(typeof value === "string" || Array.isArray(value))) return [];
+  const source = Array.isArray(value) ? value : [value];
+  const flattened = source.flatMap((item) => typeof item === "string" ? tokenizeCriteriaValue(item) : []);
+  return Array.from(new Set(flattened)).sort((a, b) => a.localeCompare(b));
+}
+function hasAnyCriteriaInput(input) {
+  const query = typeof input.query === "string" ? input.query.trim() : "";
+  if (query.length > 0) return true;
+  const lists = [input.mustHave, input.prefer, input.exclude];
+  return lists.some((list) => normalizeList(list).length > 0);
+}
+function validateRecommendationCriteria(input) {
+  const issues = [];
+  if (input.query !== void 0 && typeof input.query !== "string") {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "query",
+      message: "query must be a string"
+    });
+  }
+  if (input.mustHave !== void 0 && !(typeof input.mustHave === "string" || Array.isArray(input.mustHave))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "mustHave",
+      message: "mustHave must be a string or string[]"
+    });
+  }
+  if (input.prefer !== void 0 && !(typeof input.prefer === "string" || Array.isArray(input.prefer))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "prefer",
+      message: "prefer must be a string or string[]"
+    });
+  }
+  if (input.exclude !== void 0 && !(typeof input.exclude === "string" || Array.isArray(input.exclude))) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "exclude",
+      message: "exclude must be a string or string[]"
+    });
+  }
+  const mustHave = normalizeList(input.mustHave);
+  const prefer = normalizeList(input.prefer);
+  const exclude = normalizeList(input.exclude);
+  const conflict = mustHave.some((term) => exclude.includes(term)) || prefer.some((term) => exclude.includes(term));
+  if (conflict) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.CRITERIA_CONFLICT,
+      field: "exclude",
+      message: "criteria terms cannot appear in both prefer/must-have and exclude"
+    });
+  }
+  if (issues.length === 0 && !hasAnyCriteriaInput(input)) {
+    issues.push({
+      code: RECOMMENDATION_ERROR_CODES.QUERY_INVALID,
+      field: "query",
+      message: "at least one criteria value is required"
+    });
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+function normalizeRecommendationCriteria(input) {
+  const query = (input.query ?? "").trim().toLowerCase();
+  return {
+    query,
+    queryTokens: query ? Array.from(new Set(tokenizeCriteriaValue(query.replace(/\s+/g, ",")))).sort((a, b) => a.localeCompare(b)) : [],
+    mustHave: normalizeList(input.mustHave),
+    prefer: normalizeList(input.prefer),
+    exclude: normalizeList(input.exclude)
+  };
+}
+function countMatches(haystack, needles) {
+  let count = 0;
+  for (const needle of needles) {
+    if (haystack.includes(needle)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function clampScore(value) {
+  return Number(value.toFixed(6));
+}
+function buildSearchText(skill) {
+  return `${skill.name} ${skill.scopedName} ${skill.description} ${skill.author}`.toLowerCase();
+}
+function scoreSkillRecommendation(skill, criteria, options = {}) {
+  const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+  const modernMarkers = (options.modernMarkers ?? DEFAULT_MODERN_MARKERS).map((marker) => marker.toLowerCase());
+  const legacyMarkers = (options.legacyMarkers ?? DEFAULT_LEGACY_MARKERS).map((marker) => marker.toLowerCase());
+  const text = buildSearchText(skill);
+  const reasons = [];
+  const tradeoffs = [];
+  const mustHaveMatches = countMatches(text, criteria.mustHave);
+  const missingMustHave = Math.max(criteria.mustHave.length - mustHaveMatches, 0);
+  const preferMatches = countMatches(text, criteria.prefer);
+  const queryMatches = countMatches(text, criteria.queryTokens);
+  const excludeMatches = countMatches(text, criteria.exclude);
+  const modernMatches = countMatches(text, modernMarkers);
+  const legacyMatches = countMatches(text, legacyMarkers);
+  const metadataSignal = skill.description.trim().length >= 80 ? 1 : 0;
+  const starsSignal = Math.log10(skill.stars + 1);
+  const sourceConfidence = skill.source === "agentskills.in" ? 1 : skill.source === "skills.sh" ? 0.8 : 0.6;
+  const mustHaveScore = mustHaveMatches * weights.mustHaveMatch - missingMustHave * weights.missingMustHavePenalty;
+  const preferScore = preferMatches * weights.preferMatch;
+  const queryScore = queryMatches * weights.queryTokenMatch;
+  const starsScore = starsSignal * weights.starsFactor;
+  const metadataScore = (metadataSignal + sourceConfidence) * weights.metadataBoost;
+  const modernityScore = modernMatches * weights.modernMarkerBoost - legacyMatches * weights.legacyMarkerPenalty;
+  const exclusionPenalty = excludeMatches * weights.excludePenalty;
+  const hasGitbookTopic = text.includes("gitbook");
+  const hasGitSync = text.includes("git sync") || text.includes("git") && text.includes("sync");
+  const hasApiWorkflow = text.includes("api") && (text.includes("workflow") || text.includes("sync"));
+  const hasLegacyCli = text.includes("gitbook-cli") || text.includes("book.json");
+  const topicScore = (hasGitbookTopic ? 3 : 0) + (hasGitSync ? 2 : 0) + (hasApiWorkflow ? 2 : 0) - (hasLegacyCli ? 4 : 0);
+  const total = clampScore(
+    mustHaveScore + preferScore + queryScore + starsScore + metadataScore + modernityScore + topicScore - exclusionPenalty
+  );
+  if (hasGitbookTopic) reasons.push({ code: "MATCH_TOPIC_GITBOOK" });
+  if (hasGitSync) reasons.push({ code: "HAS_GIT_SYNC" });
+  if (hasApiWorkflow) reasons.push({ code: "HAS_API_WORKFLOW" });
+  if (hasLegacyCli) reasons.push({ code: "PENALTY_LEGACY_CLI" });
+  if (mustHaveMatches > 0) reasons.push({ code: "MUST_HAVE_MATCH", detail: String(mustHaveMatches) });
+  if (missingMustHave > 0) reasons.push({ code: "MISSING_MUST_HAVE", detail: String(missingMustHave) });
+  if (preferMatches > 0) reasons.push({ code: "PREFER_MATCH", detail: String(preferMatches) });
+  if (queryMatches > 0) reasons.push({ code: "QUERY_MATCH", detail: String(queryMatches) });
+  if (starsSignal > 0) reasons.push({ code: "STAR_SIGNAL" });
+  if (metadataSignal > 0) reasons.push({ code: "METADATA_SIGNAL" });
+  if (modernMatches > 0) reasons.push({ code: "MODERN_MARKER", detail: String(modernMatches) });
+  if (legacyMatches > 0) reasons.push({ code: "LEGACY_MARKER", detail: String(legacyMatches) });
+  if (excludeMatches > 0) reasons.push({ code: "EXCLUDE_MATCH", detail: String(excludeMatches) });
+  if (missingMustHave > 0) tradeoffs.push("Missing one or more required criteria terms.");
+  if (excludeMatches > 0) tradeoffs.push("Matches one or more excluded terms.");
+  if (skill.stars < 10) tradeoffs.push("Low quality signal from repository stars.");
+  if (hasLegacyCli) tradeoffs.push("Contains legacy GitBook CLI markers.");
+  const result = {
+    skill,
+    score: total,
+    reasons,
+    tradeoffs,
+    excluded: excludeMatches > 0
+  };
+  if (options.includeDetails) {
+    result.breakdown = {
+      mustHave: clampScore(mustHaveScore),
+      prefer: clampScore(preferScore),
+      query: clampScore(queryScore),
+      stars: clampScore(starsScore),
+      metadata: clampScore(metadataScore),
+      modernity: clampScore(modernityScore),
+      exclusionPenalty: clampScore(exclusionPenalty),
+      total
+    };
+  }
+  return result;
+}
+function recommendSkills(skills, criteriaInput, options = {}) {
+  const validation = validateRecommendationCriteria(criteriaInput);
+  if (!validation.valid) {
+    const first = validation.issues[0];
+    const error = new Error(first?.message ?? "Invalid recommendation criteria");
+    error.code = first?.code;
+    error.issues = validation.issues;
+    throw error;
+  }
+  const criteria = normalizeRecommendationCriteria(criteriaInput);
+  const ranking = skills.map((skill) => scoreSkillRecommendation(skill, criteria, options)).sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (b.skill.stars !== a.skill.stars) return b.skill.stars - a.skill.stars;
+    return a.skill.scopedName.localeCompare(b.skill.scopedName);
+  });
+  return {
+    criteria,
+    ranking: typeof options.top === "number" ? ranking.slice(0, Math.max(0, options.top)) : ranking
+  };
+}
+var rankSkills = recommendSkills;
+
+// src/core/skills/recommendation-api.ts
+function formatSkillRecommendations(result, opts) {
+  const top = result.ranking;
+  if (opts.mode === "human") {
+    if (top.length === 0) return "No recommendations found.";
+    const lines = ["Recommended skills:", ""];
+    for (const [index, entry] of top.entries()) {
+      const marker = index === 0 ? " (Recommended)" : "";
+      lines.push(`${index + 1}) ${entry.skill.scopedName}${marker}`);
+      lines.push(`   why: ${entry.reasons.map((reason) => reason.code).join(", ") || "score-based match"}`);
+      lines.push(`   tradeoff: ${entry.tradeoffs[0] ?? "none"}`);
+    }
+    lines.push("");
+    lines.push(`CHOOSE: ${top.map((_, index) => index + 1).join(",")}`);
+    return lines.join("\n");
+  }
+  const options = top.map((entry, index) => ({
+    rank: index + 1,
+    scopedName: entry.skill.scopedName,
+    score: entry.score,
+    reasons: entry.reasons,
+    tradeoffs: entry.tradeoffs,
+    ...opts.details ? {
+      description: entry.skill.description,
+      source: entry.skill.source,
+      evidence: entry.breakdown ?? null
+    } : {}
+  }));
+  return {
+    query: result.criteria.query,
+    recommended: options[0] ?? null,
+    options
+  };
+}
+async function searchSkills(query, options = {}) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    const error = new Error("query must be non-empty");
+    error.code = RECOMMENDATION_ERROR_CODES.QUERY_INVALID;
+    throw error;
+  }
+  const client = new MarketplaceClient();
+  try {
+    return await client.search(trimmed, options.limit ?? 20);
+  } catch (error) {
+    const wrapped = new Error(error instanceof Error ? error.message : String(error));
+    wrapped.code = RECOMMENDATION_ERROR_CODES.SOURCE_UNAVAILABLE;
+    throw wrapped;
+  }
+}
+async function recommendSkills2(query, criteria, options = {}) {
+  const hits = await searchSkills(query, { limit: options.limit ?? Math.max((options.top ?? 3) * 5, 20) });
+  const ranked = recommendSkills(hits, { ...criteria, query }, options);
+  if (ranked.ranking.length === 0) {
+    const error = new Error("no matches found");
+    error.code = RECOMMENDATION_ERROR_CODES.NO_MATCHES;
+    throw error;
+  }
+  return ranked;
+}
+
 // src/core/skills/audit/scanner.ts
 import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
@@ -1222,13 +1573,13 @@ async function scanFile(filePath, rules) {
 }
 async function scanDirectory(dirPath) {
   const { readdir: readdir2 } = await import("fs/promises");
-  const { join: join8 } = await import("path");
+  const { join: join9 } = await import("path");
   if (!existsSync6(dirPath)) return [];
   const entries = await readdir2(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillFile = join8(dirPath, entry.name, "SKILL.md");
+      const skillFile = join9(dirPath, entry.name, "SKILL.md");
       if (existsSync6(skillFile)) {
         results.push(await scanFile(skillFile));
       }
@@ -1442,9 +1793,9 @@ function getNestedValue(obj, keyPath) {
   return current;
 }
 async function ensureDir(filePath) {
-  const { mkdir: mkdir4 } = await import("fs/promises");
-  const { dirname: dirname4 } = await import("path");
-  await mkdir4(dirname4(filePath), { recursive: true });
+  const { mkdir: mkdir5 } = await import("fs/promises");
+  const { dirname: dirname5 } = await import("path");
+  await mkdir5(dirname5(filePath), { recursive: true });
 }
 
 // src/core/formats/json.ts
@@ -1977,8 +2328,8 @@ async function removeInjection(filePath) {
   if (!MARKER_PATTERN.test(content)) return false;
   const cleaned = content.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
   if (!cleaned) {
-    const { rm: rm2 } = await import("fs/promises");
-    await rm2(filePath);
+    const { rm: rm3 } = await import("fs/promises");
+    await rm3(filePath);
   } else {
     await writeFile6(filePath, cleaned + "\n", "utf-8");
   }
@@ -2042,6 +2393,398 @@ function groupByInstructFile(providers) {
   return groups;
 }
 
+// src/core/advanced/orchestration.ts
+import { existsSync as existsSync13, lstatSync as lstatSync2 } from "fs";
+import {
+  cp as cp2,
+  mkdir as mkdir4,
+  readFile as readFile10,
+  readlink as readlink2,
+  rm as rm2,
+  symlink as symlink2,
+  writeFile as writeFile7
+} from "fs/promises";
+import { homedir as homedir4, tmpdir } from "os";
+import { basename as basename2, dirname as dirname4, join as join8 } from "path";
+var PRIORITY_ORDER = {
+  high: 0,
+  medium: 1,
+  low: 2
+};
+var CANONICAL_SKILLS_DIR = join8(homedir4(), ".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]);
+}
+function resolveSkillLinkPath(provider, skillName, isGlobal, projectDir) {
+  const skillDir = isGlobal ? provider.pathSkills : join8(projectDir, provider.pathProjectSkills);
+  return join8(skillDir, skillName);
+}
+async function snapshotConfigs(paths) {
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    if (!path || snapshots.has(path)) continue;
+    if (!existsSync13(path)) {
+      snapshots.set(path, null);
+      continue;
+    }
+    snapshots.set(path, await readFile10(path, "utf-8"));
+  }
+  return snapshots;
+}
+async function restoreConfigSnapshots(snapshots) {
+  for (const [path, content] of snapshots) {
+    if (content === null) {
+      await rm2(path, { force: true });
+      continue;
+    }
+    await mkdir4(dirname4(path), { recursive: true });
+    await writeFile7(path, content, "utf-8");
+  }
+}
+async function snapshotSkillState(providerTargets, operation, projectDir, backupRoot) {
+  const skillName = operation.skillName;
+  const isGlobal = operation.isGlobal ?? true;
+  const canonicalPath = join8(CANONICAL_SKILLS_DIR, skillName);
+  const canonicalExisted = existsSync13(canonicalPath);
+  const canonicalBackupPath = join8(backupRoot, "canonical", skillName);
+  if (canonicalExisted) {
+    await mkdir4(dirname4(canonicalBackupPath), { recursive: true });
+    await cp2(canonicalPath, canonicalBackupPath, { recursive: true });
+  }
+  const pathSnapshots = [];
+  for (const provider of providerTargets) {
+    const linkPath = resolveSkillLinkPath(provider, skillName, isGlobal, projectDir);
+    if (!existsSync13(linkPath)) {
+      pathSnapshots.push({ linkPath, state: "missing" });
+      continue;
+    }
+    const stat = lstatSync2(linkPath);
+    if (stat.isSymbolicLink()) {
+      pathSnapshots.push({
+        linkPath,
+        state: "symlink",
+        symlinkTarget: await readlink2(linkPath)
+      });
+      continue;
+    }
+    const backupPath = join8(backupRoot, "links", provider.id, `${skillName}-${basename2(linkPath)}`);
+    await mkdir4(dirname4(backupPath), { recursive: true });
+    if (stat.isDirectory()) {
+      await cp2(linkPath, backupPath, { recursive: true });
+      pathSnapshots.push({ linkPath, state: "directory", backupPath });
+      continue;
+    }
+    await cp2(linkPath, backupPath);
+    pathSnapshots.push({ linkPath, state: "file", backupPath });
+  }
+  return {
+    skillName,
+    isGlobal,
+    canonicalPath,
+    canonicalBackupPath: canonicalExisted ? canonicalBackupPath : void 0,
+    canonicalExisted,
+    pathSnapshots
+  };
+}
+async function restoreSkillSnapshot(snapshot) {
+  if (existsSync13(snapshot.canonicalPath)) {
+    await rm2(snapshot.canonicalPath, { recursive: true, force: true });
+  }
+  if (snapshot.canonicalExisted && snapshot.canonicalBackupPath && existsSync13(snapshot.canonicalBackupPath)) {
+    await mkdir4(dirname4(snapshot.canonicalPath), { recursive: true });
+    await cp2(snapshot.canonicalBackupPath, snapshot.canonicalPath, { recursive: true });
+  }
+  for (const pathSnapshot of snapshot.pathSnapshots) {
+    await rm2(pathSnapshot.linkPath, { recursive: true, force: true });
+    if (pathSnapshot.state === "missing") continue;
+    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);
+      continue;
+    }
+    if ((pathSnapshot.state === "directory" || pathSnapshot.state === "file") && pathSnapshot.backupPath) {
+      if (pathSnapshot.state === "directory") {
+        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath, { recursive: true });
+      } else {
+        await cp2(pathSnapshot.backupPath, pathSnapshot.linkPath);
+      }
+    }
+  }
+}
+async function installBatchWithRollback(options) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const minimumPriority = options.minimumPriority ?? "low";
+  const mcpOps = options.mcp ?? [];
+  const skillOps = options.skills ?? [];
+  const baseProviders = options.providers ?? getInstalledProviders();
+  const providers = selectProvidersByMinimumPriority(baseProviders, minimumPriority);
+  const configPaths = providers.flatMap((provider) => {
+    const paths = [];
+    for (const operation of mcpOps) {
+      const path = resolveConfigPath(provider, operation.scope ?? "project", projectDir);
+      if (path) paths.push(path);
+    }
+    return paths;
+  });
+  const configSnapshots = await snapshotConfigs(configPaths);
+  const backupRoot = join8(
+    tmpdir(),
+    `caamp-skill-backup-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  const skillSnapshots = await Promise.all(
+    skillOps.map((operation) => snapshotSkillState(providers, operation, projectDir, backupRoot))
+  );
+  const appliedSkills = [];
+  const rollbackErrors = [];
+  let mcpApplied = 0;
+  let skillsApplied = 0;
+  let rollbackPerformed = false;
+  try {
+    for (const operation of mcpOps) {
+      const scope = operation.scope ?? "project";
+      for (const provider of providers) {
+        const result = await installMcpServer(
+          provider,
+          operation.serverName,
+          operation.config,
+          scope,
+          projectDir
+        );
+        if (!result.success) {
+          throw new Error(result.error ?? `Failed MCP install for ${provider.id}`);
+        }
+        mcpApplied += 1;
+      }
+    }
+    for (const operation of skillOps) {
+      const isGlobal = operation.isGlobal ?? true;
+      const result = await installSkill(
+        operation.sourcePath,
+        operation.skillName,
+        providers,
+        isGlobal,
+        projectDir
+      );
+      const linkedProviders = providers.filter((provider) => result.linkedAgents.includes(provider.id));
+      appliedSkills.push({
+        skillName: operation.skillName,
+        isGlobal,
+        linkedProviders
+      });
+      if (result.errors.length > 0) {
+        throw new Error(result.errors.join("; "));
+      }
+      skillsApplied += 1;
+    }
+    await rm2(backupRoot, { recursive: true, force: true });
+    return {
+      success: true,
+      providerIds: providers.map((provider) => provider.id),
+      mcpApplied,
+      skillsApplied,
+      rollbackPerformed: false,
+      rollbackErrors: []
+    };
+  } catch (error) {
+    rollbackPerformed = true;
+    for (const applied of [...appliedSkills].reverse()) {
+      try {
+        await removeSkill(applied.skillName, applied.linkedProviders, applied.isGlobal, projectDir);
+      } catch (err) {
+        rollbackErrors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    try {
+      await restoreConfigSnapshots(configSnapshots);
+    } catch (err) {
+      rollbackErrors.push(err instanceof Error ? err.message : String(err));
+    }
+    for (const snapshot of skillSnapshots) {
+      try {
+        await restoreSkillSnapshot(snapshot);
+      } catch (err) {
+        rollbackErrors.push(err instanceof Error ? err.message : String(err));
+      }
+    }
+    await rm2(backupRoot, { recursive: true, force: true });
+    return {
+      success: false,
+      providerIds: providers.map((provider) => provider.id),
+      mcpApplied,
+      skillsApplied,
+      rollbackPerformed,
+      rollbackErrors,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const keys = Object.keys(record).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+async function detectMcpConfigConflicts(providers, operations, projectDir = process.cwd()) {
+  const conflicts = [];
+  for (const provider of providers) {
+    for (const operation of operations) {
+      const scope = operation.scope ?? "project";
+      if (operation.config.type && !provider.supportedTransports.includes(operation.config.type)) {
+        conflicts.push({
+          providerId: provider.id,
+          serverName: operation.serverName,
+          scope,
+          code: "unsupported-transport",
+          message: `${provider.id} does not support transport ${operation.config.type}`
+        });
+      }
+      if (operation.config.headers && !provider.supportsHeaders) {
+        conflicts.push({
+          providerId: provider.id,
+          serverName: operation.serverName,
+          scope,
+          code: "unsupported-headers",
+          message: `${provider.id} does not support header configuration`
+        });
+      }
+      const existingEntries = await listMcpServers(provider, scope, projectDir);
+      const current = existingEntries.find((entry) => entry.name === operation.serverName);
+      if (!current) continue;
+      const transform = getTransform(provider.id);
+      const desired = transform ? transform(operation.serverName, operation.config) : operation.config;
+      if (stableStringify(current.config) !== stableStringify(desired)) {
+        conflicts.push({
+          providerId: provider.id,
+          serverName: operation.serverName,
+          scope,
+          code: "existing-mismatch",
+          message: `${provider.id} has existing config mismatch for ${operation.serverName}`
+        });
+      }
+    }
+  }
+  return conflicts;
+}
+async function applyMcpInstallWithPolicy(providers, operations, policy = "fail", projectDir = process.cwd()) {
+  const conflicts = await detectMcpConfigConflicts(providers, operations, projectDir);
+  const conflictKey = (providerId, serverName, scope) => `${providerId}::${serverName}::${scope}`;
+  const conflictMap = /* @__PURE__ */ new Map();
+  for (const conflict of conflicts) {
+    conflictMap.set(conflictKey(conflict.providerId, conflict.serverName, conflict.scope), conflict);
+  }
+  if (policy === "fail" && conflicts.length > 0) {
+    return { conflicts, applied: [], skipped: [] };
+  }
+  const applied = [];
+  const skipped = [];
+  for (const provider of providers) {
+    for (const operation of operations) {
+      const scope = operation.scope ?? "project";
+      const key = conflictKey(provider.id, operation.serverName, scope);
+      const conflict = conflictMap.get(key);
+      if (policy === "skip" && conflict) {
+        skipped.push({
+          providerId: provider.id,
+          serverName: operation.serverName,
+          scope,
+          reason: conflict.code
+        });
+        continue;
+      }
+      const result = await installMcpServer(
+        provider,
+        operation.serverName,
+        operation.config,
+        scope,
+        projectDir
+      );
+      applied.push(result);
+    }
+  }
+  return { conflicts, applied, skipped };
+}
+async function updateInstructionsSingleOperation(providers, content, scope = "project", projectDir = process.cwd()) {
+  const actions = await injectAll(providers, projectDir, scope, content);
+  const groupedByFile = groupByInstructFile(providers);
+  const summary = {
+    scope,
+    updatedFiles: actions.size,
+    actions: []
+  };
+  for (const [filePath, action] of actions.entries()) {
+    const providersForFile = providers.filter((provider) => {
+      const expectedPath = scope === "global" ? join8(provider.pathGlobal, provider.instructFile) : join8(projectDir, provider.instructFile);
+      return expectedPath === filePath;
+    });
+    const fallback = groupedByFile.get(basename2(filePath)) ?? [];
+    const selected = providersForFile.length > 0 ? providersForFile : fallback;
+    summary.actions.push({
+      file: filePath,
+      action,
+      providers: selected.map((provider) => provider.id),
+      configFormats: Array.from(new Set(selected.map((provider) => provider.configFormat)))
+    });
+  }
+  return summary;
+}
+async function configureProviderGlobalAndProject(provider, options) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const globalOps = options.globalMcp ?? [];
+  const projectOps = options.projectMcp ?? [];
+  const globalResults = [];
+  for (const operation of globalOps) {
+    globalResults.push(await installMcpServer(
+      provider,
+      operation.serverName,
+      operation.config,
+      "global",
+      projectDir
+    ));
+  }
+  const projectResults = [];
+  for (const operation of projectOps) {
+    projectResults.push(await installMcpServer(
+      provider,
+      operation.serverName,
+      operation.config,
+      "project",
+      projectDir
+    ));
+  }
+  const instructionResults = {};
+  const instructionContent = options.instructionContent;
+  if (typeof instructionContent === "string") {
+    instructionResults.global = await injectAll([provider], projectDir, "global", instructionContent);
+    instructionResults.project = await injectAll([provider], projectDir, "project", instructionContent);
+  } else if (instructionContent) {
+    if (instructionContent.global) {
+      instructionResults.global = await injectAll([provider], projectDir, "global", instructionContent.global);
+    }
+    if (instructionContent.project) {
+      instructionResults.project = await injectAll([provider], projectDir, "project", instructionContent.project);
+    }
+  }
+  return {
+    providerId: provider.id,
+    configPaths: {
+      global: resolveConfigPath(provider, "global", projectDir),
+      project: resolveConfigPath(provider, "project", projectDir)
+    },
+    mcp: {
+      global: globalResults,
+      project: projectResults
+    },
+    instructions: instructionResults
+  };
+}
+
 export {
   getAllProviders,
   getProvider,
@@ -2070,11 +2813,21 @@ export {
   removeSkillFromLock,
   getTrackedSkills,
   checkSkillUpdate,
+  formatNetworkError,
   MarketplaceClient,
   parseSkillFile,
   discoverSkill,
   discoverSkills,
   discoverSkillsMulti,
+  RECOMMENDATION_ERROR_CODES,
+  tokenizeCriteriaValue,
+  validateRecommendationCriteria,
+  normalizeRecommendationCriteria,
+  scoreSkillRecommendation,
+  rankSkills,
+  formatSkillRecommendations,
+  searchSkills,
+  recommendSkills2 as recommendSkills,
   scanFile,
   scanDirectory,
   toSarif,
@@ -2104,6 +2857,12 @@ export {
   checkAllInjections,
   injectAll,
   generateInjectionContent,
-  groupByInstructFile
+  groupByInstructFile,
+  selectProvidersByMinimumPriority,
+  installBatchWithRollback,
+  detectMcpConfigConflicts,
+  applyMcpInstallWithPolicy,
+  updateInstructionsSingleOperation,
+  configureProviderGlobalAndProject
 };
-//# sourceMappingURL=chunk-PCWTRJV2.js.map
+//# sourceMappingURL=chunk-ZYINKJDE.js.map