claudeos-core 2.4.4 → 2.5.1

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

@@ -8,6 +8,24 @@
 const path = require("path");
 const { glob } = require("glob");
 
+// v2.5.0 — Layer-first stem de-duplication (shared shape with scan-python.js).
+// For every plural key whose singular form is ALSO a key, fold the plural
+// into the singular via `merge(into, from)` and drop the plural. Handles
+// `-ies`→`-y`, `-(s|x|z|ch|sh)es`→base, and plain `-s`. No merge happens
+// when only one form exists — the scanner never invents a singular.
+function mergePluralStems(byDomain, merge) {
+  for (const name of Object.keys(byDomain)) {
+    const cands = [];
+    if (/ies$/.test(name)) cands.push(name.slice(0, -3) + "y");
+    if (/(?:s|x|z|ch|sh)es$/.test(name)) cands.push(name.slice(0, -2));
+    if (/[^s]s$/.test(name)) cands.push(name.slice(0, -1));
+    const singular = cands.find(c => c !== name && byDomain[c]);
+    if (!singular) continue;
+    merge(byDomain[singular], byDomain[name]);
+    delete byDomain[name];
+  }
+}
+
 async function scanNodeDomains(stack, ROOT) {
   const backendDomains = [];
   const skipDirs = ["common", "shared", "config", "utils", "lib", "core", "main", "interfaces", "types", "constants", "guards", "decorators", "pipes", "filters", "interceptors"];
@@ -27,7 +45,104 @@ async function scanNodeDomains(stack, ROOT) {
     }
   }
 
