@cleocode/caamp 1.7.1 → 1.8.1

package/dist/chunk-CPHF5IM4.js

@@ -0,0 +1,766 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/instructions/injector.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+
+// src/core/registry/providers.ts
+import { readFileSync } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+
+// src/core/paths/standard.ts
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+
+// src/core/platform-paths.ts
+import envPaths from "env-paths";
+import { arch, homedir, hostname, platform, release } from "os";
+import { isAbsolute, join, resolve } from "path";
+var APP_NAME = "agents";
+function resolveAgentsHomeOverride(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  if (trimmed === "~") return homedir();
+  if (trimmed.startsWith("~/")) return join(homedir(), trimmed.slice(2));
+  if (isAbsolute(trimmed)) return resolve(trimmed);
+  return resolve(homedir(), trimmed);
+}
+var _paths = null;
+var _sysInfo = null;
+var _lastAgentsHome = void 0;
+function getPlatformPaths() {
+  const currentAgentsHome = process.env["AGENTS_HOME"];
+  if (_paths && currentAgentsHome !== _lastAgentsHome) {
+    _paths = null;
+    _sysInfo = null;
+  }
+  if (_paths) return _paths;
+  const ep = envPaths(APP_NAME, { suffix: "" });
+  _lastAgentsHome = currentAgentsHome;
+  _paths = {
+    data: resolveAgentsHomeOverride(currentAgentsHome) ?? ep.data,
+    config: ep.config,
+    cache: ep.cache,
+    log: ep.log,
+    temp: ep.temp
+  };
+  return _paths;
+}
+function getSystemInfo() {
+  if (_sysInfo) return _sysInfo;
+  const paths = getPlatformPaths();
+  _sysInfo = {
+    platform: platform(),
+    arch: arch(),
+    release: release(),
+    hostname: hostname(),
+    nodeVersion: process.version,
+    paths
+  };
+  return _sysInfo;
+}
+function _resetPlatformPathsCache() {
+  _paths = null;
+  _sysInfo = null;
+  _lastAgentsHome = void 0;
+}
+
+// src/core/paths/standard.ts
+function getPlatformLocations() {
+  const home = homedir2();
+  const platform2 = process.platform;
+  if (platform2 === "win32") {
+    const appData = process.env["APPDATA"] ?? join2(home, "AppData", "Roaming");
+    return {
+      home,
+      config: appData,
+      vscodeConfig: join2(appData, "Code", "User"),
+      zedConfig: join2(appData, "Zed"),
+      claudeDesktopConfig: join2(appData, "Claude"),
+      applications: []
+    };
+  }
+  if (platform2 === "darwin") {
+    const config2 = process.env["XDG_CONFIG_HOME"] ?? join2(home, ".config");
+    return {
+      home,
+      config: config2,
+      vscodeConfig: join2(home, "Library", "Application Support", "Code", "User"),
+      zedConfig: join2(home, "Library", "Application Support", "Zed"),
+      claudeDesktopConfig: join2(home, "Library", "Application Support", "Claude"),
+      applications: ["/Applications", join2(home, "Applications")]
+    };
+  }
+  const config = process.env["XDG_CONFIG_HOME"] ?? join2(home, ".config");
+  return {
+    home,
+    config,
+    vscodeConfig: join2(config, "Code", "User"),
+    zedConfig: join2(config, "zed"),
+    claudeDesktopConfig: join2(config, "Claude"),
+    applications: []
+  };
+}
+function getAgentsHome() {
+  return getPlatformPaths().data;
+}
+function getProjectAgentsDir(projectRoot = process.cwd()) {
+  return join2(projectRoot, ".agents");
+}
+function resolveProjectPath(relativePath, projectDir = process.cwd()) {
+  return join2(projectDir, relativePath);
+}
+function getCanonicalSkillsDir() {
+  return join2(getAgentsHome(), "skills");
+}
+function getLockFilePath() {
+  return join2(getAgentsHome(), ".caamp-lock.json");
+}
+function getAgentsMcpDir(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "mcp");
+  return join2(projectDir ?? process.cwd(), ".agents", "mcp");
+}
+function getAgentsMcpServersPath(scope = "global", projectDir) {
+  return join2(getAgentsMcpDir(scope, projectDir), "servers.json");
+}
+function getAgentsInstructFile(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "AGENTS.md");
+  return join2(projectDir ?? process.cwd(), ".agents", "AGENTS.md");
+}
+function getAgentsConfigPath(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "config.toml");
+  return join2(projectDir ?? process.cwd(), ".agents", "config.toml");
+}
+function getAgentsWikiDir(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "wiki");
+  return join2(projectDir ?? process.cwd(), ".agents", "wiki");
+}
+function getAgentsSpecDir(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "spec");
+  return join2(projectDir ?? process.cwd(), ".agents", "spec");
+}
+function getAgentsLinksDir(scope = "global", projectDir) {
+  if (scope === "global") return join2(getAgentsHome(), "links");
+  return join2(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());
+}
+function resolveProviderConfigPath(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.configPathGlobal;
+  }
+  if (!provider.configPathProject) {
+    return null;
+  }
+  return resolveProjectPath(provider.configPathProject, projectDir);
+}
+function resolvePreferredConfigScope(provider, useGlobalFlag) {
+  if (useGlobalFlag) {
+    return "global";
+  }
+  return provider.configPathProject ? "project" : "global";
+}
+function resolveProviderSkillsDir(provider, scope, projectDir = process.cwd()) {
+  if (scope === "global") {
+    return provider.pathSkills;
+  }
+  return resolveProjectPath(provider.pathProjectSkills, projectDir);
+}
+function resolveProviderSkillsDirs(provider, scope, projectDir = process.cwd()) {
+  const vendorPath = resolveProviderSkillsDir(provider, scope, projectDir);
+  const precedence = provider.capabilities?.skills?.precedence ?? "vendor-only";
+  const resolveAgentsPath = () => {
+    if (scope === "global") {
+      return provider.capabilities?.skills?.agentsGlobalPath ?? null;
+    }
+    const projectRelative = provider.capabilities?.skills?.agentsProjectPath ?? null;
+    return projectRelative ? join2(projectDir, projectRelative) : null;
+  };
+  switch (precedence) {
+    case "vendor-only":
+      return [vendorPath];
+    case "agents-canonical": {
+      const agentsPath = resolveAgentsPath();
+      return agentsPath ? [agentsPath] : [vendorPath];
+    }
+    case "agents-first": {
+      const agentsPath = resolveAgentsPath();
+      return agentsPath ? [agentsPath, vendorPath] : [vendorPath];
+    }
+    case "agents-supported": {
+      const agentsPath = resolveAgentsPath();
+      return agentsPath ? [vendorPath, agentsPath] : [vendorPath];
+    }
+    case "vendor-global-agents-project": {
+      if (scope === "global") {
+        return [vendorPath];
+      }
+      const agentsPath = resolveAgentsPath();
+      return agentsPath ? [agentsPath, vendorPath] : [vendorPath];
+    }
+    default:
+      return [vendorPath];
+  }
+}
+function resolveProviderProjectPath(provider, projectDir = process.cwd()) {
+  return resolveProjectPath(provider.pathProject, projectDir);
+}
+function resolveProvidersRegistryPath(startDir) {
+  const candidates = [
+    join2(startDir, "..", "..", "..", "providers", "registry.json"),
+    join2(startDir, "..", "providers", "registry.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  let current = startDir;
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = join2(current, "providers", "registry.json");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    current = dirname(current);
+  }
+  throw new Error(`Cannot find providers/registry.json (searched from ${startDir})`);
+}
+function normalizeSkillSubPath(path) {
+  if (!path) return void 0;
+  const normalized = path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/SKILL\.md$/i, "").trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function buildSkillSubPathCandidates(marketplacePath, parsedPath) {
+  const candidates = [];
+  const base = normalizeSkillSubPath(marketplacePath);
+  const parsed = normalizeSkillSubPath(parsedPath);
+  if (base) candidates.push(base);
+  if (parsed) candidates.push(parsed);
+  const knownPrefixes = [".agents", ".claude"];
+  for (const value of [base, parsed]) {
+    if (!value || !value.startsWith("skills/")) continue;
+    for (const prefix of knownPrefixes) {
+      candidates.push(`${prefix}/${value}`);
+    }
+  }
+  if (candidates.length === 0) {
+    candidates.push(void 0);
+  }
+  return Array.from(new Set(candidates));
+}
+
+// src/core/registry/providers.ts
+var DEFAULT_SKILLS_CAPABILITY = {
+  agentsGlobalPath: null,
+  agentsProjectPath: null,
+  precedence: "vendor-only"
+};
+var DEFAULT_HOOKS_CAPABILITY = {
+  supported: [],
+  hookConfigPath: null,
+  hookFormat: null
+};
+var DEFAULT_SPAWN_CAPABILITY = {
+  supportsSubagents: false,
+  supportsProgrammaticSpawn: false,
+  supportsInterAgentComms: false,
+  supportsParallelSpawn: false,
+  spawnMechanism: null
+};
+function resolveCapabilities(raw) {
+  const skills = raw?.skills ? {
+    agentsGlobalPath: raw.skills.agentsGlobalPath ? resolveRegistryTemplatePath(raw.skills.agentsGlobalPath) : null,
+    agentsProjectPath: raw.skills.agentsProjectPath,
+    precedence: raw.skills.precedence
+  } : { ...DEFAULT_SKILLS_CAPABILITY };
+  const hooks = raw?.hooks ? {
+    supported: raw.hooks.supported,
+    hookConfigPath: raw.hooks.hookConfigPath ? resolveRegistryTemplatePath(raw.hooks.hookConfigPath) : null,
+    hookFormat: raw.hooks.hookFormat
+  } : { ...DEFAULT_HOOKS_CAPABILITY, supported: [] };
+  const spawn = raw?.spawn ? {
+    supportsSubagents: raw.spawn.supportsSubagents,
+    supportsProgrammaticSpawn: raw.spawn.supportsProgrammaticSpawn,
+    supportsInterAgentComms: raw.spawn.supportsInterAgentComms,
+    supportsParallelSpawn: raw.spawn.supportsParallelSpawn,
+    spawnMechanism: raw.spawn.spawnMechanism
+  } : { ...DEFAULT_SPAWN_CAPABILITY };
+  return { skills, hooks, spawn };
+}
+function findRegistryPath() {
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
+  return resolveProvidersRegistryPath(thisDir);
+}
+var _registry = null;
+var _providers = null;
+var _aliasMap = null;
+function resolveProvider(raw) {
+  return {
+    id: raw.id,
+    toolName: raw.toolName,
+    vendor: raw.vendor,
+    agentFlag: raw.agentFlag,
+    aliases: raw.aliases,
+    pathGlobal: resolveRegistryTemplatePath(raw.pathGlobal),
+    pathProject: raw.pathProject,
+    instructFile: raw.instructFile,
+    configKey: raw.configKey,
+    configFormat: raw.configFormat,
+    configPathGlobal: resolveRegistryTemplatePath(raw.configPathGlobal),
+    configPathProject: raw.configPathProject,
+    pathSkills: resolveRegistryTemplatePath(raw.pathSkills),
+    pathProjectSkills: raw.pathProjectSkills,
+    detection: {
+      methods: raw.detection.methods,
+      binary: raw.detection.binary,
+      directories: raw.detection.directories?.map(resolveRegistryTemplatePath),
+      appBundle: raw.detection.appBundle,
+      flatpakId: raw.detection.flatpakId
+    },
+    supportedTransports: raw.supportedTransports,
+    supportsHeaders: raw.supportsHeaders,
+    priority: raw.priority,
+    status: raw.status,
+    agentSkillsCompatible: raw.agentSkillsCompatible,
+    capabilities: resolveCapabilities(raw.capabilities)
+  };
+}
+function loadRegistry() {
+  if (_registry) return _registry;
+  const registryPath = findRegistryPath();
+  const raw = readFileSync(registryPath, "utf-8");
+  _registry = JSON.parse(raw);
+  return _registry;
+}
+function ensureProviders() {
+  if (_providers) return;
+  const registry = loadRegistry();
+  _providers = /* @__PURE__ */ new Map();
+  _aliasMap = /* @__PURE__ */ new Map();
+  for (const [id, raw] of Object.entries(registry.providers)) {
+    const provider = resolveProvider(raw);
+    _providers.set(id, provider);
+    for (const alias of provider.aliases) {
+      _aliasMap.set(alias, id);
+    }
+  }
+}
+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);
+}
+function resolveAlias(idOrAlias) {
+  ensureProviders();
+  return _aliasMap?.get(idOrAlias) ?? idOrAlias;
+}
+function getProvidersByPriority(priority) {
+  return getAllProviders().filter((p) => p.priority === priority);
+}
+function getProvidersByStatus(status) {
+  return getAllProviders().filter((p) => p.status === status);
+}
+function getProvidersByInstructFile(file) {
+  return getAllProviders().filter((p) => p.instructFile === file);
+}
+function getInstructionFiles() {
+  const files = /* @__PURE__ */ new Set();
+  for (const p of getAllProviders()) {
+    files.add(p.instructFile);
+  }
+  return Array.from(files);
+}
+function getProviderCount() {
+  ensureProviders();
+  return _providers?.size ?? 0;
+}
+function getRegistryVersion() {
+  return loadRegistry().version;
+}
+function getProvidersByHookEvent(event) {
+  return getAllProviders().filter((p) => p.capabilities.hooks.supported.includes(event));
+}
+function getCommonHookEvents(providerIds) {
+  const providers = providerIds && providerIds.length > 0 ? providerIds.map((id) => getProvider(id)).filter((p) => p !== void 0) : getAllProviders();
+  if (providers.length === 0) return [];
+  const first = providers[0].capabilities.hooks.supported;
+  return first.filter(
+    (event) => providers.every((p) => p.capabilities.hooks.supported.includes(event))
+  );
+}
+function providerSupports(provider, dotPath) {
+  const parts = dotPath.split(".");
+  let current = provider.capabilities;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return false;
+    current = current[part];
+  }
+  if (typeof current === "boolean") return current;
+  if (Array.isArray(current)) return current.length > 0;
+  return current != null;
+}
+function getSpawnCapableProviders() {
+  return getAllProviders().filter((p) => p.capabilities.spawn.supportsSubagents);
+}
+function getProvidersBySpawnCapability(flag) {
+  return getAllProviders().filter((p) => p.capabilities.spawn[flag] === true);
+}
+function getProvidersBySkillsPrecedence(precedence) {
+  return getAllProviders().filter((p) => p.capabilities.skills.precedence === precedence);
+}
+function getEffectiveSkillsPaths(provider, scope, projectDir) {
+  const vendorPath = resolveProviderSkillsDir(provider, scope, projectDir);
+  const { precedence, agentsGlobalPath, agentsProjectPath } = provider.capabilities.skills;
+  const resolveAgentsPath = () => {
+    if (scope === "global" && agentsGlobalPath) return agentsGlobalPath;
+    if (scope === "project" && agentsProjectPath && projectDir) {
+      return join3(projectDir, agentsProjectPath);
+    }
+    return null;
+  };
+  const agentsPath = resolveAgentsPath();
+  const scopeLabel = scope === "global" ? "global" : "project";
+  switch (precedence) {
+    case "vendor-only":
+      return [{ path: vendorPath, source: "vendor", scope: scopeLabel }];
+    case "agents-canonical":
+      return agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : [];
+    case "agents-first":
+      return [
+        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : [],
+        { path: vendorPath, source: "vendor", scope: scopeLabel }
+      ];
+    case "agents-supported":
+      return [
+        { path: vendorPath, source: "vendor", scope: scopeLabel },
+        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: scopeLabel }] : []
+      ];
+    case "vendor-global-agents-project":
+      if (scope === "global") {
+        return [{ path: vendorPath, source: "vendor", scope: "global" }];
+      }
+      return [
+        ...agentsPath ? [{ path: agentsPath, source: "agents", scope: "project" }] : [],
+        { path: vendorPath, source: "vendor", scope: "project" }
+      ];
+    default:
+      return [{ path: vendorPath, source: "vendor", scope: scopeLabel }];
+  }
+}
+function buildSkillsMap() {
+  return getAllProviders().map((p) => {
+    const { precedence, agentsGlobalPath, agentsProjectPath } = p.capabilities.skills;
+    const isVendorOnly = precedence === "vendor-only";
+    return {
+      providerId: p.id,
+      toolName: p.toolName,
+      precedence,
+      paths: {
+        global: isVendorOnly ? p.pathSkills : agentsGlobalPath ?? null,
+        project: isVendorOnly ? p.pathProjectSkills : agentsProjectPath ?? null
+      }
+    };
+  });
+}
+function getProviderCapabilities(idOrAlias) {
+  return getProvider(idOrAlias)?.capabilities;
+}
+function providerSupportsById(idOrAlias, capabilityPath) {
+  const provider = getProvider(idOrAlias);
+  if (!provider) return false;
+  return providerSupports(provider, capabilityPath);
+}
+
+// src/core/instructions/templates.ts
+function buildInjectionContent(template) {
+  const lines = [];
+  for (const ref of template.references) {
+    lines.push(ref);
+  }
+  if (template.content && template.content.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(...template.content);
+  }
+  return lines.join("\n");
+}
+function parseInjectionContent(content) {
+  const references = [];
+  const contentLines = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("@")) {
+      references.push(trimmed);
+    } else {
+      contentLines.push(line);
+    }
+  }
+  return {
+    references,
+    content: contentLines.length > 0 ? contentLines : void 0
+  };
+}
+function generateInjectionContent(options) {
+  const lines = [];
+  lines.push("## CAAMP Managed Configuration");
+  lines.push("");
+  lines.push("This section is managed by [CAAMP](https://github.com/caamp/caamp).");
+  lines.push("Do not edit between the CAAMP markers manually.");
+  if (options?.mcpServerName) {
+    lines.push("");
+    lines.push(`### MCP Server: ${options.mcpServerName}`);
+    lines.push(`Configured via \`caamp mcp install\`.`);
+  }
+  if (options?.customContent) {
+    lines.push("");
+    lines.push(options.customContent);
+  }
+  return lines.join("\n");
+}
+function generateSkillsSection(skillNames) {
+  if (skillNames.length === 0) return "";
+  const lines = [];
+  lines.push("### Installed Skills");
+  lines.push("");
+  for (const name of skillNames) {
+    lines.push(`- \`${name}\` - Available via SKILL.md`);
+  }
+  return lines.join("\n");
+}
+function groupByInstructFile(providers) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const provider of providers) {
+    const existing = groups.get(provider.instructFile) ?? [];
+    existing.push(provider);
+    groups.set(provider.instructFile, existing);
+  }
+  return groups;
+}
+
+// src/core/instructions/injector.ts
+var MARKER_START = "<!-- CAAMP:START -->";
+var MARKER_END = "<!-- CAAMP:END -->";
+var MARKER_PATTERN = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/g;
+var MARKER_PATTERN_SINGLE = /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/;
+async function checkInjection(filePath, expectedContent) {
+  if (!existsSync2(filePath)) return "missing";
+  const content = await readFile(filePath, "utf-8");
+  if (!MARKER_PATTERN_SINGLE.test(content)) return "none";
+  if (expectedContent) {
+    const blockContent = extractBlock(content);
+    if (blockContent && blockContent.trim() === expectedContent.trim()) {
+      return "current";
+    }
+    return "outdated";
+  }
+  return "current";
+}
+function extractBlock(content) {
+  const match = content.match(MARKER_PATTERN_SINGLE);
+  if (!match) return null;
+  return match[0].replace(MARKER_START, "").replace(MARKER_END, "").trim();
+}
+function buildBlock(content) {
+  return `${MARKER_START}
+${content}
+${MARKER_END}`;
+}
+async function inject(filePath, content) {
+  const block = buildBlock(content);
+  await mkdir(dirname3(filePath), { recursive: true });
+  if (!existsSync2(filePath)) {
+    await writeFile(filePath, `${block}
+`, "utf-8");
+    return "created";
+  }
+  const existing = await readFile(filePath, "utf-8");
+  const matches = existing.match(MARKER_PATTERN);
+  if (matches && matches.length > 0) {
+    if (matches.length > 1) {
+      const updated3 = existing.replace(MARKER_PATTERN, "").replace(/^\n{2,}/, "\n").trim();
+      const finalContent = updated3 ? `${block}
+
+${updated3}` : `${block}
+`;
+      await writeFile(filePath, finalContent, "utf-8");
+      return "consolidated";
+    }
+    const existingBlock = extractBlock(existing);
+    if (existingBlock !== null && existingBlock.trim() === content.trim()) {
+      return "intact";
+    }
+    const updated2 = existing.replace(MARKER_PATTERN_SINGLE, block);
+    await writeFile(filePath, updated2, "utf-8");
+    return "updated";
+  }
+  const updated = `${block}
+
+${existing}`;
+  await writeFile(filePath, updated, "utf-8");
+  return "added";
+}
+async function removeInjection(filePath) {
+  if (!existsSync2(filePath)) return false;
+  const content = await readFile(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 } = await import("fs/promises");
+    await rm(filePath);
+  } else {
+    await writeFile(filePath, `${cleaned}
+`, "utf-8");
+  }
+  return true;
+}
+async function checkAllInjections(providers, projectDir, scope, expectedContent) {
+  const results = [];
+  const checked = /* @__PURE__ */ new Set();
+  for (const provider of providers) {
+    const filePath = scope === "global" ? join4(provider.pathGlobal, provider.instructFile) : join4(projectDir, provider.instructFile);
+    if (checked.has(filePath)) continue;
+    checked.add(filePath);
+    const status = await checkInjection(filePath, expectedContent);
+    results.push({
+      file: filePath,
+      provider: provider.id,
+      status,
+      fileExists: existsSync2(filePath)
+    });
+  }
+  return results;
+}
+async function injectAll(providers, projectDir, scope, content) {
+  const results = /* @__PURE__ */ new Map();
+  const injected = /* @__PURE__ */ new Set();
+  for (const provider of providers) {
+    const filePath = scope === "global" ? join4(provider.pathGlobal, provider.instructFile) : join4(projectDir, provider.instructFile);
+    if (injected.has(filePath)) continue;
+    injected.add(filePath);
+    const action = await inject(filePath, content);
+    results.set(filePath, action);
+  }
+  return results;
+}
+async function ensureProviderInstructionFile(providerId, projectDir, options) {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    throw new Error(`Unknown provider: "${providerId}". Check CAAMP provider registry.`);
+  }
+  const scope = options.scope ?? "project";
+  const filePath = scope === "global" ? join4(provider.pathGlobal, provider.instructFile) : join4(projectDir, provider.instructFile);
+  const template = {
+    references: options.references,
+    content: options.content
+  };
+  const injectionContent = buildInjectionContent(template);
+  const action = await inject(filePath, injectionContent);
+  return {
+    filePath,
+    instructFile: provider.instructFile,
+    action,
+    providerId: provider.id
+  };
+}
+async function ensureAllProviderInstructionFiles(providerIds, projectDir, options) {
+  const results = [];
+  const processed = /* @__PURE__ */ new Set();
+  for (const providerId of providerIds) {
+    const provider = getProvider(providerId);
+    if (!provider) {
+      throw new Error(`Unknown provider: "${providerId}". Check CAAMP provider registry.`);
+    }
+    const scope = options.scope ?? "project";
+    const filePath = scope === "global" ? join4(provider.pathGlobal, provider.instructFile) : join4(projectDir, provider.instructFile);
+    if (processed.has(filePath)) continue;
+    processed.add(filePath);
+    const template = {
+      references: options.references,
+      content: options.content
+    };
+    const injectionContent = buildInjectionContent(template);
+    const action = await inject(filePath, injectionContent);
+    results.push({
+      filePath,
+      instructFile: provider.instructFile,
+      action,
+      providerId: provider.id
+    });
+  }
+  return results;
+}
+
+export {
+  __export,
+  getPlatformPaths,
+  getSystemInfo,
+  _resetPlatformPathsCache,
+  getPlatformLocations,
+  getAgentsHome,
+  getProjectAgentsDir,
+  getCanonicalSkillsDir,
+  getLockFilePath,
+  getAgentsMcpDir,
+  getAgentsMcpServersPath,
+  getAgentsInstructFile,
+  getAgentsConfigPath,
+  getAgentsWikiDir,
+  getAgentsSpecDir,
+  getAgentsLinksDir,
+  resolveRegistryTemplatePath,
+  resolveProviderConfigPath,
+  resolvePreferredConfigScope,
+  resolveProviderSkillsDir,
+  resolveProviderSkillsDirs,
+  resolveProviderProjectPath,
+  buildSkillSubPathCandidates,
+  getAllProviders,
+  getProvider,
+  resolveAlias,
+  getProvidersByPriority,
+  getProvidersByStatus,
+  getProvidersByInstructFile,
+  getInstructionFiles,
+  getProviderCount,
+  getRegistryVersion,
+  getProvidersByHookEvent,
+  getCommonHookEvents,
+  providerSupports,
+  getSpawnCapableProviders,
+  getProvidersBySpawnCapability,
+  getProvidersBySkillsPrecedence,
+  getEffectiveSkillsPaths,
+  buildSkillsMap,
+  getProviderCapabilities,
+  providerSupportsById,
+  buildInjectionContent,
+  parseInjectionContent,
+  generateInjectionContent,
+  generateSkillsSection,
+  groupByInstructFile,
+  checkInjection,
+  inject,
+  removeInjection,
+  checkAllInjections,
+  injectAll,
+  ensureProviderInstructionFile,
+  ensureAllProviderInstructionFiles
+};
+//# sourceMappingURL=chunk-CPHF5IM4.js.map