claudeos-core 1.6.1 → 1.6.2

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [1.6.2] — 2026-04-09
+
+### Fixed
+
+- **Sync command crash bypass** — `cli.js` sync throw from `cmdHealth`/`cmdValidate`/`cmdRestore`/`cmdRefresh` now correctly caught by `.catch()` handler; previously caused unhandled exception
+- **`init.js` group.domains crash** — Null guard added for `group.domains` and `group.estimatedFiles` in domain-groups iteration; prevents TypeError on malformed `domain-groups.json`
+- **Kotlin shared query resolution failure** — `scan-kotlin.js` full key (`__` separator) module names now converted back to path form (`/`) before file matching; `resolveSharedQueryDomains` was silently failing to find any files
+- **Python scanner Windows glob failure** — `scan-python.js` added `dir.replace(/\\/g, "/")` for Django and FastAPI/Flask glob patterns; Windows `path.dirname` returns backslashes that break glob (same fix `scan-node.js` already had)
+- **`prompt-generator.js` langData.labels crash** — Added null guard for `langData.labels` access; prevents TypeError when `lang-instructions.json` has `instructions` but missing `labels` key
+- **Plan parser heading description leakage** — `plan-parser.js` `parseCodeBlocks` now strips trailing ` — description` / ` – description` / ` - description` from heading; previously included in `filePath`
+- **Content validator regex escape** — `content-validator/index.js` regex character class now correctly escapes `[` and `]`; previously `[` was unescaped, causing runtime error when keyword contains `[`
+- **Manifest generator CODE_BLOCK_PLANS count** — `plan-manifest.json` now uses `extractCodeBlockPathsFromFile` for code-block-format plans (e.g., `21.sync-rules-master.md`); `fileBlocks` count was always 0
+- **Resume pass1/pass2 inconsistency** — When "continue" is selected but no pass1 files exist while pass2 does, pass2 is now deleted to force re-run; previously new pass1 + stale pass2 caused data mismatch
+- **`--force` incomplete cleanup** — Now deletes all `.json` and `.md` files in `generated/` directory (not just pass1/pass2); ensures truly fresh start including stale prompts, manifests, and reports
+- **Workspace path without wildcard** — `stack-detector.js` now handles concrete workspace paths (e.g., `packages/backend`) by scanning both direct and child `package.json` files; previously only glob patterns with `*` worked
+- **Framework-less Python projects skipped** — `structure-scanner.js` now triggers Python scanner for all `language === "python"` projects; previously required `framework` to be `django`/`fastapi`/`flask`
+- **Root directory router.py false domain** — `scan-python.js` now skips `name === "."` when `router.py` is in project root; previously created a domain named `.`
+- **Sync checker null sourcePath** — `sync-checker/index.js` now skips mappings with null/undefined `sourcePath`; previously produced `path.join(ROOT, undefined)` = `"ROOT/undefined"`
+- **Java Pattern B/D detection instability** — `scan-java.js` `detectedPattern` now determined by majority vote across all domains; previously depended on first `Object.keys` insertion order
+- **Duplicate pass1 prompt overwrite** — `prompt-generator.js` deduplicates `activeTemplates` via `Set`; when backend and frontend share the same template, pass1 is generated once instead of being overwritten
+- **Health checker stale-report overwrite** — Removed redundant `generatedAt` write that was overwriting `manifest-generator`'s `summaryPatch`; manifest-generator (run as prerequisite) already sets this key
+- **Plan validator empty file creation** — `--execute` mode now skips file creation when plan block has empty/whitespace-only content; previously created blank files
+
 ## [1.6.1] — 2026-04-09
 
 ### Fixed

package/bin/cli.js

@@ -130,7 +130,7 @@ if (!commands[command]) {
   process.exit(1);
 }
 