+  // v2.5.0 — Layer-first layouts (Express / Fastify / Koa): src/controllers/,
+  // src/routes/, src/services/, src/models/. Every folder is a LAYER, so the
+  // loop below used to emit "controllers", "services", "routes" as domains.
+  // When (almost) every candidate folder is a layer name, derive domains from
+  // the file stems inside those layers instead: user.controller.js,
+  // users.routes.ts, orderService.js → user, users, order.
+  const LAYER_DIRS = new Set(["controllers", "controller", "routes", "route", "routers", "router", "services", "service",
+    "models", "model", "repositories", "repository", "middlewares", "middleware", "handlers", "handler",
+    "validators", "validations", "schemas", "dtos", "entities", "dao", "helpers", "api"]);
+  // Infrastructure folders that are neither layers nor features.
+  const NODE_GENERIC_DIRS = new Set(["db", "database", "migrations", "seeds", "scripts", "public", "static", "views", "templates",
+    "assets", "test", "tests", "__tests__", "mocks", "__mocks__", "docs", "node_modules", "dist", "build"]);
+  const candidateNames = srcDirs.map(d => path.basename(d.replace(/\/$/, ""))).filter(n => !skipDirs.includes(n) && !NODE_GENERIC_DIRS.has(n));
+  const layerNames = candidateNames.filter(n => LAYER_DIRS.has(n));
+  // A tree is layer-first only when a ROUTING layer folder exists at the
+  // top (`controllers/`, `routes/`, `handlers/`, `api/`). Data-only layer
+  // folders (`entities/`, `dtos/`, `schemas/`, `models/`) also appear in
+  // module-first NestJS trees (`src/users/`, `src/orders/` + shared
+  // `src/entities/`), where the modules are the domains — treating that as
+  // layer-first would rename `users` to `user` and invent one-file domains.
+  const ROUTING_LAYERS = new Set(["controllers", "controller", "routes", "route", "routers", "router", "handlers", "handler", "api"]);
+  const hasRoutingLayer = layerNames.some(n => ROUTING_LAYERS.has(n));
+  // Then: at least two layer folders (or the only candidate is a layer).
+  // Remaining non-layer siblings (`src/jobs/`, `src/billing/`) are MIXED-
+  // layout feature folders and become whole-folder domains — they must not
+  // disable the layer-first path, which would resurrect `controllers` /
+  // `routes` / `services` as domains.
+  if (hasRoutingLayer && (layerNames.length >= 2 || (layerNames.length === 1 && candidateNames.length === 1))) {
+    const byDomain = {};
+    const featureNames = candidateNames.filter(n => !LAYER_DIRS.has(n));
+    for (const dir of srcDirs) {
+      const name = path.basename(dir.replace(/\/$/, ""));
+      if (!featureNames.includes(name)) continue;
+      const files = await glob(`${dir.replace(/\\/g, "/").replace(/\/?$/, "/")}**/*.{ts,js,mjs,cjs}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*", "**/*.d.ts", "**/node_modules/**"] });
+      if (files.length === 0) continue;
+      const e = (byDomain[name] = byDomain[name] || { name, type: "backend", controllers: 0, services: 0, dtos: 0, totalFiles: 0 });
+      for (const f of files) {
+        if (/controller|router|route|handler/.test(f)) e.controllers++;
+        if (/service/.test(f)) e.services++;
+        if (/dto|schema|type|validator/.test(f)) e.dtos++;
+        e.totalFiles++;
+      }
+    }
+    // Layer/role suffixes are stripped REPEATEDLY (`email.service.impl.ts` →
+    // `email`, not `emailimpl`); `impl`, `base`, `abstract`, `interface`,
+    // `types`, `spec` are role words, not domains.
+    // A suffix counts only after a separator (`user.controller`, `user-controller`)
+    // or as a PascalCase word (`userController`, `UserService`) — never as a bare
+    // substring, so `prototype` is not cut down to `proto`.
+    const DOTTED_SUFFIX_RE = /[.\-_](?:controller|router|routes?|service|handler|model|repository|repo|middleware|validator|schema|dto|entity|dao|helper|impl|base|abstract|interface|types?|spec|mock|factory|utils?)s?$/i;
+    const CAMEL_SUFFIX_RE = /(?<=[a-z0-9])(?:Controller|Router|Routes?|Service|Handler|Model|Repository|Repo|Middleware|Validator|Schema|Dto|DTO|Entity|Dao|DAO|Helper|Impl|Base|Abstract|Interface|Types?|Spec|Mock|Factory|Utils?)s?$/;
+    const stemOf = (f) => {
+      const base = path.basename(f).replace(/\.(ts|js|mjs|cjs)$/, "");
+      // user.controller | user-controller | userController | users.routes | UserService | index
+      let stem = base;
+      for (let i = 0; i < 6; i++) {
+        const next = stem.replace(DOTTED_SUFFIX_RE, "").replace(CAMEL_SUFFIX_RE, "");
+        if (next === stem) break;
+        stem = next;
+      }
+      stem = stem.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/^[.\-_]+|[.\-_]+$/g, "");
+      return stem && stem !== "index" && stem !== "app" && stem !== "main" ? stem : null;
+    };
+    // Role comes from the LAYER FOLDER (authoritative), never from substrings
+    // of the file path (`models/prototype.ts` is not a dto because it contains
+    // "type").
+    const ROLE_OF_LAYER = (layer) => ROUTING_LAYERS.has(layer) ? "controllers"
+      : /^services?$/.test(layer) ? "services"
+      : /^(dtos?|schemas?|validators?|validations|entities)$/.test(layer) ? "dtos" : null;
+    for (const dir of srcDirs) {
+      const layer = path.basename(dir.replace(/\/$/, ""));
+      if (!LAYER_DIRS.has(layer)) continue;
+      const role = ROLE_OF_LAYER(layer);
+      const files = await glob(`${dir.replace(/\\/g, "/").replace(/\/?$/, "/")}**/*.{ts,js,mjs,cjs}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*", "**/*.d.ts"] });
+      for (const f of files) {
+        const d = stemOf(f);
+        if (!d) continue;
+        const e = (byDomain[d] = byDomain[d] || { name: d, type: "backend", controllers: 0, services: 0, dtos: 0, totalFiles: 0 });
+        if (role) e[role]++;
+        e.totalFiles++;
+      }
+    }
+    // Merge a plural stem into its singular twin when BOTH exist
+    // (`users.routes.js` + `user.controller.js` → `user`). Only pairs are
+    // merged — a lone `orders` stays `orders`, so no guessed singularization.
+    mergePluralStems(byDomain, (into, from) => {
+      into.controllers += from.controllers; into.services += from.services;
+      into.dtos += from.dtos; into.totalFiles += from.totalFiles;
+    });
+    for (const d of Object.values(byDomain)) backendDomains.push({ ...d, pattern: "layer-first" });
+    if (backendDomains.length > 0) return { backendDomains };
+    // fall through to the directory loop if stems yielded nothing
+  }
+
   for (let dir of srcDirs) {
+    // A folder named after a layer (`entities/`, `dtos/`, `controllers/`) is
+    // never a feature domain, whichever layout won above.
+    if (LAYER_DIRS.has(path.basename(dir.replace(/\/$/, "")))) continue;
     if (!dir.endsWith("/")) dir += "/";
     const name = path.basename(dir.replace(/\/$/, ""));
     if (skipDirs.includes(name)) continue;

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

@@ -7,6 +7,22 @@
 const path = require("path");
 const { glob } = require("glob");
 
+// v2.5.0 — Layer-first stem de-duplication (same rule as scan-node.js).
+// Fold a plural key into its singular twin ONLY when both exist
+// (`routers/users.py` + `models/user.py` → `user`); a lone plural is kept.
+function mergePluralStems(byDomain, merge) {
+  for (const name of Object.keys(byDomain)) {
+    const cands = [];
+    if (/ies$/.test(name)) cands.push(name.slice(0, -3) + "y");
+    if (/(?:s|x|z|ch|sh)es$/.test(name)) cands.push(name.slice(0, -2));
+    if (/[^s]s$/.test(name)) cands.push(name.slice(0, -1));
+    const singular = cands.find(c => c !== name && byDomain[c]);
+    if (!singular) continue;
+    merge(byDomain[singular], byDomain[name]);
+    delete byDomain[name];
+  }
+}
+
 async function scanPythonDomains(stack, ROOT) {
   const backendDomains = [];
 
@@ -46,6 +62,46 @@ async function scanPythonDomains(stack, ROOT) {
       const appFiles = await glob(`${dir.replace(/\\/g, "/")}/*.py`, { cwd: ROOT });
       backendDomains.push({ name, type: "backend", totalFiles: appFiles.length });
     }
+    // v2.5.0 — Layer-first FastAPI/Flask: app/routers/users.py, app/models/user.py,
+    // app/schemas/user.py. Folders are layers, so derive domains from file stems.
+    if (backendDomains.filter(d => d.type === "backend").length === 0) {
+      const PY_LAYER_DIRS = new Set(["routers", "router", "routes", "route", "api", "endpoints", "views", "controllers",
+        "services", "service", "models", "model", "schemas", "schema", "repositories", "repository", "crud", "dao", "handlers"]);
+      const PY_GENERIC_DIRS = new Set(["core", "common", "utils", "__pycache__", "config", "db", "database", "tests", "test", "app", "static", "templates", "migrations",
+        "env", "venv", ".venv", "virtualenv", "node_modules", "site-packages", "scripts", "docs"]);
+      const allSub = (await glob("{app,src/app,src}/*/", { cwd: ROOT, ignore: ["**/venv/**", "**/.venv/**", "**/env/**", "**/virtualenv/**", "**/node_modules/**", "**/site-packages/**", "**/__pycache__/**"] }))
+        .map(d => d.replace(/\\/g, "/").replace(/\/?$/, "/"));
+      const baseOf = (d) => path.basename(d.replace(/\/$/, ""));
+      const parentOf = (d) => d.replace(/\/$/, "").split("/").slice(0, -1).join("/") + "/";
+      const layerDirs = allSub.filter(d => PY_LAYER_DIRS.has(baseOf(d)));
+      // Feature packages that sit NEXT TO the layer folders (same parent):
+      // `src/routers/` + `src/tasks/` is a mixed layout — `tasks` must become a
+      // domain too, not be silently dropped. Scanned symmetrically with the
+      // layer folders (both come from the same glob), never from other trees.
+      const layerParents = new Set(layerDirs.map(parentOf));
+      const featureDirs = allSub.filter(d => layerParents.has(parentOf(d)) && !PY_LAYER_DIRS.has(baseOf(d)) && !PY_GENERIC_DIRS.has(baseOf(d)));
+      if (layerDirs.length > 0) {
+        const byDomain = {};
+        for (const dir of layerDirs) {
+          const files = await glob(`${dir}*.py`, { cwd: ROOT });
+          for (const f of files) {
+            let stem = path.basename(f, ".py").replace(/_(router|routes?|service|model|schema|repository|crud|handler|views?|api)s?$/i, "").toLowerCase();
+            if (!stem || ["__init__", "base", "deps", "dependencies", "main", "app", "utils", "common"].includes(stem)) continue;
+            const e = (byDomain[stem] = byDomain[stem] || { name: stem, type: "backend", totalFiles: 0 });
+            e.totalFiles++;
+          }
+        }
+        for (const dir of featureDirs) {
+          const files = await glob(`${dir}**/*.py`, { cwd: ROOT, ignore: ["**/__pycache__/**"] });
+          if (files.length === 0) continue;
+          const name = baseOf(dir).toLowerCase();
+          const e = (byDomain[name] = byDomain[name] || { name, type: "backend", totalFiles: 0 });
+          e.totalFiles += files.length;
+        }
+        mergePluralStems(byDomain, (into, from) => { into.totalFiles += from.totalFiles; });
+        for (const d of Object.values(byDomain)) backendDomains.push({ ...d, pattern: "layer-first" });
+      }
+    }
     if (backendDomains.filter(d => d.type === "backend").length === 0) {
       const appDirs = await glob("{app,src/app}/*/", { cwd: ROOT });
       for (let dir of appDirs) {

package/plan-installer/source-paths.js

@@ -234,9 +234,70 @@ function renderAllowedPathsSection(collected) {
   return lines.join("\n");
 }
 
+/**
+ * Deterministically insert (or replace) the `## Allowed Source Paths` section
+ * in a pass3a-facts.md body. Called by the orchestrator right after Pass 3a
+ * finishes, so the allowlist reaches Pass 3b/3c/3d verbatim — without asking
+ * the LLM to hand-copy up to 500 paths out of pass3-context.json.
+ *
+ * - If a `## Allowed Source Paths` section already exists (LLM wrote one),
+ *   it is replaced wholesale up to the next `## ` heading / EOF.
+ * - Otherwise the section is appended.
+ * - `collected` is the `allowedSourcePaths` object from project-analysis.json.
+ *   A missing/empty allowlist yields the documented fallback line so
+ *   downstream prompts see an explicit "unavailable" marker, not silence.
+ *
+ * Returns the new markdown string.
+ */
+function injectAllowedPathsSection(factsMd, collected) {
+  const heading = "## Allowed Source Paths";
+  const hasPaths = collected && Array.isArray(collected.paths) && collected.paths.length > 0;
+  const body = hasPaths
+    ? renderAllowedPathsSection(collected)
+    : "(allowlist unavailable — fall back to pass2-merged.json verification per file)";
+  const section = `${heading}\n\n${body}\n`;
+
+  const src = typeof factsMd === "string" ? factsMd : "";
+  const lines = src.split(/\r?\n/);
+  // Locate EVERY existing section heading outside fenced blocks. A model on a
+  // retry/resume may have written the section twice; all copies are removed
+  // and exactly one is put back at the position of the first.
+  const ranges = []; // [start, end) line indices
+  let inFence = false, cur = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^(```|~~~)/.test(lines[i].trimStart())) inFence = !inFence;
+    if (inFence) continue;
+    const isTarget = /^##\s+Allowed Source Paths\b/i.test(lines[i]);
+    const isHeading = /^##\s+/.test(lines[i]);
+    if (cur >= 0 && isHeading) { ranges.push([cur, i]); cur = -1; }
+    if (cur < 0 && isTarget) cur = i;
+  }
+  if (cur >= 0) ranges.push([cur, lines.length]);
+  if (ranges.length > 0) {
+    const out = [];
+    let pos = 0;
+    ranges.forEach(([a, b], idx) => {
+      out.push(...lines.slice(pos, a));
+      if (idx === 0) out.push(...section.split("\n"));
+      pos = b;
+    });
+    out.push(...lines.slice(pos));
+    return out.join("\n");
+  }
+  // Rebuild from `lines` (not `src`) so a CRLF input comes out as consistent LF
+  // instead of a mixed-ending file (CRLF body + LF appended section).
+  let trimmed = lines.join("\n").replace(/\s+$/, "");
+  // If the file ends inside an unclosed fence (LLM forgot the closing ```),
+  // close it first — otherwise the appended heading would sit inside a code
+  // block and be invisible to fence-aware readers of this file.
+  if (inFence) trimmed += "\n```";
+  return (trimmed ? trimmed + "\n\n" : "") + section;
+}
+
 module.exports = {
   collectSourcePaths,
   renderAllowedPathsSection,
+  injectAllowedPathsSection,
   // Exported for test visibility.
   _constants: { SOURCE_EXTENSIONS, EXCLUDED_DIRS, MAX_PATHS, MIN_FILES_PER_DIR, MAX_DIRS },
 };