claudeos-core 2.3.2 → 2.4.1

package/pass-prompts/templates/vue-nuxt/pass3.md

@@ -47,18 +47,18 @@ Generation targets:
    - 00.core/01.project-overview.md — Stack, routing approach, deployment environment
    - 00.core/02.architecture.md — Nuxt/Vue structure, component hierarchy, data flow, Nitro server
    - 00.core/03.naming-conventions.md — File/component/composable/store naming conventions
-   - 20.frontend-ui/01.component-patterns.md — SFC, <script setup>, Props/Emits, slots, provide/inject
-   - 20.frontend-ui/02.page-routing-patterns.md — Pages/layouts/dynamic routes/middleware/definePageMeta
-   - 20.frontend-ui/03.data-fetching.md — useFetch, useAsyncData, $fetch, server routes, caching
-   - 20.frontend-ui/04.state-management.md — Pinia stores, composables, useState, form state
-   - 20.frontend-ui/05.styling-patterns.md — Scoped styles, CSS Modules, Tailwind/UnoCSS, theming
-   - 10.backend-api/01.server-routes.md — Nitro server routes (server/api/), H3 event handlers
+   - 20.frontend/01.component-patterns.md — SFC, <script setup>, Props/Emits, slots, provide/inject
+   - 20.frontend/02.page-routing-patterns.md — Pages/layouts/dynamic routes/middleware/definePageMeta
+   - 20.frontend/03.data-fetching.md — useFetch, useAsyncData, $fetch, server routes, caching
+   - 20.frontend/04.state-management.md — Pinia stores, composables, useState, form state
+   - 20.frontend/05.styling-patterns.md — Scoped styles, CSS Modules, Tailwind/UnoCSS, theming
+   - 10.backend/01.server-routes.md — Nitro server routes (server/api/), H3 event handlers
    - 30.security-db/01.security-auth.md — Auth, middleware protection, environment variables
    - 40.infra/01.environment-config.md — Runtime config, nuxt.config.ts, Nitro presets
    - 40.infra/02.logging-monitoring.md — Error tracking, analytics, Web Vitals
    - 40.infra/03.cicd-deployment.md — CI/CD, deployment (Vercel/Netlify/Docker), preview
-   - 50.verification/01.development-verification.md — Build, startup, Lighthouse
-   - 50.verification/02.testing-strategy.md — Vitest, @vue/test-utils, E2E, @nuxt/test-utils
+   - 80.verification/01.development-verification.md — Build, startup, Lighthouse
+   - 80.verification/02.testing-strategy.md — Vitest, @vue/test-utils, E2E, @nuxt/test-utils
 
    Each file MUST include:
    - Correct examples (✅ code blocks)
@@ -80,6 +80,7 @@ Generation targets:
      - `40.infra/03.cicd-deployment-rules.md` paths: `["**/*.yml", "**/*.yaml", "**/Dockerfile*", "**/*.ts", "**/*.vue"]` — CI config + source
      - `50.sync/*` rules: `paths: ["**/claudeos-core/**", "**/.claude/**"]`
      - `60.memory/*` rules: forward reference — Pass 4 will generate 4 files (01.decision-log, 02.failure-patterns, 03.compaction, 04.auto-rule-update), each with file-specific `paths`. Pass 3 must STILL list ```.claude/rules/60.memory/*``` as a row in CLAUDE.md Section 6 Rules table so developers/Claude see the category exists.
+     - `70.domains/*` rules (multi-domain projects only): per-domain rules at `.claude/rules/70.domains/{type}/{domain}-rules.md` (where `{type}` is `backend` or `frontend`, ALWAYS present even in single-stack projects for uniform layout + zero-migration future-proofing), each with a `paths:` glob scoped to that domain's source directories so the rule auto-loads only when editing files within the relevant domain. Folder name is PLURAL (`domains/`) — collection of N per-domain files — and each file inside uses the SINGULAR domain name (`{domain}-rules.md`). DO NOT use `60.domains/` (collides with `60.memory/`) and DO NOT skip the `{type}/` sub-folder. See pass3-footer.md "Per-domain folder convention" for the full rationale.
    - MUST generate `.claude/rules/00.core/00.standard-reference.md` — directory of all standard files
 
 4. .claude/rules/50.sync/ (2 sync rules)

