claudeos-core 1.2.3 → 1.3.0

package/plan-validator/index.js

@@ -39,12 +39,48 @@ function extractFileBlocks(content) {
 }
 
 // Extract ## N. `path` \n```markdown ... ``` blocks
+// Uses indexOf-based parsing to correctly handle nested code fences inside markdown content
 function extractCodeBlocks(content) {
   const result = [];
-  let m;
-  const re = /##\s+\d+\.\s+([^\n]+)\n+```markdown\n([\s\S]*?)```/g;
-  while ((m = re.exec(content)) !== null) {
-    result.push({ path: m[1].replace(/`/g, "").trim(), content: m[2].trimEnd() });
+  const headingRe = /^##\s+\d+\.\s+([^\n]+)/gm;
+  let headingMatch;
+  while ((headingMatch = headingRe.exec(content)) !== null) {
+    const filePath = headingMatch[1].replace(/`/g, "").trim();
+    // Find the opening ```markdown after the heading
+    const openFence = content.indexOf("```markdown\n", headingMatch.index);
+    if (openFence < 0) continue;
+    const contentStart = openFence + "```markdown\n".length;
+    // Find the matching closing ``` — track nesting depth to skip inner fenced blocks
+    let searchPos = contentStart;
+    let closingPos = -1;
+    let nestDepth = 0;
+    while (searchPos < content.length) {
+      const nextFence = content.indexOf("\n```", searchPos);
+      if (nextFence < 0) break;
+      const fenceLineStart = nextFence + 1; // position of ```
+      // Determine end of this ``` line
+      const nextNewline = content.indexOf("\n", fenceLineStart + 3);
+      const restOfLine = nextNewline >= 0
+        ? content.substring(fenceLineStart + 3, nextNewline)
+        : content.substring(fenceLineStart + 3);
+      // Opening fence: ``` followed by a language tag (non-empty alphanumeric text)
+      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 {
+        closingPos = fenceLineStart;
+        break;
+      }
+    }
+    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;
 }
@@ -70,24 +106,29 @@ function replaceCodeBlock(content, filePath, newContent) {
   const afterHeading = content.indexOf("```markdown\n", headingMatch.index);
   if (afterHeading < 0) return content;
   const contentStart = afterHeading + "```markdown\n".length;
-  // Find the closing ``` that is on its own line (not nested)
-  // Track nesting depth to skip inner fenced blocks
+  // Find the matching closing ``` — track nesting depth to skip inner fenced blocks
   let searchPos = contentStart;
   let closingPos = -1;
   let nestDepth = 0;
   while (searchPos < content.length) {
     const nextFence = content.indexOf("\n```", searchPos);
     if (nextFence < 0) break;
-    const lineAfterFence = content.substring(nextFence + 4, content.indexOf("\n", nextFence + 4));
-    const isOpening = lineAfterFence.trim().length > 0 && !lineAfterFence.startsWith("\n");
+    const fenceLineStart = nextFence + 1; // position of ```
+    // Determine end of this ``` line
+    const nextNewline = content.indexOf("\n", fenceLineStart + 3);
+    const restOfLine = nextNewline >= 0
+      ? content.substring(fenceLineStart + 3, nextNewline)
+      : content.substring(fenceLineStart + 3);
+    // Opening fence: ``` followed by a language tag (non-empty alphanumeric text)
+    const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
     if (isOpening) {
       nestDepth++;
-      searchPos = nextFence + 4;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
     } else if (nestDepth > 0) {
       nestDepth--;
-      searchPos = nextFence + 4;
+      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
     } else {
-      closingPos = nextFence + 1; // position of the closing ```
+      closingPos = fenceLineStart;
       break;
     }
   }
@@ -96,12 +137,18 @@ function replaceCodeBlock(content, filePath, newContent) {
 }
 
 async function main() {
+  const validModes = ["--check", "--refresh", "--execute"];
   const mode = process.argv[2] || "--check";
+  if (!validModes.includes(mode)) {
+    console.log(`  ❌ Unknown mode: ${mode}`);
+    console.log(`  Valid modes: ${validModes.join(", ")}`);
+    process.exit(1);
+  }
 
-  console.log("\n╔══════════════════════════════════════╗");
+  console.log("\n╔═══════════════════════════════════════╗");
   console.log("║  ClaudeOS-Core — Plan Validator       ║");
-  console.log(`║  Mode: ${mode.padEnd(30)}║`);
-  console.log("╚══════════════════════════════════════╝\n");
+  console.log(`║  Mode: ${mode.padEnd(31)}║`);
+  console.log("╚═══════════════════════════════════════╝\n");
 
   if (!fs.existsSync(PLAN)) {
     console.log("  ❌ Plan directory not found");
@@ -127,7 +174,7 @@ async function main() {
       const abs = path.join(ROOT, b.path);
 
       // Block path traversal attempts
-      if (!path.resolve(abs).startsWith(path.resolve(ROOT))) {
+      if (!path.resolve(abs).startsWith(path.resolve(ROOT) + path.sep)) {
         console.log(`     ⚠️  SKIPPED: ${b.path} (path traversal blocked)`);
         continue;
       }
@@ -148,9 +195,9 @@ async function main() {
         continue;
       }
 
-      // File exists — compare content
-      const diskContent = fs.readFileSync(abs, "utf-8").trimEnd();
-      const planContent = b.content.trimEnd();
+      // File exists — compare content (normalize trailing newlines only)
+      const diskContent = fs.readFileSync(abs, "utf-8").replace(/\n+$/, "");
+      const planContent = b.content.replace(/\n+$/, "");
 
       if (diskContent === planContent) {
         synced++;
@@ -187,15 +234,32 @@ async function main() {
   console.log(`\n  Total: ${total} | Synced: ${synced} | Drift: ${drift} | Missing: ${missing}`);
   console.log(drift + missing === 0 ? "  ✅ All plans in sync\n" : `  ⚠️  ${drift + missing} issues\n`);
 
-  // ─── Update plan-sync-status.json (separate from manifest-generator's plan-manifest.json) ──
+  // ─── Update plan-sync-status.json + stale-report.json ──
   if (fs.existsSync(GEN)) {
     fs.writeFileSync(
       path.join(GEN, "plan-sync-status.json"),
       JSON.stringify({ generatedAt: new Date().toISOString(), lastMode: mode, total, synced, drift, missing, issues: results }, null, 2)
     );
+
+    // Also write to stale-report.json for consolidated health reporting
+    const rp = path.join(GEN, "stale-report.json");
+    let ex = {};
+    if (fs.existsSync(rp)) {
+      try { ex = JSON.parse(fs.readFileSync(rp, "utf-8")); } catch { ex = {}; }
+    }
+    ex.planValidation = { checkedAt: new Date().toISOString(), mode, total, synced, drift, missing };
+    if (!ex.summary) ex.summary = {};
+    ex.summary.planDrift = drift;
+    ex.summary.planMissing = missing;
+    fs.writeFileSync(rp, JSON.stringify(ex, null, 2));
   }
 
   process.exit(drift + missing > 0 ? 1 : 0);
 }
 
-main().catch(console.error);
+// Export for testing; run main() only when executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = { extractFileBlocks, extractCodeBlocks, replaceFileBlock, replaceCodeBlock };

package/sync-checker/index.js

@@ -34,9 +34,9 @@ function rel(p) {
 }
 
 async function main() {
-  console.log("\n╔══════════════════════════════════════╗");
+  console.log("\n╔═══════════════════════════════════════╗");
   console.log("║  ClaudeOS-Core — Sync Checker         ║");
-  console.log("╚══════════════════════════════════════╝\n");
+  console.log("╚═══════════════════════════════════════╝\n");
 
   if (!fs.existsSync(SMP)) {
     console.log("  ❌ sync-map.json not found. Run manifest-generator first.\n");
@@ -50,6 +50,10 @@ async function main() {
     console.log(`  ❌ sync-map.json is malformed: ${e.message}\n`);
     process.exit(1);
   }
+  if (!Array.isArray(sm.mappings)) {
+    console.log("  ❌ sync-map.json has no mappings array.\n");
+    process.exit(1);
+  }
   const reg = new Set(sm.mappings.map((m) => m.sourcePath));
   const issues = { unreg: [], orphan: [] };
 
@@ -78,7 +82,7 @@ async function main() {
   for (const m of sm.mappings) {
     const abs = path.join(ROOT, m.sourcePath);
     // Skip path traversal attempts
-    if (!path.resolve(abs).startsWith(path.resolve(ROOT))) continue;
+    if (!path.resolve(abs).startsWith(path.resolve(ROOT) + path.sep)) continue;
     if (!fs.existsSync(abs)) {
       issues.orphan.push({ path: m.sourcePath, plan: m.planFile });
     }