claudeos-core 2.2.0 → 2.3.0

package/lib/plan-parser.js

@@ -1,165 +1,165 @@
-/**
- * ClaudeOS-Core — Plan Parser (shared)
- *
- * Shared parsing logic for plan files used by both manifest-generator and plan-validator.
- * Two block formats:
- *   - <file path="..."> ... </file>   (standard plan format)
- *   - ## N. `path` \n```markdown ... ```  (code block format, e.g. sync-rules-master)
- *
- * Each function accepts a content string and returns parsed blocks.
- * Replace functions modify content in-place and return the updated string.
- */
-
-// ─── Extract <file path="..."> blocks ───────────────────────
-
-/**
- * Parse <file path="..."> ... </file> blocks from plan content.
- * @param {string} content - plan file content
- * @param {{ includeContent?: boolean }} options
- * @returns {Array<{ path: string, content?: string }>}
- */
-function parseFileBlocks(content, { includeContent = false } = {}) {
-  const result = [];
-  // Filter out placeholder paths that can appear in prose/documentation inside
-  // the plan file (e.g., a sentence like: use <file path="..."> to wrap files).
-  // Real paths are any non-empty string; only the literal ellipsis placeholders
-  // and angle-bracket templates are rejected.
-  const isRealPath = (p) =>
-    typeof p === "string" &&
-    p.length > 0 &&
-    p !== "..." &&
-    !p.startsWith("...") &&
-    !/^<[^>]+>$/.test(p);
-  if (includeContent) {
-    const re = /<file\s+path="([^"]+)">\s*\n([\s\S]*?)\n<\/file>/g;
-    let m;
-    while ((m = re.exec(content)) !== null) {
-      if (!isRealPath(m[1])) continue;
-      result.push({ path: m[1], content: m[2] });
-    }
-  } else {
-    const re = /<file\s+path="([^"]+)">/g;
-    let m;
-    while ((m = re.exec(content)) !== null) {
-      if (!isRealPath(m[1])) continue;
-      result.push({ path: m[1] });
-    }
-  }
-  return result;
-}
-
-// ─── Extract ## N. `path` ```markdown ... ``` blocks ────────
-
-/**
- * Parse ## N. `path` + ```markdown ... ``` blocks from plan content.
- * Uses indexOf-based parsing to correctly handle nested code fences.
- * @param {string} content - plan file content
- * @param {{ includeContent?: boolean }} options
- * @returns {Array<{ path: string, content?: string }>}
- */
-function parseCodeBlocks(content, { includeContent = false } = {}) {
-  const result = [];
-  const headingRe = includeContent
-    ? /^##\s+\d+\.\s+([^\n]+)/gm
-    : /^##\s+\d+\.\s+`?([^`\n]+)`?/gm;
-  let headingMatch;
-  while ((headingMatch = headingRe.exec(content)) !== null) {
-    const filePath = headingMatch[1].replace(/`/g, "").replace(/\s+[—–\-].*$/, "").trim();
-
-    if (!includeContent) {
-      // Path-only mode: just validate and collect
-      if (filePath && filePath.includes("/")) {
-        result.push({ path: filePath });
-      }
-      continue;
-    }
-
-    // Content mode: find opening ```markdown and matching closing ```
-    const openFence = content.indexOf("```markdown\n", headingMatch.index);
-    if (openFence < 0) continue;
-    const contentStart = openFence + "```markdown\n".length;
-    const closingPos = findClosingFence(content, contentStart);
-    if (closingPos < 0) continue;
-    const blockContent = content.substring(contentStart, closingPos).trimEnd();
-    result.push({ path: filePath, content: blockContent });
-    // Advance headingRe past this block to avoid re-matching inside content
-    headingRe.lastIndex = closingPos;
-  }
-  return result;
-}
-
-// ─── Replace <file> block content ───────────────────────────
-
-/**
- * Replace content inside a <file path="..."> block.
- * @param {string} content - full plan file content
- * @param {string} filePath - path attribute to match
- * @param {string} newContent - replacement content
- * @returns {string} updated content
- */
-function replaceFileBlock(content, filePath, newContent) {
-  // Escape regex special chars in filePath (for the pattern)
-  const escaped = filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  // CRITICAL: use a replacement *function* (not a string) to avoid
-  // `$1`/`$&`/`$$` special-character interpretation inside newContent.
-  // When users document things like `$1`, `price: $100`, or shell `$$PID`
-  // in their memory/rule/standard files, a string replacement would
-  // corrupt the data.
-  const re = new RegExp(`(<file\\s+path="${escaped}">\\s*\\n)[\\s\\S]*?(\\n</file>)`, "g");
-  return content.replace(re, (_match, open, close) => open + newContent + close);
-}
-
-// ─── Replace code block content ─────────────────────────────
-
-/**
- * Replace content inside a ## N. `path` ```markdown ... ``` block.
- * Uses indexOf-based approach to handle nested code fences.
- * @param {string} content - full plan file content
- * @param {string} filePath - path to match in heading
- * @param {string} newContent - replacement content
- * @returns {string} updated content
- */
-function replaceCodeBlock(content, filePath, newContent) {
-  const cleanPath = filePath.replace(/`/g, "");
-  const headingPattern = new RegExp(`^##\\s+\\d+\\.\\s+\`?${cleanPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`?`, "m");
-  const headingMatch = headingPattern.exec(content);
-  if (!headingMatch) return content;
-  const afterHeading = content.indexOf("```markdown\n", headingMatch.index);
-  if (afterHeading < 0) return content;
-  const contentStart = afterHeading + "```markdown\n".length;
-  const closingPos = findClosingFence(content, contentStart);
-  if (closingPos < 0) return content;
-  return content.substring(0, contentStart) + newContent + "\n" + content.substring(closingPos);
-}
-
-// ─── Internal: find closing ``` with nesting ────────────────
-
-function findClosingFence(content, startPos) {
-  let searchPos = startPos;
-  let nestDepth = 0;
-  while (searchPos < content.length) {
-    const nextFence = content.indexOf("\n```", searchPos);
-    if (nextFence < 0) break;
-    const fenceLineStart = nextFence + 1;
-    const nextNewline = content.indexOf("\n", fenceLineStart + 3);
-    const restOfLine = nextNewline >= 0
-      ? content.substring(fenceLineStart + 3, nextNewline)
-      : content.substring(fenceLineStart + 3);
-    const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
-    if (isOpening) {
-      nestDepth++;
-      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-    } else if (nestDepth > 0) {
-      nestDepth--;
-      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-    } else {
-      return fenceLineStart;
-    }
-  }
-  return -1;
-}
-
-// Plan files that use code block format instead of <file> block format
-const CODE_BLOCK_PLANS = ["21.sync-rules-master.md"];
-
-module.exports = { parseFileBlocks, parseCodeBlocks, replaceFileBlock, replaceCodeBlock, CODE_BLOCK_PLANS };
+/**
+ * ClaudeOS-Core — Plan Parser (shared)
+ *
+ * Shared parsing logic for plan files used by both manifest-generator and plan-validator.
+ * Two block formats:
+ *   - <file path="..."> ... </file>   (standard plan format)
+ *   - ## N. `path` \n```markdown ... ```  (code block format, e.g. sync-rules-master)
+ *
+ * Each function accepts a content string and returns parsed blocks.
+ * Replace functions modify content in-place and return the updated string.
+ */
+
+// ─── Extract <file path="..."> blocks ───────────────────────
+
+/**
+ * Parse <file path="..."> ... </file> blocks from plan content.
+ * @param {string} content - plan file content
+ * @param {{ includeContent?: boolean }} options
+ * @returns {Array<{ path: string, content?: string }>}
+ */
+function parseFileBlocks(content, { includeContent = false } = {}) {
+  const result = [];
+  // Filter out placeholder paths that can appear in prose/documentation inside
+  // the plan file (e.g., a sentence like: use <file path="..."> to wrap files).
+  // Real paths are any non-empty string; only the literal ellipsis placeholders
+  // and angle-bracket templates are rejected.
+  const isRealPath = (p) =>
+    typeof p === "string" &&
+    p.length > 0 &&
+    p !== "..." &&
+    !p.startsWith("...") &&
+    !/^<[^>]+>$/.test(p);
+  if (includeContent) {
+    const re = /<file\s+path="([^"]+)">\s*\n([\s\S]*?)\n<\/file>/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      if (!isRealPath(m[1])) continue;
+      result.push({ path: m[1], content: m[2] });
+    }
+  } else {
+    const re = /<file\s+path="([^"]+)">/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      if (!isRealPath(m[1])) continue;
+      result.push({ path: m[1] });
+    }
+  }
+  return result;
+}
+
+// ─── Extract ## N. `path` ```markdown ... ``` blocks ────────
+
+/**
+ * Parse ## N. `path` + ```markdown ... ``` blocks from plan content.
+ * Uses indexOf-based parsing to correctly handle nested code fences.
+ * @param {string} content - plan file content
+ * @param {{ includeContent?: boolean }} options
+ * @returns {Array<{ path: string, content?: string }>}
+ */
+function parseCodeBlocks(content, { includeContent = false } = {}) {
+  const result = [];
+  const headingRe = includeContent
+    ? /^##\s+\d+\.\s+([^\n]+)/gm
+    : /^##\s+\d+\.\s+`?([^`\n]+)`?/gm;
+  let headingMatch;
+  while ((headingMatch = headingRe.exec(content)) !== null) {
+    const filePath = headingMatch[1].replace(/`/g, "").replace(/\s+[—–\-].*$/, "").trim();
+
+    if (!includeContent) {
+      // Path-only mode: just validate and collect
+      if (filePath && filePath.includes("/")) {
+        result.push({ path: filePath });
+      }
+      continue;
+    }
+
+    // Content mode: find opening ```markdown and matching closing ```
+    const openFence = content.indexOf("```markdown\n", headingMatch.index);
+    if (openFence < 0) continue;
+    const contentStart = openFence + "```markdown\n".length;
+    const closingPos = findClosingFence(content, contentStart);
+    if (closingPos < 0) continue;
+    const blockContent = content.substring(contentStart, closingPos).trimEnd();
+    result.push({ path: filePath, content: blockContent });
+    // Advance headingRe past this block to avoid re-matching inside content
+    headingRe.lastIndex = closingPos;
+  }
+  return result;
+}
+
+// ─── Replace <file> block content ───────────────────────────
+
+/**
+ * Replace content inside a <file path="..."> block.
+ * @param {string} content - full plan file content
+ * @param {string} filePath - path attribute to match
+ * @param {string} newContent - replacement content
+ * @returns {string} updated content
+ */
+function replaceFileBlock(content, filePath, newContent) {
+  // Escape regex special chars in filePath (for the pattern)
+  const escaped = filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  // CRITICAL: use a replacement *function* (not a string) to avoid
+  // `$1`/`$&`/`$$` special-character interpretation inside newContent.
+  // When users document things like `$1`, `price: $100`, or shell `$$PID`
+  // in their memory/rule/standard files, a string replacement would
+  // corrupt the data.
+  const re = new RegExp(`(<file\\s+path="${escaped}">\\s*\\n)[\\s\\S]*?(\\n</file>)`, "g");
+  return content.replace(re, (_match, open, close) => open + newContent + close);
+}
+
+// ─── Replace code block content ─────────────────────────────
+
+/**
+ * Replace content inside a ## N. `path` ```markdown ... ``` block.
+ * Uses indexOf-based approach to handle nested code fences.
+ * @param {string} content - full plan file content
+ * @param {string} filePath - path to match in heading
+ * @param {string} newContent - replacement content
+ * @returns {string} updated content
+ */
+function replaceCodeBlock(content, filePath, newContent) {
+  const cleanPath = filePath.replace(/`/g, "");
+  const headingPattern = new RegExp(`^##\\s+\\d+\\.\\s+\`?${cleanPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`?`, "m");
+  const headingMatch = headingPattern.exec(content);
+  if (!headingMatch) return content;
+  const afterHeading = content.indexOf("```markdown\n", headingMatch.index);
+  if (afterHeading < 0) return content;
+  const contentStart = afterHeading + "```markdown\n".length;
+  const closingPos = findClosingFence(content, contentStart);
+  if (closingPos < 0) return content;
+  return content.substring(0, contentStart) + newContent + "\n" + content.substring(closingPos);
+}
+
+// ─── Internal: find closing ``` with nesting ────────────────
+
+function findClosingFence(content, startPos) {
+  let searchPos = startPos;
+  let nestDepth = 0;
+  while (searchPos < content.length) {
+    const nextFence = content.indexOf("\n```", searchPos);
+    if (nextFence < 0) break;
+    const fenceLineStart = nextFence + 1;
+    const nextNewline = content.indexOf("\n", fenceLineStart + 3);
+    const restOfLine = nextNewline >= 0
+      ? content.substring(fenceLineStart + 3, nextNewline)
+      : content.substring(fenceLineStart + 3);
+    const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
+    if (isOpening) {
+      nestDepth++;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
+    } else if (nestDepth > 0) {
+      nestDepth--;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
+    } else {
+      return fenceLineStart;
+    }
+  }
+  return -1;
+}
+
+// Plan files that use code block format instead of <file> block format
+const CODE_BLOCK_PLANS = ["21.sync-rules-master.md"];
+
+module.exports = { parseFileBlocks, parseCodeBlocks, replaceFileBlock, replaceCodeBlock, CODE_BLOCK_PLANS };

package/lib/staged-rules.js

@@ -1,118 +1,118 @@
-/**
- * ClaudeOS-Core — Staged Rules Mover
- *
- * Pass 3 and Pass 4 write rule files into
- *   claudeos-core/generated/.staged-rules/**
- * rather than
- *   .claude/rules/**
- * because Claude Code's sensitive-path policy blocks direct writes to
- * `.claude/` from the `claude -p` subprocess (even with
- * `--dangerously-skip-permissions`).
- *
- * After each pass, this module moves everything under the staging dir into the
- * real `.claude/rules/` tree, preserving subpaths, then removes the staging
- * dir. The Node.js orchestrator is not subject to Claude Code's policy, so the
- * final writes succeed.
- */
-
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Recursively list files under dir (absolute paths). Returns [] if dir missing.
- */
-function walkFiles(dir) {
-  const out = [];
-  if (!fs.existsSync(dir)) return out;
-  const stack = [dir];
-  while (stack.length > 0) {
-    const cur = stack.pop();
-    let entries;
-    try { entries = fs.readdirSync(cur, { withFileTypes: true }); }
-    catch (_e) { continue; }
-    for (const e of entries) {
-      const full = path.join(cur, e.name);
-      if (e.isDirectory()) stack.push(full);
-      else if (e.isFile()) out.push(full);
-    }
-  }
-  return out;
-}
-
-/**
- * Move a single file, falling back to copy+unlink if rename fails
- * (Windows cross-volume/overwrite edge cases).
- */
-function moveFile(src, dst) {
-  fs.mkdirSync(path.dirname(dst), { recursive: true });
-  try {
-    fs.renameSync(src, dst);
-    return;
-  } catch (_e) {
-    // Fallback: copy then unlink. copyFileSync overwrites by default.
-    fs.copyFileSync(src, dst);
-    try { fs.unlinkSync(src); } catch (_e2) { /* best-effort cleanup */ }
-  }
-}
-
-/**
- * Remove a directory tree. No-op if missing.
- */
-function removeDir(dir) {
-  if (!fs.existsSync(dir)) return;
-  fs.rmSync(dir, { recursive: true, force: true });
-}
-
-/**
- * Move everything from <projectRoot>/claudeos-core/generated/.staged-rules/**
- * to <projectRoot>/.claude/rules/**, preserving subpaths.
- *
- * @param {string} projectRoot - absolute path to the user's project root
- * @returns {{ moved: number, failed: number, files: string[], errors: string[], skipped: boolean }}
- *   - skipped: true when the staging dir does not exist (nothing to move)
- *   - files: list of subpaths moved (relative to .claude/rules/)
- *   - errors: per-file error messages (empty on full success)
- */
-function moveStagedRules(projectRoot) {
-  const stagingRoot = path.join(projectRoot, "claudeos-core", "generated", ".staged-rules");
-  const rulesRoot = path.join(projectRoot, ".claude", "rules");
-
-  if (!fs.existsSync(stagingRoot)) {
-    return { moved: 0, failed: 0, files: [], errors: [], skipped: true };
-  }
-
-  const staged = walkFiles(stagingRoot);
-  const result = { moved: 0, failed: 0, files: [], errors: [], skipped: false };
-
-  for (const srcAbs of staged) {
-    const rel = path.relative(stagingRoot, srcAbs);
-    const dstAbs = path.join(rulesRoot, rel);
-    try {
-      moveFile(srcAbs, dstAbs);
-      result.moved++;
-      result.files.push(rel.split(path.sep).join("/"));
-    } catch (e) {
-      result.failed++;
-      result.errors.push(`${rel}: ${e.code || e.message}`);
-    }
-  }
-
-  // Clean up the staging tree on full success; keep it on partial failure so
-  // the user (or a re-run) can inspect what didn't make it across.
-  if (result.failed === 0) {
-    try { removeDir(stagingRoot); } catch (_e) { /* non-fatal */ }
-  }
-
-  return result;
-}
-
-/**
- * Count the total number of regular files under a directory, recursively.
- * Returns 0 if the directory doesn't exist. Unreadable subdirectories are
- * skipped silently (consistent with walkFiles behavior).
- */
-function countFilesRecursive(dir) {
-  return walkFiles(dir).length;
-}
-
-module.exports = { moveStagedRules, countFilesRecursive };
+/**
+ * ClaudeOS-Core — Staged Rules Mover
+ *
+ * Pass 3 and Pass 4 write rule files into
+ *   claudeos-core/generated/.staged-rules/**
+ * rather than
+ *   .claude/rules/**
+ * because Claude Code's sensitive-path policy blocks direct writes to
+ * `.claude/` from the `claude -p` subprocess (even with
+ * `--dangerously-skip-permissions`).
+ *
+ * After each pass, this module moves everything under the staging dir into the
+ * real `.claude/rules/` tree, preserving subpaths, then removes the staging
+ * dir. The Node.js orchestrator is not subject to Claude Code's policy, so the
+ * final writes succeed.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Recursively list files under dir (absolute paths). Returns [] if dir missing.
+ */
+function walkFiles(dir) {
+  const out = [];
+  if (!fs.existsSync(dir)) return out;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(cur, { withFileTypes: true }); }
+    catch (_e) { continue; }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile()) out.push(full);
+    }
+  }
+  return out;
+}
+
+/**
+ * Move a single file, falling back to copy+unlink if rename fails
+ * (Windows cross-volume/overwrite edge cases).
+ */
+function moveFile(src, dst) {
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  try {
+    fs.renameSync(src, dst);
+    return;
+  } catch (_e) {
+    // Fallback: copy then unlink. copyFileSync overwrites by default.
+    fs.copyFileSync(src, dst);
+    try { fs.unlinkSync(src); } catch (_e2) { /* best-effort cleanup */ }
+  }
+}
+
+/**
+ * Remove a directory tree. No-op if missing.
+ */
+function removeDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+/**
+ * Move everything from <projectRoot>/claudeos-core/generated/.staged-rules/**
+ * to <projectRoot>/.claude/rules/**, preserving subpaths.
+ *
+ * @param {string} projectRoot - absolute path to the user's project root
+ * @returns {{ moved: number, failed: number, files: string[], errors: string[], skipped: boolean }}
+ *   - skipped: true when the staging dir does not exist (nothing to move)
+ *   - files: list of subpaths moved (relative to .claude/rules/)
+ *   - errors: per-file error messages (empty on full success)
+ */
+function moveStagedRules(projectRoot) {
+  const stagingRoot = path.join(projectRoot, "claudeos-core", "generated", ".staged-rules");
+  const rulesRoot = path.join(projectRoot, ".claude", "rules");
+
+  if (!fs.existsSync(stagingRoot)) {
+    return { moved: 0, failed: 0, files: [], errors: [], skipped: true };
+  }
+
+  const staged = walkFiles(stagingRoot);
+  const result = { moved: 0, failed: 0, files: [], errors: [], skipped: false };
+
+  for (const srcAbs of staged) {
+    const rel = path.relative(stagingRoot, srcAbs);
+    const dstAbs = path.join(rulesRoot, rel);
+    try {
+      moveFile(srcAbs, dstAbs);
+      result.moved++;
+      result.files.push(rel.split(path.sep).join("/"));
+    } catch (e) {
+      result.failed++;
+      result.errors.push(`${rel}: ${e.code || e.message}`);
+    }
+  }
+
+  // Clean up the staging tree on full success; keep it on partial failure so
+  // the user (or a re-run) can inspect what didn't make it across.
+  if (result.failed === 0) {
+    try { removeDir(stagingRoot); } catch (_e) { /* non-fatal */ }
+  }
+
+  return result;
+}
+
+/**
+ * Count the total number of regular files under a directory, recursively.
+ * Returns 0 if the directory doesn't exist. Unreadable subdirectories are
+ * skipped silently (consistent with walkFiles behavior).
+ */
+function countFilesRecursive(dir) {
+  return walkFiles(dir).length;
+}
+
+module.exports = { moveStagedRules, countFilesRecursive };