package/plan-installer/domain-grouper.js

@@ -5,22 +5,62 @@
  * and selects appropriate templates based on detected stack.
  */
 
+// ─── Splitting thresholds ───────────────────────────────────────
+//
+// MAX_FILES_PER_GROUP and MAX_DOMAINS_PER_GROUP are the original budgets that
+// have governed Pass 1 batching since v1.x. They are sound for projects with
+// a roughly uniform file-size distribution but can produce time-outlier
+// batches when a single domain contains a very large file (e.g. a 2500-line
+// TUI Grid wrapper) — observed in field testing where a group of ~29
+// files ran ~70% longer than a group of 39 files.
+//
+// MAX_LINES_PER_GROUP is the optional second axis. It only fires when the
+// caller supplies per-domain `totalLines`; scanners that do not yet record
+// line counts leave it unset and the line-budget check is skipped, so this
+// field is strictly additive (no behavior change for existing scanners).
+//
+// The 8000-line threshold is a pragmatic starting point calibrated against
+// observed field tests: ~40 files × ~200 lines/file average. It can be
+// tuned later once more scanners populate `totalLines` and we have more
+// data on per-stack line-count distributions.
+const MAX_FILES_PER_GROUP = 40;
+const MAX_DOMAINS_PER_GROUP = 4;
+const MAX_LINES_PER_GROUP = 8000;
+
 function splitDomainGroups(domains, type, template) {
-  const MAX_FILES_PER_GROUP = 40;
-  const MAX_DOMAINS_PER_GROUP = 4;
   const groups = [];
   let current = [];
   let fileCount = 0;
+  let lineCount = 0;
 
   for (const d of domains) {
-    // Flush current group before adding if it would exceed limits
-    if (current.length > 0 && (fileCount + d.totalFiles > MAX_FILES_PER_GROUP || current.length >= MAX_DOMAINS_PER_GROUP)) {
+    // Read `totalLines` as an optional signal. Domains produced by scanners
+    // that have not yet been extended to record line counts leave this
+    // undefined, which makes the line-budget check a no-op (0 + undefined
+    // stays undefined; the `hasLines` guard below suppresses the comparison
+    // entirely in that case). This preserves exact byte-for-byte output for
+    // all existing callers.
+    const domainLines = (typeof d.totalLines === "number" && d.totalLines >= 0) ? d.totalLines : 0;
+    const hasLines = domainLines > 0;
+
+    // Flush current group before adding if it would exceed any budget.
+    // The line-budget condition (`hasLines && ...`) is only evaluated when
+    // the incoming domain actually carries line-count data — callers using
+    // the legacy `{ name, totalFiles }` shape retain the original 2-axis
+    // behavior.
+    const wouldExceedFiles = fileCount + d.totalFiles > MAX_FILES_PER_GROUP;
+    const wouldExceedDomains = current.length >= MAX_DOMAINS_PER_GROUP;
+    const wouldExceedLines = hasLines && (lineCount + domainLines > MAX_LINES_PER_GROUP);
+
+    if (current.length > 0 && (wouldExceedFiles || wouldExceedDomains || wouldExceedLines)) {
       groups.push({ type, template, domains: [...current], estimatedFiles: fileCount });
       current = [];
       fileCount = 0;
+      lineCount = 0;
     }
     current.push(d.name);
     fileCount += d.totalFiles;
+    lineCount += domainLines;
   }
   if (current.length > 0) {
     groups.push({ type, template, domains: [...current], estimatedFiles: fileCount });
@@ -38,7 +78,7 @@ function determineActiveDomains(stack) {
     "20.frontend": !!stack.frontend,
     "30.security-db": !!(stack.database || isBackend || stack.frontend),
     "40.infra": true,
-    "50.verification": true,
+    "80.verification": true,
     "90.optional": true,
   };
 }

package/plan-installer/index.js

@@ -40,7 +40,17 @@ async function main() {
     console.warn("  Ensure you have build.gradle, package.json, pyproject.toml, or requirements.txt in the project root.\n");
   }
   console.log(`    Frontend:    ${stack.frontend || "none"} ${stack.frontendVersion || ""}`);
-  console.log(`    Database:    ${stack.database || "none"}`);
+  // v2.4.0 — when a project ships more than one DB driver (e.g. Oracle +
+  // MySQL master/slave), surface the full list so downstream LLMs (Pass 1)
+  // see the dual-dialect setup without having to re-derive it from source
+  // code. Singular `Database:` line preserved for byte-for-byte parity in
+  // single-DB projects (the dominant case).
+  if (Array.isArray(stack.databases) && stack.databases.length > 1) {
+    console.log(`    Database:    ${stack.database} (primary)`);
+    console.log(`    Databases:   ${stack.databases.join(", ")} (multi-dialect)`);
+  } else {
+    console.log(`    Database:    ${stack.database || "none"}`);
+  }
   console.log(`    ORM:         ${stack.orm || "none"}`);
   console.log(`    PackageMgr:  ${stack.packageManager || "none"}\n`);
 

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

@@ -22,9 +22,42 @@ async function scanJavaDomains(stack, ROOT) {
   let rootPackage = null;
 
   const javaFiles = (await glob("src/main/java/**/*.java", { cwd: ROOT })).map(norm);
+
+  // v2.4.0 — Pick the LONGEST package prefix (1-4 segments) that still
+  // covers ≥80% of layer-bearing files. Pre-v2.4.0 the first matched file
+  // won, which misclassified projects whose actual production code lives
+  // under one root (e.g. `<orgA>.<projectA>.*`) but where a small number
+  // of stub files happen to sit under another deeper subtree (e.g.
+  // `<orgA>.<otherModule>.core.<dir>.*`) — glob enumeration order then
+  // determined the rootPackage non-deterministically.
+  //
+  // Algorithm: count every (1-, 2-, 3-, 4-)segment prefix preceding a
+  // known layer marker. Then pick the longest prefix whose count is at
+  // least 80% of the maximum (1-segment) count. This gives:
+  //   • Mono-package project (`com.example.app.*` only): root = `com.example.app`
+  //     (all 4 prefix lengths tied, longest = most specific root).
+  //   • Multi-module project (95% under `<root>.api.*`, 5% stubs under
+  //     `<root>.misc.*`): root = `<root>.api` (the LONGEST prefix that
+  //     still covers ≥80% of files), not `<root>` (too generic) and
+  //     not the minority `<root>.misc.*` location (no longer first-match).
+  const pkgCounts = new Map();
   for (const f of javaFiles) {
     const m = f.match(/src\/main\/java\/(.+?)\/(controller|aggregator|facade|usecase|orchestrator|service|mapper|dao|dto|entity|repository|adapter)/);
-    if (m) { rootPackage = m[1].replace(/\//g, "."); break; }
+    if (!m) continue;
+    const segs = m[1].split("/");
+    for (let len = Math.min(4, segs.length); len >= 1; len--) {
+      const prefix = segs.slice(0, len).join(".");
+      pkgCounts.set(prefix, (pkgCounts.get(prefix) || 0) + 1);
+    }
+  }
+  if (pkgCounts.size > 0) {
+    const maxCount = Math.max(...pkgCounts.values());
+    const threshold = Math.ceil(maxCount * 0.8);
+    const candidates = [...pkgCounts.entries()].filter(([_, c]) => c >= threshold);
+    // Among candidates, pick the longest prefix (most specific root that
+    // still covers the majority of files). Tie-break on length DESC.
+    candidates.sort((a, b) => b[0].length - a[0].length);
+    rootPackage = candidates[0][0];
   }
   const domainMap = {};
   let detectedPattern = null;
@@ -172,7 +205,70 @@ async function scanJavaDomains(stack, ROOT) {
     domainMap[d].mappers = mpr.length;
     domainMap[d].dtos = dto.length;
     domainMap[d].xmlMappers = xml.length;
-    const totalFiles = svc.length + agg.length + mpr.length + dto.length + xml.length + domainMap[d].controllers;
+
+    // v2.4.0 — Deep-sweep fallback (Pattern B/D only).
+    //
+    // Pre-v2.4.0: standard globs assume `{domain}/{layer}/X.java`. This
+    // misses two real-world layouts:
+    //   (a) Multi-module split: `front/{domain}/{layer}/` for HTTP
+    //       layer + `core/{domain}/{layer}/` for service/dao layer.
+    //       Standard glob `**/{domain}/{layer}/` actually matches BOTH
+    //       via the leading `**`, so this case generally works.
+    //   (b) Cross-domain coupling: `core/{otherDomain}/{layer}/{domain}/`
+    //       — services for `{domain}` living under a different module's
+    //       layer directory (the layer dir comes BEFORE the domain dir).
+    //       Standard glob `**/{domain}/{layer}/*.java` does NOT match
+    //       this layout.
+    //
+    // When standard globs return zero files for a Pattern B/D domain
+    // that is registered in domainMap (so it does exist), fall back to
+    // a deep sweep: `**/${dn}/**/*.java` finds every .java file under
+    // ANY directory named ${dn}. We then classify each file by walking
+    // up its path to find the nearest layer dir, which catches both
+    // `${dn}/{layer}/` AND `{layer}/${dn}/` placements.
+    //
+    // Restricting to Pattern B/D and to the zero-files case keeps the
+    // legacy behavior identical for projects whose standard globs
+    // already cover everything, and prevents over-counting for
+    // domains with healthy direct-layout file counts.
+    const standardCount = svc.length + agg.length + mpr.length + dto.length + xml.length;
+    if (standardCount === 0 && (p === "B" || p === "D")) {
+      const deepFiles = (await glob(`src/main/java/**/${dn}/**/*.java`, { cwd: ROOT })).map(norm);
+      // v2.4.0 — extended layer recognition. Real-world enterprise codebases
+      // commonly include implementation/support layers beyond the canonical
+      // controller/service/mapper/dto trio. Files in `factory/`, `strategy/`,
+      // `impl/`, `helper/`, etc. were previously dropped by deep-sweep
+      // (no `break`), causing domains with non-standard layer names to
+      // report 0 totalFiles. The recognized list is augmented and a
+      // catch-all classifies any remaining `.java` file under the domain
+      // tree as a service (the most generic backend layer).
+      const SVC_LAYERS = ["aggregator", "facade", "usecase", "orchestrator", "service",
+                          "factory", "strategy", "impl", "helper", "support",
+                          "client", "provider", "manager", "handler", "interceptor",
+                          "filter", "listener", "task", "scheduler", "command", "query",
+                          "validator", "converter", "translator", "resolver"];
+      const DAO_LAYERS = ["mapper", "repository", "dao"];
+      const DTO_LAYERS = ["dto", "vo", "entity", "model", "request", "response", "payload"];
+      for (const f of deepFiles) {
+        const parts = f.split("/");
+        let classified = false;
+        for (let i = parts.length - 2; i >= 0; i--) {
+          const seg = parts[i];
+          if (seg === "controller") { domainMap[d].controllers++; classified = true; break; }
+          if (SVC_LAYERS.includes(seg)) { domainMap[d].services++; classified = true; break; }
+          if (DAO_LAYERS.includes(seg)) { domainMap[d].mappers++; classified = true; break; }
+          if (DTO_LAYERS.includes(seg)) { domainMap[d].dtos++; classified = true; break; }
+        }
+        // Fallback: any unclassified .java file under the domain tree is
+        // counted as a service. This catches layouts like
+        // `core/${dn}/X.java` (no layer subdir) and prevents legitimate
+        // backend domains from reporting 0 totalFiles when their files
+        // happen to live under unrecognized parent directories.
+        if (!classified) domainMap[d].services++;
+      }
+    }
+
+    const totalFiles = domainMap[d].services + domainMap[d].mappers + domainMap[d].dtos + domainMap[d].xmlMappers + domainMap[d].controllers;
     backendDomains.push({ name: d, type: "backend", ...domainMap[d], totalFiles });
   }
 

package/plan-installer/stack-detector.js

@@ -270,6 +270,10 @@ async function detectStack(ROOT) {
     const g = readFileSafe(path.join(ROOT, gradleFile));
     if (g) {
       stack.buildTool = "gradle"; stack.detected.push(gradleFile);
+      // v2.4.0 — JVM project package manager. Set "gradle" so generated docs
+      // and downstream tooling don't show "PackageMgr: none" for a build tool
+      // that IS the package manager. Only set if not already detected.
+      if (!stack.packageManager) stack.packageManager = "gradle";
       if (g.includes("spring-boot")) { stack.language = "java"; stack.framework = "spring-boot"; stack.detected.push("spring-boot"); }
       const svPatterns = [
         /org\.springframework\.boot.*version\s*['"]([^'"]+)['"]/,
@@ -483,6 +487,8 @@ async function detectStack(ROOT) {
     const pom = readFileSafe(path.join(ROOT, "pom.xml"));
     if (pom) {
       if (!stack.buildTool) { stack.buildTool = "maven"; stack.language = "java"; stack.detected.push("pom.xml"); }
+      // v2.4.0 — JVM package manager (parallel to Gradle case above).
+      if (!stack.packageManager) stack.packageManager = "maven";
       const sv = pom.match(/<spring-boot[^>]*version>([^<]+)/);
       if (sv) stack.frameworkVersion = sv[1];
       // Java version — Maven commonly uses three patterns:
@@ -815,6 +821,7 @@ async function detectStack(ROOT) {
       // framework default).
       const portPatterns = [
         // (1) direct numeric literal in yml `server:\n  port: N`
+        //     (port immediately after server: with no intermediate keys)
         /server:\s*\n\s*port:\s*(\d+)/,
         // (2) flat-key style `server.port=N` or `server.port: N`
         /server\.port\s*[=:]\s*(\d+)/,
@@ -824,6 +831,29 @@ async function detectStack(ROOT) {
         /server:\s*\n\s*port:\s*\$\{[^}:]+:(\d+)\}/,
         // (4) placeholder-with-default in flat-key form
         /server\.port\s*[=:]\s*\$\{[^}:]+:(\d+)\}/,
+        // (5) v2.4.0 — nested-block yml: `server:` block with intermediate
+        //     keys (e.g. `ssl:`, `http:`, `error:`, `tomcat:`, `compression:`)
+        //     BEFORE `port:`. Real Spring Boot configs often look like:
+        //       server:
+        //         ssl:
+        //           key-store: ...
+        //         port: 8443
+        //     Pre-v2.4.0 pattern (1) requires `port:` immediately after
+        //     `server:\n`, missing this common form. The lazy-quantified
+        //     gap allows up to ~20000 chars between `server:` and `port:`,
+        //     while the leading-whitespace constraint on `port:` ensures
+        //     we match an INDENTED key (still inside the server: block),
+        //     not an outdented sibling key at column 0.
+        //
+        //     v2.4.0: window expanded from 2000 to 20000 chars after
+        //     observing an enterprise YAML where the `server:` block
+        //     contained ssl/http/tomcat/compression children spanning
+        //     ~3000 chars before `port: 8443`. The 2000 limit silently
+        //     missed the port and the detector defaulted to the Spring
+        //     Boot 8080 fallback.
+        /^server:[\s\S]{0,20000}?\n[ \t]+port:\s*(\d+)/m,
+        // (6) v2.4.0 — same nested-block form with placeholder-with-default
+        /^server:[\s\S]{0,20000}?\n[ \t]+port:\s*\$\{[^}:]+:(\d+)\}/m,
       ];
       for (const re of portPatterns) {
         const pm = c.match(re);
@@ -912,6 +942,20 @@ async function detectStack(ROOT) {
     }
   }
 
+  // v2.4.0 — Spring Boot ships Logback as the default logging implementation
+  // via spring-boot-starter (transitively). Most projects do not declare
+  // `ch.qos.logback:logback-classic` explicitly because the starter brings
+  // it in. The dependency-only LOGGING_RULES regex therefore misses Logback
+  // for the common case. Fill in the default unless the project has
+  // explicitly opted into log4j2 (in which case spring-boot-starter-log4j2
+  // would replace the Logback default).
+  if (stack.framework === "spring-boot"
+      && !stack.loggingFrameworks.includes("log4j2")
+      && !stack.loggingFrameworks.includes("logback")) {
+    stack.loggingFrameworks.push("logback");
+    stack.detected.push("logback (spring-boot default)");
+  }
+
   return stack;
 }