@cleocode/caamp 2026.8.1 → 2026.8.2

package/dist/{chunk-EH5U4PRC.js → chunk-3IQUGSIV.js}

@@ -1,4 +1,5 @@
 import {
+  getAgentsHome,
   resolveProviderSkillsDir,
   resolveProvidersRegistryPath,
   resolveRegistryTemplatePath
@@ -6,13 +7,80 @@ import {
 
 // src/core/instructions/injector.ts
 import { existsSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { readFile as readFile2, stat as stat2 } from "fs/promises";
 import { homedir } from "os";
-import { dirname as dirname2, join as join2 } from "path";
+import { join as join2 } from "path";
+import { writeFileAtomic } from "@cleocode/core/tools/fs.js";
+
+// src/core/fs/atomic.ts
+import { mkdir, open, readFile, rm, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var DEFAULT_LOCK_RETRIES = 400;
+var DEFAULT_LOCK_DELAY_MS = 25;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function removeStaleGuard(guardPath, staleMs, expectedToken) {
+  try {
+    const info = await stat(guardPath);
+    if (Date.now() - info.mtimeMs <= staleMs) return false;
+    const current = await readFile(guardPath, "utf-8").catch(() => null);
+    if (expectedToken !== null && current !== null && current !== expectedToken) return false;
+    await rm(guardPath, { force: true });
+    return true;
+  } catch {
+  }
+  return false;
+}
+async function withFileLock(targetPath, fn, options = {}) {
+  const retries = options.retries ?? DEFAULT_LOCK_RETRIES;
+  const delayMs = options.delayMs ?? DEFAULT_LOCK_DELAY_MS;
+  const staleMs = options.staleMs ?? DEFAULT_STALE_LOCK_MS;
+  const guardPath = `${targetPath}.lock`;
+  const token = `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2, 12)}`;
+  await mkdir(dirname(targetPath), { recursive: true });
+  let acquired = false;
+  for (let attempt = 0; attempt < retries && !acquired; attempt += 1) {
+    try {
+      const handle = await open(guardPath, "wx");
+      await handle.close();
+      await writeFile(guardPath, token, "utf-8");
+      acquired = true;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      const observed = await readFile(guardPath, "utf-8").catch(() => null);
+      if (await removeStaleGuard(guardPath, staleMs, observed)) continue;
+      await sleep(delayMs);
+    }
+  }
+  if (!acquired) {
+    throw new Error(
+      `Timed out acquiring lock for ${targetPath} after ${retries} attempts (~${Math.round(retries * delayMs / 1e3)}s)`
+    );
+  }
+  try {
+    return await fn();
+  } finally {
+    const current = await readFile(guardPath, "utf-8").catch(() => null);
+    if (current === null || current === token) {
+      await rm(guardPath, { force: true }).catch(() => {
+      });
+    }
+  }
+}
+function assertNotTornRead(filePath, content, sizeOnDisk) {
+  if (content.length === 0 && sizeOnDisk > 0) {
+    throw new Error(
+      `Refusing to rewrite ${filePath}: read 0 bytes but the file is ${sizeOnDisk} bytes on disk (torn read from a concurrent non-atomic writer).`
+    );
+  }
+}
 
 // src/core/registry/providers.ts
 import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname as dirname2, join } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_SKILLS_CAPABILITY = {
   agentsGlobalPath: null,
@@ -91,7 +159,7 @@ function resolveCapabilities(raw) {
   return { mcp, harness, skills, hooks, spawn };
 }
 function findRegistryPath() {
-  const thisDir = dirname(fileURLToPath(import.meta.url));
+  const thisDir = dirname2(fileURLToPath(import.meta.url));
   return resolveProvidersRegistryPath(thisDir);
 }
 var _registry = null;
@@ -281,6 +349,102 @@ function providerSupportsById(idOrAlias, capabilityPath) {
   return providerSupports(provider, capabilityPath);
 }
 
+// src/core/instructions/markers.ts
+import {
+  CAAMP_BLOCK_PATTERN_SOURCE,
+  CAAMP_DAMAGED_END_PATTERN_SOURCE,
+  CAAMP_DAMAGED_START_PATTERN_SOURCE,
+  CAAMP_MARKER_END,
+  CAAMP_MARKER_START
+} from "@cleocode/contracts/caamp-markers";
+function blockPattern() {
+  return new RegExp(CAAMP_BLOCK_PATTERN_SOURCE, "g");
+}
+function normalizeMarkers(content) {
+  let repaired = 0;
+  const heal = (input, source, canonical) => input.replace(new RegExp(source, "gmi"), (match) => {
+    if (match === canonical) return match;
+    repaired += 1;
+    return canonical;
+  });
+  let out = heal(content, CAAMP_DAMAGED_START_PATTERN_SOURCE, CAAMP_MARKER_START);
+  out = heal(out, CAAMP_DAMAGED_END_PATTERN_SOURCE, CAAMP_MARKER_END);
+  return { content: out, repaired };
+}
+function parseBlocks(fileContent) {
+  const blocks = [];
+  const pattern = blockPattern();
+  for (let match = pattern.exec(fileContent); match !== null; match = pattern.exec(fileContent)) {
+    const raw = match[0];
+    blocks.push({
+      raw,
+      content: (match[1] ?? "").trim(),
+      startIndex: match.index,
+      endIndex: match.index + raw.length
+    });
+  }
+  return blocks;
+}
+function buildBlock(content) {
+  return `${CAAMP_MARKER_START}
+${content}
+${CAAMP_MARKER_END}`;
+}
+function tidy(content) {
+  const collapsed = content.replace(/\n{3,}/g, "\n\n").trimEnd();
+  return collapsed.length > 0 ? `${collapsed}
+` : "";
+}
+function reconcile(existing, desiredContent, insert = "prepend") {
+  const { content: healed, repaired } = normalizeMarkers(existing);
+  const blocks = parseBlocks(healed);
+  const desiredBlock = buildBlock(desiredContent.trim());
+  if (blocks.length === 0) {
+    const body = healed.trim();
+    if (body.length === 0) return { content: tidy(desiredBlock), blocksBefore: 0, repaired };
+    return {
+      content: insert === "append" ? tidy(`${body}
+
+${desiredBlock}`) : tidy(`${desiredBlock}
+
+${body}`),
+      blocksBefore: 0,
+      repaired
+    };
+  }
+  let out = "";
+  let cursor = 0;
+  for (const [index, block] of blocks.entries()) {
+    out += healed.slice(cursor, block.startIndex);
+    cursor = block.endIndex;
+    if (index === 0) out += desiredBlock;
+  }
+  out += healed.slice(cursor);
+  return { content: tidy(out), blocksBefore: blocks.length, repaired };
+}
+function mergeBlockBodies(blocks) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const block of blocks) {
+    for (const line of block.content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      lines.push(trimmed);
+    }
+  }
+  return lines.join("\n");
+}
+function repairContent(existing) {
+  const { content: healed, repaired } = normalizeMarkers(existing);
+  const blocks = parseBlocks(healed);
+  if (blocks.length === 0) {
+    return { content: healed, blocksBefore: 0, repaired };
+  }
+  const merged = reconcile(healed, mergeBlockBodies(blocks));
+  return { content: merged.content, blocksBefore: blocks.length, repaired };
+}
+
 // src/core/instructions/templates.ts
 function buildInjectionContent(template) {
   const lines = [];
@@ -350,56 +514,51 @@ function groupByInstructFile(providers) {
 }
 
 // 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 -->/;
 function parseCaampBlocks(fileContent) {
-  const blocks = [];
-  const pattern = /<!-- CAAMP:START -->([\s\S]*?)<!-- CAAMP:END -->/g;
-  for (let match = pattern.exec(fileContent); match !== null; match = pattern.exec(fileContent)) {
-    const raw = match[0];
-    const innerContent = match[1] ?? "";
-    blocks.push({
-      raw,
-      content: innerContent.trim(),
-      startIndex: match.index,
-      endIndex: match.index + raw.length
-    });
-  }
-  return blocks;
+  return parseBlocks(fileContent);
 }
 async function dedupeFile(filePath) {
   if (!existsSync(filePath)) {
-    return { filePath, removed: 0, kept: 0, modified: false };
-  }
-  const fileContent = await readFile(filePath, "utf-8");
-  const blocks = parseCaampBlocks(fileContent);
-  if (blocks.length === 0) {
-    return { filePath, removed: 0, kept: 0, modified: false };
-  }
-  const lastByContent = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    lastByContent.set(block.content, block);
-  }
-  const keepSet = new Set(lastByContent.values());
-  const removed = blocks.length - keepSet.size;
-  if (removed === 0) {
-    return { filePath, removed: 0, kept: blocks.length, modified: false };
+    return { filePath, removed: 0, kept: 0, modified: false, repaired: 0 };
   }
-  let result = "";
-  let cursor = 0;
-  for (const block of blocks) {
-    result += fileContent.slice(cursor, block.startIndex);
-    cursor = block.endIndex;
-    if (keepSet.has(block)) {
-      result += block.raw;
+  return withFileLock(filePath, async () => {
+    const original = await readFile2(filePath, "utf-8");
+    const { content: healed, repaired } = normalizeMarkers(original);
+    const blocks = parseBlocks(healed);
+    if (blocks.length === 0) {
+      if (repaired > 0 && healed !== original) {
+        await writeFileAtomic({ path: filePath, content: healed });
+        return { filePath, removed: 0, kept: 0, modified: true, repaired };
+      }
+      return { filePath, removed: 0, kept: 0, modified: false, repaired };
     }
-  }
-  result += fileContent.slice(cursor);
-  result = result.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-  await writeFile(filePath, result, "utf-8");
-  return { filePath, removed, kept: keepSet.size, modified: true };
+    const lastByContent = /* @__PURE__ */ new Map();
+    for (const block of blocks) {
+      lastByContent.set(block.content, block);
+    }
+    const keepSet = new Set(lastByContent.values());
+    const removed = blocks.length - keepSet.size;
+    let result = "";
+    let cursor = 0;
+    for (const block of blocks) {
+      result += healed.slice(cursor, block.startIndex);
+      cursor = block.endIndex;
+      if (keepSet.has(block)) {
+        result += block.raw;
+      }
+    }
+    result += healed.slice(cursor);
+    result = `${result.replace(/\n{3,}/g, "\n\n").trimEnd()}
+`;
+    if (removed === 0 && repaired === 0) {
+      return { filePath, removed: 0, kept: blocks.length, modified: false, repaired };
+    }
+    if (result === original) {
+      return { filePath, removed: 0, kept: blocks.length, modified: false, repaired };
+    }
+    await writeFileAtomic({ path: filePath, content: result });
+    return { filePath, removed, kept: keepSet.size, modified: true, repaired };
+  });
 }
 async function dedupeFiles(filePaths) {
   const results = [];
@@ -408,76 +567,102 @@ async function dedupeFiles(filePaths) {
   }
   return results;
 }
+function instructionFileCascade(projectDir, providers) {
+  const paths = [
+    join2(getAgentsHome(), "AGENTS.md"),
+    join2(projectDir, "AGENTS.md"),
+    join2(projectDir, "CLAUDE.md"),
+    join2(projectDir, "GEMINI.md")
+  ];
+  for (const provider of providers) {
+    paths.push(join2(provider.pathGlobal, provider.instructFile));
+  }
+  return [...new Set(paths)];
+}
+async function repairInstructionFiles(projectDir, providers) {
+  const paths = instructionFileCascade(projectDir, providers).filter((p) => existsSync(p));
+  const files = [];
+  for (const filePath of paths) {
+    files.push(
+      await withFileLock(filePath, async () => {
+        const original = await readFile2(filePath, "utf-8");
+        const { content, blocksBefore, repaired } = repairContent(original);
+        const removed = Math.max(0, blocksBefore - 1);
+        if (removed === 0 && repaired === 0) {
+          return { filePath, removed: 0, kept: blocksBefore, modified: false, repaired: 0 };
+        }
+        if (content === original) {
+          return { filePath, removed: 0, kept: blocksBefore, modified: false, repaired };
+        }
+        await writeFileAtomic({ path: filePath, content });
+        return {
+          filePath,
+          removed,
+          kept: blocksBefore > 0 ? 1 : 0,
+          modified: true,
+          repaired
+        };
+      })
+    );
+  }
+  return {
+    files,
+    repaired: files.reduce((n, r) => n + r.repaired, 0),
+    removed: files.reduce((n, r) => n + r.removed, 0),
+    filesModified: files.filter((r) => r.modified).length
+  };
+}
 async function checkInjection(filePath, expectedContent) {
   if (!existsSync(filePath)) return "missing";
-  const content = await readFile(filePath, "utf-8");
-  if (!MARKER_PATTERN_SINGLE.test(content)) return "none";
+  const raw = await readFile2(filePath, "utf-8");
+  const { content, repaired } = normalizeMarkers(raw);
+  const blocks = parseBlocks(content);
+  if (blocks.length === 0) return "none";
+  if (blocks.length > 1 || repaired > 0) return "outdated";
   if (expectedContent) {
-    const blockContent = extractBlock(content);
-    if (blockContent && blockContent.trim() === expectedContent.trim()) {
-      return "current";
-    }
-    return "outdated";
+    return blocks[0]?.content === expectedContent.trim() ? "current" : "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(dirname2(filePath), { recursive: true });
+  const body = content.trim();
   if (!existsSync(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";
+    return withFileLock(filePath, async () => {
+      await writeFileAtomic({ path: filePath, content: `${buildBlock(body)}
+` });
+      return "created";
+    });
+  }
+  return withFileLock(filePath, async () => {
+    const existing = await readFile2(filePath, "utf-8");
+    if (existing.length === 0) {
+      assertNotTornRead(filePath, existing, (await stat2(filePath)).size);
     }
-    const updated2 = existing.replace(MARKER_PATTERN_SINGLE, block);
-    await writeFile(filePath, updated2, "utf-8");
+    const { content: next, blocksBefore, repaired } = reconcile(existing, body);
+    if (next === existing) return "intact";
+    await writeFileAtomic({ path: filePath, content: next });
+    if (blocksBefore === 0) return "added";
+    if (repaired > 0) return "repaired";
+    if (blocksBefore > 1) return "consolidated";
     return "updated";
-  }
-  const updated = `${block}
-
-${existing}`;
-  await writeFile(filePath, updated, "utf-8");
-  return "added";
+  });
 }
 async function removeInjection(filePath) {
   if (!existsSync(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;
+  return withFileLock(filePath, async () => {
+    const original = await readFile2(filePath, "utf-8");
+    const { content } = normalizeMarkers(original);
+    if (parseBlocks(content).length === 0) return false;
+    const cleaned = content.replace(blockPattern(), "").replace(/^\n{2,}/, "\n").trim();
+    if (!cleaned) {
+      const { rm: rm2 } = await import("fs/promises");
+      await rm2(filePath);
+    } else {
+      await writeFileAtomic({ path: filePath, content: `${cleaned}
+` });
+    }
+    return true;
+  });
 }
 async function checkAllInjections(providers, projectDir, scope, expectedContent) {
   const results = [];
@@ -608,6 +793,8 @@ async function writeAgentFileToAllProviders(providerIds, options) {
 }
 
 export {
+  withFileLock,
+  assertNotTornRead,
   getAllProviders,
   getProvider,
   resolveAlias,
@@ -629,6 +816,13 @@ export {
   buildSkillsMap,
   getProviderCapabilities,
   providerSupportsById,
+  blockPattern,
+  normalizeMarkers,
+  parseBlocks,
+  buildBlock,
+  reconcile,
+  mergeBlockBodies,
+  repairContent,
   buildInjectionContent,
   parseInjectionContent,
   generateInjectionContent,
@@ -637,6 +831,8 @@ export {
   parseCaampBlocks,
   dedupeFile,
   dedupeFiles,
+  instructionFileCascade,
+  repairInstructionFiles,
   checkInjection,
   inject,
   removeInjection,
@@ -647,4 +843,4 @@ export {
   getProviderAgentFolder,
   writeAgentFileToAllProviders
 };
-//# sourceMappingURL=chunk-EH5U4PRC.js.map
+//# sourceMappingURL=chunk-3IQUGSIV.js.map