-Promise.resolve(commands[command]()).catch((e) => {
+Promise.resolve().then(() => commands[command]()).catch((e) => {
   if (e instanceof InitError) {
     log(`\n  ❌ ${e.message}\n`);
   } else {

package/bin/commands/init.js

@@ -96,9 +96,9 @@ async function cmdInit(parsedArgs) {
 
     if (existingPass1.length > 0 || pass2Exists) {
       if (parsedArgs.force) {
-        // --force: delete without prompt
-        for (const f of existingPass1) fs.unlinkSync(path.join(GENERATED_DIR, f));
-        if (pass2Exists) fs.unlinkSync(path.join(GENERATED_DIR, "pass2-merged.json"));
+        // --force: clean all generated files for truly fresh start
+        const genFiles = fs.readdirSync(GENERATED_DIR).filter(f => f.endsWith(".json") || f.endsWith(".md"));
+        for (const f of genFiles) fs.unlinkSync(path.join(GENERATED_DIR, f));
         log("  🔄 Previous results deleted (--force)\n");
       } else {
         const status = { pass1Done: existingPass1.length, pass2Done: pass2Exists };
@@ -107,6 +107,10 @@ async function cmdInit(parsedArgs) {
         if (mode === "fresh") {
           for (const f of existingPass1) fs.unlinkSync(path.join(GENERATED_DIR, f));
           if (pass2Exists) fs.unlinkSync(path.join(GENERATED_DIR, "pass2-merged.json"));
+        } else if (mode === "continue" && existingPass1.length === 0 && pass2Exists) {
+          // pass2 exists but no pass1 → pass2 is stale, force re-run
+          fs.unlinkSync(path.join(GENERATED_DIR, "pass2-merged.json"));
+          log("    ⚠️  pass2-merged.json deleted (no pass1 files to continue from)");
         }
       }
     }
@@ -202,8 +206,8 @@ async function cmdInit(parsedArgs) {
   }
   for (let i = 1; i <= totalGroups; i++) {
     const group = domainGroups.groups[i - 1];
-    const domainList = group.domains.join(", ");
-    const estFiles = group.estimatedFiles;
+    const domainList = (group.domains || []).join(", ") || "(unknown)";
+    const estFiles = group.estimatedFiles || 0;
     const groupType = group.type || "backend";
     const icon = groupType === "frontend" ? "🎨" : "⚙️";
 

package/content-validator/index.js

@@ -85,7 +85,7 @@ async function main() {
     for (let i = 0; i < enKeywords.length; i++) {
       const candidates = [enKeywords[i], langKeywords[i]].filter(Boolean);
       const found = candidates.some(kw => {
-        const re = new RegExp(`(^|#|\\s)${kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "im");
+        const re = new RegExp(`(^|#|\\s)${kw.replace(/[.*+?^${}()|\\[\]\\\\]/g, "\\$&")}`, "im");
         return re.test(content);
       });
       if (!found) {

package/health-checker/index.js

@@ -113,7 +113,6 @@ function main() {
   console.log("  ══════════════════════════════\n");
 
   // ─── Update stale-report.json ────────────────────────────
-  updateStaleReport(GEN, "generatedAt", new Date().toISOString());
   updateStaleReport(GEN, "healthCheck",
     { results, status: hasErr ? "fail" : "pass" },
     { totalIssues: results.filter((r) => r.status === "fail").length, healthStatus: hasErr ? "fail" : "ok" }

package/lib/plan-parser.js

@@ -52,7 +52,7 @@ function parseCodeBlocks(content, { includeContent = false } = {}) {
     : /^##\s+\d+\.\s+`?([^`\n]+)`?/gm;
   let headingMatch;
   while ((headingMatch = headingRe.exec(content)) !== null) {
-    const filePath = headingMatch[1].replace(/`/g, "").trim();
+    const filePath = headingMatch[1].replace(/`/g, "").replace(/\s+[—–\-].*$/, "").trim();
 
     if (!includeContent) {
       // Path-only mode: just validate and collect

package/manifest-generator/index.js

@@ -148,7 +148,10 @@ async function main() {
     for (const p of await glob("*.md", { cwd: DIRS.plan, absolute: true })) {
       const r = rel(p);
       const s = stat(p);
-      const blocks = extractFileBlocksFromFile(p);
+      const bn = path.basename(p);
+      const blocks = CODE_BLOCK_PLANS.includes(bn)
+        ? extractCodeBlockPathsFromFile(p)
+        : extractFileBlocksFromFile(p);
       pm.plans.push({ path: r, ...s, fileBlocks: blocks.length, status: "ok" });
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeos-core",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Auto-generate Claude Code documentation from your actual source code — Standards, Rules, Skills, and Guides tailored to your project",
   "main": "bin/cli.js",
   "bin": {

package/plan-installer/prompt-generator.js

@@ -29,7 +29,8 @@ function generatePrompts(templates, lang, templatesDir, generatedDir) {
     const langData = readJsonSafe(langPath);
     if (langData && langData.instructions && langData.instructions[lang]) {
       langInstruction = langData.instructions[lang];
-      console.log(`    🌐 Language: ${langData.labels[lang]} (Pass 3 output)`);
+      const label = (langData.labels && langData.labels[lang]) || lang;
+      console.log(`    🌐 Language: ${label} (Pass 3 output)`);
     }
   }
 
@@ -39,7 +40,7 @@ function generatePrompts(templates, lang, templatesDir, generatedDir) {
     return readFileSafe(src);
   }
 
-  const activeTemplates = [templates.backend, templates.frontend].filter(Boolean);
+  const activeTemplates = [...new Set([templates.backend, templates.frontend].filter(Boolean))];
   const primaryTemplate = templates.backend || templates.frontend;
 
   for (let ti = 0; ti < activeTemplates.length; ti++) {

package/plan-installer/scanners/scan-java.js

@@ -69,7 +69,12 @@ async function scanJavaDomains(stack, ROOT) {
         domainMap[d].controllers += entries.length;
       }
     }
-    if (Object.keys(domainMap).length > 0) detectedPattern = domainMap[Object.keys(domainMap)[0]].pattern;
+    if (Object.keys(domainMap).length > 0) {
+      // Determine pattern by majority vote (B vs D)
+      const patternCounts = {};
+      for (const v of Object.values(domainMap)) patternCounts[v.pattern] = (patternCounts[v.pattern] || 0) + 1;
+      detectedPattern = Object.entries(patternCounts).sort((a, b) => b[1] - a[1])[0][0];
+    }
   }
 
   // Pattern E: DDD/Hexagonal — {domain}/adapter/in/web/*.java or {domain}/adapter/in/rest/*.java

package/plan-installer/scanners/scan-kotlin.js

@@ -262,7 +262,10 @@ function resolveSharedQueryDomains(backendDomains, ktFiles) {
   for (const shared of sharedModules) {
     const moduleNames = shared.modules || [];
     const sharedKtFiles = ktFiles.filter(f =>
-      moduleNames.some(m => f.includes(`/${m}/`) || f.startsWith(`${m}/`))
+      moduleNames.some(m => {
+        const p = m.includes("__") ? m.replace(/__/g, "/") : m;
+        return f.includes(`/${p}/`) || f.startsWith(`${p}/`);
+      })
     );
     if (sharedKtFiles.length === 0) continue;
 

package/plan-installer/scanners/scan-python.js

@@ -17,7 +17,7 @@ async function scanPythonDomains(stack, ROOT) {
       const dir = path.dirname(f);
       if (dir === "." || dir.includes("venv")) continue;
       const name = path.basename(dir);
-      const appFiles = await glob(`${dir}/*.py`, { cwd: ROOT });
+      const appFiles = await glob(`${dir.replace(/\\/g, "/")}/*.py`, { cwd: ROOT });
       const views = appFiles.filter(x => x.includes("views")).length;
       const models = appFiles.filter(x => x.includes("models")).length;
       const serializers = appFiles.filter(x => x.includes("serializers")).length;
@@ -25,16 +25,16 @@ async function scanPythonDomains(stack, ROOT) {
     }
   }
 
-  // ── FastAPI / Flask ──
-  if (stack.framework === "fastapi" || stack.framework === "flask") {
+  // ── FastAPI / Flask / generic Python ──
+  if (stack.framework === "fastapi" || stack.framework === "flask" || (stack.language === "python" && stack.framework !== "django")) {
     const routerFiles = await glob("**/{router,routes,endpoints}*.py", { cwd: ROOT, ignore: ["**/venv/**", "**/.venv/**"] });
     const seen = new Set();
     for (const f of routerFiles) {
       const dir = path.dirname(f);
       const name = path.basename(dir);
-      if (seen.has(name) || ["venv", ".venv", "__pycache__"].includes(name)) continue;
+      if (name === "." || seen.has(name) || ["venv", ".venv", "__pycache__"].includes(name)) continue;
       seen.add(name);
-      const appFiles = await glob(`${dir}/*.py`, { cwd: ROOT });
+      const appFiles = await glob(`${dir.replace(/\\/g, "/")}/*.py`, { cwd: ROOT });
       backendDomains.push({ name, type: "backend", totalFiles: appFiles.length });
     }
     if (backendDomains.filter(d => d.type === "backend").length === 0) {

package/plan-installer/stack-detector.js

@@ -267,7 +267,9 @@ async function detectStack(ROOT) {
         const subPkgGlobs = ["{apps,packages}/*/package.json"];
         if (stack.workspaces) {
           for (const ws of stack.workspaces) {
-            const wsGlob = ws.replace(/\/?\*?\*?$/, "/*/package.json");
+            const wsGlob = /[*?]/.test(ws)
+              ? ws.replace(/\/?\*?\*?$/, "/*/package.json")
+              : `${ws.replace(/\/?$/, "")}/{,*/}package.json`;
             if (!subPkgGlobs.includes(wsGlob)) subPkgGlobs.push(wsGlob);
           }
         }

package/plan-installer/structure-scanner.js

@@ -41,7 +41,7 @@ async function scanStructure(stack, ROOT) {
     backendDomains.push(...r.backendDomains);
   }
 
-  if (stack.framework === "django" || stack.framework === "fastapi" || stack.framework === "flask") {
+  if (stack.language === "python") {
     const r = await scanPythonDomains(stack, ROOT);
     backendDomains.push(...r.backendDomains);
   }

package/plan-validator/index.js

@@ -88,6 +88,10 @@ async function main() {
       // File does not exist
       if (!fs.existsSync(abs)) {
         if (mode === "--execute") {
+          if (!b.content || b.content.trim().length === 0) {
+            console.log(`     ⚠️  SKIPPED: ${b.path} (empty content in plan)`);
+            continue;
+          }
           const dir = path.dirname(abs);
           if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
           fs.writeFileSync(abs, b.content + "\n");

package/sync-checker/index.js

@@ -91,6 +91,7 @@ async function main() {
   // ─── [2/2] Plan → Disk: detect orphaned files ───────────────
   console.log("  [2/2] Plan → Disk...");
   for (const m of sm.mappings) {
+    if (!m.sourcePath) continue;
     const abs = path.join(ROOT, m.sourcePath);
     // Skip path traversal attempts (allow files at ROOT level and below)
     if (!isWithinRoot(abs)) continue;