claudeos-core 1.2.4 → 1.3.1

package/plan-installer/structure-scanner.js

@@ -0,0 +1,783 @@
+/**
+ * ClaudeOS-Core — Structure Scanner
+ *
+ * Scans project directory structure to discover domains (backend + frontend).
+ * Supports: Java (5 patterns), Kotlin (multi-module + CQRS), Node.js, Python.
+ * Also resolves shared query modules for Kotlin monorepos.
+ */
+
+const path = require("path");
+const { glob } = require("glob");
+
+async function scanStructure(stack, ROOT) {
+  const backendDomains = [];
+  const frontendDomains = [];
+  let rootPackage = null;
+
+  // ── Java ──
+  if (stack.language === "java") {
+    const javaFiles = await glob("src/main/java/**/*.java", { cwd: ROOT });
+    for (const f of javaFiles) {
+      const m = f.match(/src\/main\/java\/(.+?)\/(controller|service|mapper|dto|entity|repository|adapter)/);
+      if (m) { rootPackage = m[1].replace(/\//g, "."); break; }
+    }
+    const domainMap = {};
+    let detectedPattern = null;
+
+    // Pattern A: controller/{domain}/*.java (layer-first — domain under controller)
+    const controllersA = await glob("src/main/java/**/controller/*/*.java", { cwd: ROOT });
+    for (const f of controllersA) {
+      const m = f.match(/controller\/([^/]+)\//);
+      if (m) {
+        const d = m[1];
+        if (!domainMap[d]) domainMap[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "A" };
+        domainMap[d].controllers++;
+      }
+    }
+    if (Object.keys(domainMap).length > 0) detectedPattern = "A";
+
+    // Pattern B/D: {domain}/controller/*.java (domain-first — controller under domain)
+    // D extends B: {module}/{domain}/controller/ — auto-upgrade to module/domain on name conflict
+    if (!detectedPattern) {
+      const controllersB = await glob("src/main/java/**/*/controller/*.java", { cwd: ROOT });
+      const domainPaths = {};
+      for (const f of controllersB) {
+        const m = f.match(/\/([^/]+)\/controller\/[^/]+\.java$/);
+        if (m) {
+          const d = m[1];
+          const parentMatch = f.match(/\/([^/]+)\/([^/]+)\/controller\//);
+          const parentModule = parentMatch ? parentMatch[1] : null;
+          if (!domainPaths[d]) domainPaths[d] = [];
+          domainPaths[d].push({ file: f, module: parentModule });
+        }
+      }
+
+      // If same domain name found in multiple modules, use module/domain form (Pattern D)
+      for (const [d, entries] of Object.entries(domainPaths)) {
+        const modules = [...new Set(entries.map(e => e.module).filter(Boolean))];
+        if (modules.length > 1) {
+          // Pattern D: conflict — register as module/domain
+          for (const entry of entries) {
+            const fullName = entry.module ? `${entry.module}/${d}` : d;
+            if (!domainMap[fullName]) domainMap[fullName] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "D", modulePath: entry.module, domainName: d };
+            domainMap[fullName].controllers++;
+          }
+        } else {
+          if (!domainMap[d]) domainMap[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "B" };
+          domainMap[d].controllers += entries.length;
+        }
+      }
+      if (Object.keys(domainMap).length > 0) detectedPattern = domainMap[Object.keys(domainMap)[0]].pattern;
+    }
+
+    // Pattern E: DDD/Hexagonal — {domain}/adapter/in/web/*.java or {domain}/adapter/in/rest/*.java
+    if (!detectedPattern) {
+      const controllersE = await glob("src/main/java/**/adapter/in/{web,rest}/*.java", { cwd: ROOT });
+      for (const f of controllersE) {
+        const m = f.match(/\/([^/]+)\/adapter\/in\/(web|rest)\/[^/]+\.java$/);
+        if (m) {
+          const d = m[1];
+          if (!domainMap[d]) domainMap[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "E" };
+          domainMap[d].controllers++;
+        }
+      }
+      if (Object.keys(domainMap).length > 0) detectedPattern = "E";
+    }
+
+    // Pattern C: Flat structure — controller/*.java (no domain directory, extract domain from class name)
+    if (!detectedPattern) {
+      const controllersC = await glob("src/main/java/**/controller/*.java", { cwd: ROOT });
+      for (const f of controllersC) {
+        const m = f.match(/\/([A-Z][a-zA-Z]*)Controller\.java$/);
+        if (m) {
+          const d = m[1].toLowerCase();
+          if (!domainMap[d]) domainMap[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "C" };
+          domainMap[d].controllers++;
+        }
+      }
+      if (Object.keys(domainMap).length > 0) detectedPattern = "C";
+    }
+
+    // ── Supplementary scan: detect service-only domains without controllers ──
+    // Catch domains like core/delivery that have service/mapper but no controller
+    if (detectedPattern === "B" || detectedPattern === "D" || !detectedPattern) {
+      const serviceDirs = await glob("src/main/java/**/*/service/*.java", { cwd: ROOT });
+      const mapperDirs = await glob("src/main/java/**/*/{mapper,repository}/*.java", { cwd: ROOT });
+      const allServiceFiles = [...serviceDirs, ...mapperDirs];
+      const skipDomains = ["common", "config", "util", "utils", "base", "core", "shared", "global", "framework", "infra", "front", "admin", "back", "internal", "external", "web", "app", "test", "tests", "main", "generated", "build"];
+      for (const f of allServiceFiles) {
+        const m = f.match(/\/([^/]+)\/(service|mapper|repository)\/[^/]+\.java$/);
+        if (m) {
+          const d = m[1];
+          if (!domainMap[d] && !skipDomains.includes(d) && !/^v\d+$/.test(d)) {
+            domainMap[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: detectedPattern || "B" };
+          }
+        }
+      }
+    }
+
+    // Scan service/mapper/dto/xml files for each domain
+    for (const d of Object.keys(domainMap)) {
+      const p = domainMap[d].pattern;
+      const dn = domainMap[d].domainName || d;
+      let svcGlob, mprGlob, dtoGlob;
+
+      if (p === "A") {
+        svcGlob = `src/main/java/**/service/${d}/*.java`;
+        mprGlob = `src/main/java/**/{mapper,repository}/${d}/*.java`;
+        dtoGlob = `src/main/java/**/dto/${d}/**/*.java`;
+      } else if (p === "B" || p === "D") {
+        svcGlob = `src/main/java/**/${dn}/service/*.java`;
+        mprGlob = `src/main/java/**/${dn}/{mapper,repository}/*.java`;
+        dtoGlob = `src/main/java/**/${dn}/dto/**/*.java`;
+      } else if (p === "E") {
+        svcGlob = `src/main/java/**/${d}/{application,domain}/**/*.java`;
+        mprGlob = `src/main/java/**/${d}/adapter/out/{persistence,repository}/*.java`;
+        dtoGlob = `src/main/java/**/${d}/**/{dto,command,query}/**/*.java`;
+      } else {
+        // Pattern C: Flat — match domain name from file name
+        const cap = d.charAt(0).toUpperCase() + d.slice(1);
+        svcGlob = `src/main/java/**/service/${cap}*.java`;
+        mprGlob = `src/main/java/**/{mapper,repository}/${cap}*.java`;
+        dtoGlob = `src/main/java/**/dto/${cap}*.java`;
+      }
+      const xmlGlob = `src/main/resources/mapper/**/${dn}/*.xml`;
+
+      const svc = await glob(svcGlob, { cwd: ROOT });
+      const mpr = await glob(mprGlob, { cwd: ROOT });
+      const dto = await glob(dtoGlob, { cwd: ROOT });
+      const xml = await glob(xmlGlob, { cwd: ROOT });
+      domainMap[d].services = svc.length;
+      domainMap[d].mappers = mpr.length;
+      domainMap[d].dtos = dto.length;
+      domainMap[d].xmlMappers = xml.length;
+      backendDomains.push({ name: d, type: "backend", ...domainMap[d], totalFiles: svc.length + mpr.length + dto.length + xml.length + domainMap[d].controllers });
+    }
+
+    // ── Java fallback: extract domains directly from all .java files when glob returns 0 ──
+    if (backendDomains.length === 0) {
+      const allJava = await glob("**/*.java", { cwd: ROOT, ignore: ["**/node_modules/**", "**/build/**", "**/target/**", "**/test/**", "**/generated/**"] });
+      const javaDomains = {};
+      const skipNames = ["common", "config", "util", "utils", "base", "shared", "global", "framework", "infra", "api", "main", "front", "admin", "back", "internal", "external", "web", "app", "test", "tests", "generated", "build"];
+      const versionPattern = /^v\d+$/;
+      const layerNames = ["controller", "service", "mapper", "repository", "dao", "dto", "vo", "entity", "aggregator", "adapter"];
+
+      for (const f of allJava) {
+        const parts = f.replace(/\\/g, "/").split("/");
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (layerNames.includes(parts[i]) && i > 0) {
+            // Pattern A detection: .../{domain}/controller/... or .../controller/{domain}/...
+            const prevDir = parts[i - 1];
+            const nextDir = parts[i + 1];
+
+            // {domain}/layer/ pattern (domain before layer)
+            if (!skipNames.includes(prevDir) && !layerNames.includes(prevDir) && !prevDir.includes(".") && !versionPattern.test(prevDir)) {
+              if (!javaDomains[prevDir]) javaDomains[prevDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "B" };
+              if (parts[i] === "controller") javaDomains[prevDir].controllers++;
+              else if (parts[i] === "service") javaDomains[prevDir].services++;
+              else if (["mapper", "repository", "dao"].includes(parts[i])) javaDomains[prevDir].mappers++;
+              else if (["dto", "vo"].includes(parts[i])) javaDomains[prevDir].dtos++;
+            }
+            // layer/{domain}/ pattern (layer before domain)
+            if (nextDir && !nextDir.endsWith(".java") && !skipNames.includes(nextDir) && !layerNames.includes(nextDir) && !versionPattern.test(nextDir)) {
+              if (!javaDomains[nextDir]) javaDomains[nextDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "A" };
+              if (parts[i] === "controller") javaDomains[nextDir].controllers++;
+              else if (parts[i] === "service") javaDomains[nextDir].services++;
+              else if (["mapper", "repository", "dao"].includes(parts[i])) javaDomains[nextDir].mappers++;
+              else if (["dto", "vo"].includes(parts[i])) javaDomains[nextDir].dtos++;
+            }
+            break;
+          }
+        }
+      }
+
+      for (const [d, data] of Object.entries(javaDomains)) {
+        const total = data.controllers + data.services + data.mappers + data.dtos;
+        if (total > 0) {
+          backendDomains.push({ name: d, type: "backend", ...data, totalFiles: total });
+        }
+      }
+    }
+  }
+
+  // ── Kotlin (multi-module monorepo + CQRS support) ──
+  if (stack.language === "kotlin") {
+    // Scan all .kt files across all submodules
+    const ktFiles = await glob("**/src/main/kotlin/**/*.kt", {
+      cwd: ROOT,
+      ignore: ["**/node_modules/**", "**/build/**", "**/test/**", "**/generated/**"],
+    });
+
+    // Detect root package from first controller/service file
+    for (const f of ktFiles) {
+      const m = f.match(/src\/main\/kotlin\/(.+?)\/(controller|service|mapper|dto|entity|repository|adapter)/);
+      if (m) { rootPackage = m[1].replace(/\//g, "."); break; }
+    }
+
+    // Detect modules from directory structure (servers/*/ or direct submodules)
+    const moduleGlobs = [
+      "servers/*/*/src/main/kotlin/",     // servers/command/reservation-command-server/
+      "servers/*/src/main/kotlin/",        // servers/iam-server/
+      "*/src/main/kotlin/",                // shared-lib/ or integration-lib/
+    ];
+    const moduleSet = {};
+    for (const mg of moduleGlobs) {
+      const moduleDirs = await glob(mg, { cwd: ROOT });
+      for (const md of moduleDirs) {
+        const parts = md.replace(/\/src\/main\/kotlin\/$/, "").split("/");
+        const moduleName = parts[parts.length - 1]; // e.g., "reservation-command-server"
+        if (moduleSet[moduleName]) {
+          // Name conflict: use full relative path as key to avoid silent loss
+          const fullKey = md.replace(/\/src\/main\/kotlin\/$/, "").replace(/\//g, "__");
+          moduleSet[fullKey] = md;
+        } else {
+          moduleSet[moduleName] = md;
+        }
+      }
+    }
+
+    // Categorize modules and extract domains
+    const skipModules = ["build", "gradle", "buildSrc", ".gradle", "node_modules"];
+    const serverTypes = { command: "command", query: "query", bff: "bff", integration: "integration" };
+    const domainMap = {};
+
+    for (const [moduleName, modulePath] of Object.entries(moduleSet)) {
+      if (skipModules.some(s => moduleName.includes(s))) continue;
+
+      // Determine server type from module name
+      let serverType = "standalone";
+      for (const [key, val] of Object.entries(serverTypes)) {
+        if (moduleName.includes(key)) { serverType = val; break; }
+      }
+
+      // Extract domain name from module name
+      // e.g., "reservation-command-server" → "reservation"
+      // e.g., "pms-bff-server" → "pms"
+      // e.g., "iam-server" → "iam"
+      // e.g., "shared-lib" → "shared-lib"
+      // e.g., "common-query-server" → "common-query" (shared server, not a domain named "common")
+      let domainName = moduleName
+        .replace(/-(?:command|query|bff|integration|adapter)-server$/, "")
+        .replace(/-server$/, "");
+
+      // Guard: if domain extraction resulted in a generic name that is likely a shared module
+      // (e.g., "common-query-server" → "common"), keep the full type qualifier
+      const genericNames = ["common", "shared", "base", "core", "global", "internal"];
+      if (genericNames.includes(domainName) && serverType !== "standalone") {
+        domainName = `${domainName}-${serverType}`;
+      }
+
+      // Scan files in this module (append "/" to prevent prefix overlap: e.g., reservation vs reservation-ext)
+      const modulePrefix = modulePath.replace(/\/$/, "").replace(/\/src\/main\/kotlin$/, "") + "/";
+      const moduleKtFiles = ktFiles.filter(f => f.startsWith(modulePrefix) || f === modulePrefix.slice(0, -1));
+      const controllers = moduleKtFiles.filter(f => /controller/i.test(f)).length;
+      const services = moduleKtFiles.filter(f => /service/i.test(f)).length;
+      const repositories = moduleKtFiles.filter(f => /repository|mapper/i.test(f)).length;
+      const dtos = moduleKtFiles.filter(f => /dto|vo|request|response|model/i.test(f) && !/repository|service|controller/i.test(f)).length;
+      const totalFiles = moduleKtFiles.length;
+
+      if (totalFiles === 0) continue;
+
+      const key = `${domainName}:${serverType}`;
+      domainMap[key] = {
+        name: domainName,
+        moduleName,
+        modulePath,
+        serverType,
+        controllers,
+        services,
+        repositories,
+        dtos,
+        totalFiles,
+      };
+    }
+
+    // Group by domain: merge command/query/bff of same domain
+    const domainGroups = {};
+    for (const [key, info] of Object.entries(domainMap)) {
+      const { name } = info;
+      if (!domainGroups[name]) {
+        domainGroups[name] = { name, type: "backend", modules: [], controllers: 0, services: 0, repositories: 0, dtos: 0, totalFiles: 0, serverTypes: [] };
+      }
+      const dg = domainGroups[name];
+      dg.modules.push(info.moduleName);
+      dg.controllers += info.controllers;
+      dg.services += info.services;
+      dg.repositories += info.repositories;
+      dg.dtos += info.dtos;
+      dg.totalFiles += info.totalFiles;
+      if (!dg.serverTypes.includes(info.serverType)) dg.serverTypes.push(info.serverType);
+    }
+
+    // Push to backendDomains
+    for (const dg of Object.values(domainGroups)) {
+      backendDomains.push({
+        name: dg.name,
+        type: "backend",
+        controllers: dg.controllers,
+        services: dg.services,
+        mappers: dg.repositories,
+        dtos: dg.dtos,
+        totalFiles: dg.totalFiles,
+        modules: dg.modules,
+        serverTypes: dg.serverTypes,
+        pattern: "kotlin-multimodule",
+      });
+    }
+
+    // Also scan shared libraries as special domains
+    const libDirs = await glob("{shared-lib,integration-lib,*-lib}/src/main/kotlin/", { cwd: ROOT });
+    for (const ld of libDirs) {
+      const libName = ld.split("/")[0];
+      if (domainGroups[libName]) continue; // Already captured
+      const libFiles = ktFiles.filter(f => f.startsWith(libName + "/"));
+      if (libFiles.length > 0) {
+        backendDomains.push({
+          name: libName,
+          type: "backend",
+          controllers: 0,
+          services: libFiles.filter(f => /service/i.test(f)).length,
+          mappers: 0,
+          dtos: libFiles.filter(f => /dto|vo|model/i.test(f)).length,
+          totalFiles: libFiles.length,
+          modules: [libName],
+          serverTypes: ["library"],
+          pattern: "kotlin-library",
+        });
+      }
+    }
+
+    // Resolve shared query modules: redistribute internal domains to actual domain entries
+    resolveSharedQueryDomains(backendDomains, ktFiles);
+
+    // ── Kotlin single-module fallback (no multi-module structure detected) ──
+    if (backendDomains.length === 0 && ktFiles.length > 0) {
+      const ktDomains = {};
+      const skipNames = ["common", "config", "util", "utils", "base", "shared", "global", "framework", "infra", "main", "generated", "build"];
+      const layerKw = ["controller", "service", "repository", "mapper", "dao", "dto", "vo", "entity", "aggregate", "adapter"];
+      for (const f of ktFiles) {
+        const parts = f.replace(/\\/g, "/").split("/");
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (layerKw.includes(parts[i].toLowerCase())) {
+            // domain/layer/ pattern
+            if (i > 0) {
+              const d = parts[i - 1].toLowerCase();
+              if (!skipNames.includes(d) && !layerKw.includes(d) && d.length > 1 && d !== "kotlin") {
+                if (!ktDomains[d]) ktDomains[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, totalFiles: 0 };
+                if (parts[i] === "controller") ktDomains[d].controllers++;
+                else if (parts[i] === "service") ktDomains[d].services++;
+                else if (["repository", "mapper", "dao"].includes(parts[i])) ktDomains[d].mappers++;
+                else if (["dto", "vo", "entity"].includes(parts[i])) ktDomains[d].dtos++;
+                ktDomains[d].totalFiles++;
+              }
+            }
+            break;
+          }
+        }
+      }
+      for (const [d, data] of Object.entries(ktDomains)) {
+        if (data.totalFiles > 0) {
+          backendDomains.push({ name: d, type: "backend", ...data, pattern: "kotlin-single" });
+        }
+      }
+    }
+  }
+
+  // ── Node.js backend (Express/NestJS) — scan regardless of frontend presence ──
+  if ((stack.language === "typescript" || stack.language === "javascript") && stack.framework) {
+    const nestModules = await glob("src/modules/*/", { cwd: ROOT });
+    const srcDirs = nestModules.length > 0 ? nestModules : await glob("src/*/", { cwd: ROOT });
+    const skipDirs = ["common", "shared", "config", "utils", "lib", "core", "main", "interfaces", "types", "constants", "guards", "decorators", "pipes", "filters", "interceptors"];
+    for (let dir of srcDirs) {
+      if (!dir.endsWith("/")) dir += "/";
+      const name = path.basename(dir.replace(/\/$/, ""));
+      if (skipDirs.includes(name)) continue;
+      const files = await glob(`${dir.replace(/\\/g, "/")}**/*.{ts,js}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*"] });
+      if (files.length > 0) {
+        const controllers = files.filter(f => /controller|router|route/.test(f)).length;
+        const services = files.filter(f => /service/.test(f)).length;
+        const dtos = files.filter(f => /dto|schema|type/.test(f)).length;
+        backendDomains.push({ name, type: "backend", controllers, services, dtos, totalFiles: files.length });
+      }
+    }
+  }
+
+  // ── Next.js/React/Vue ──
+  if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
+    // App Router / Pages Router domains
+    const allDirs = [
+      ...await glob("{app,src/app}/*/", { cwd: ROOT }),
+      ...await glob("{pages,src/pages}/*/", { cwd: ROOT }),
+    ];
+    const skipPages = ["api", "_app", "_document", "fonts"];
+    for (const dir of allDirs) {
+      const name = path.basename(dir);
+      if (skipPages.includes(name) || name.startsWith("(") || name.startsWith("[") || name.startsWith("_") || name.startsWith(".")) continue;
+      const files = await glob(`${dir}**/*.{tsx,jsx,ts,js}`, { cwd: ROOT });
+      if (files.length > 0) {
+        const pages = files.filter(f => /page\.|index\./.test(f)).length;
+        const layouts = files.filter(f => /layout\./.test(f)).length;
+        const clientFiles = files.filter(f => /client\./.test(f)).length;
+        const serverFiles = pages + layouts;
+        const components = files.filter(f => !/page\.|layout\.|index\.|client\./.test(f)).length;
+        frontendDomains.push({
+          name, type: "frontend", pages, layouts, clientFiles, serverFiles, components, totalFiles: files.length,
+          rscPattern: clientFiles > 0 ? "RSC+Client split" : "default",
+        });
+      }
+    }
+
+    // FSD (Feature-Sliced Design): features/*, widgets/*, entities/*
+    const fsdLayers = ["features", "widgets", "entities"];
+    for (const layer of fsdLayers) {
+      const fsdDirs = await glob(`{${layer},src/${layer}}/*/`, { cwd: ROOT });
+      for (const dir of fsdDirs) {
+        const name = path.basename(dir);
+        if (["ui", "common", "shared", "lib", "config", "index"].includes(name)) continue;
+        const files = await glob(`${dir}**/*.{tsx,jsx,ts,js}`, { cwd: ROOT, ignore: ["**/*.spec.*", "**/*.test.*", "**/*.stories.*"] });
+        if (files.length > 0) {
+          const uiFiles = files.filter(f => /\bui\b/.test(f)).length;
+          const modelFiles = files.filter(f => /model|store|hook/.test(f)).length;
+          frontendDomains.push({ name: `${layer}/${name}`, type: "frontend", components: uiFiles, models: modelFiles, totalFiles: files.length });
+        }
+      }
+    }
+
+    // components/* (existing)
+    const compDirs = await glob("{src/,}components/*/", { cwd: ROOT });
+    for (const dir of compDirs) {
+      const name = path.basename(dir);
+      if (["ui", "common", "shared", "layout", "icons"].includes(name)) continue;
+      const files = await glob(`${dir}**/*.{tsx,jsx}`, { cwd: ROOT });
+      if (files.length >= 2) {
+        frontendDomains.push({ name: `comp-${name}`, type: "frontend", components: files.length, totalFiles: files.length });
+      }
+    }
+
+    // ── Fallback: extract domains directly from page.tsx/index.tsx locations when scanners return 0 ──
+    if (frontendDomains.length === 0) {
+      const pageFiles = await glob("**/page.{tsx,jsx}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**"] });
+      const domainSet = {};
+      const skipNames = ["app", "src", "pages", "api", "_app", "_document"];
+      for (const f of pageFiles) {
+        const parts = f.replace(/\\/g, "/").split("/");
+        const appIdx = parts.indexOf("app");
+        const pagesIdx = parts.indexOf("pages");
+        const baseIdx = appIdx >= 0 ? appIdx : pagesIdx;
+        if (baseIdx >= 0 && baseIdx + 1 < parts.length - 1) {
+          const domain = parts[baseIdx + 1];
+          if (!skipNames.includes(domain) && !domain.startsWith("_") && !domain.startsWith("(") && !domain.startsWith("[") && !domain.startsWith(".")) {
+            if (!domainSet[domain]) domainSet[domain] = { pages: 0, clientFiles: 0, totalFiles: 0 };
+            domainSet[domain].pages++;
+            domainSet[domain].totalFiles++;
+          }
+        }
+      }
+      // Count client.tsx as well
+      const clientFiles = await glob("**/client.{tsx,jsx}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**"] });
+      for (const f of clientFiles) {
+        const parts = f.replace(/\\/g, "/").split("/");
+        const appIdx = parts.indexOf("app");
+        const baseIdx = appIdx >= 0 ? appIdx : -1;
+        if (baseIdx >= 0 && baseIdx + 1 < parts.length - 1) {
+          const domain = parts[baseIdx + 1];
+          if (domainSet[domain]) {
+            domainSet[domain].clientFiles++;
+            domainSet[domain].totalFiles++;
+          }
+        }
+      }
+      for (const [name, data] of Object.entries(domainSet)) {
+        frontendDomains.push({
+          name, type: "frontend", pages: data.pages, clientFiles: data.clientFiles, totalFiles: data.totalFiles,
+          rscPattern: data.clientFiles > 0 ? "RSC+Client split" : "default",
+        });
+      }
+
+      // Also scan widgets/features/entities directly (glob fallback)
+      for (const layer of ["widgets", "features", "entities"]) {
+        const layerFiles = await glob(`**/${layer}/*/**/*.{tsx,jsx,ts,js}`, { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**", "**/*.spec.*", "**/*.test.*"] });
+        const layerDomains = {};
+        for (const f of layerFiles) {
+          const parts = f.replace(/\\/g, "/").split("/");
+          const layerIdx = parts.indexOf(layer);
+          if (layerIdx >= 0 && layerIdx + 1 < parts.length) {
+            const domain = parts[layerIdx + 1];
+            if (!["ui", "common", "shared", "lib", "config"].includes(domain)) {
+              if (!layerDomains[domain]) layerDomains[domain] = 0;
+              layerDomains[domain]++;
+            }
+          }
+        }
+        for (const [name, count] of Object.entries(layerDomains)) {
+          frontendDomains.push({ name: `${layer}/${name}`, type: "frontend", totalFiles: count });
+        }
+      }
+    }
+  }
+
+  // ── Python/Django ──
+  if (stack.framework === "django") {
+    const candidates = await glob("**/models.py", { cwd: ROOT, ignore: ["**/node_modules/**", "**/venv/**", "**/.venv/**", "**/env/**", "**/migrations/**"] });
+    for (const f of candidates) {
+      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 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;
+      backendDomains.push({ name, type: "backend", views, models, serializers, totalFiles: appFiles.length });
+    }
+  }
+
+  // ── Python/FastAPI ──
+  if (stack.framework === "fastapi" || stack.framework === "flask") {
+    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;
+      seen.add(name);
+      const appFiles = await glob(`${dir}/*.py`, { cwd: ROOT });
+      backendDomains.push({ name, type: "backend", totalFiles: appFiles.length });
+    }
+    if (backendDomains.filter(d => d.type === "backend").length === 0) {
+      const appDirs = await glob("{app,src/app}/*/", { cwd: ROOT });
+      for (let dir of appDirs) {
+        if (!dir.endsWith("/")) dir += "/";
+        const name = path.basename(dir.replace(/\/$/, ""));
+        if (["core", "common", "utils", "__pycache__"].includes(name)) continue;
+        const files = await glob(`${dir.replace(/\\/g, "/")}*.py`, { cwd: ROOT });
+        if (files.length > 0) backendDomains.push({ name, type: "backend", totalFiles: files.length });
+      }
+    }
+  }
+
+  // Frontend count
+  const frontend = { exists: false, components: 0, pages: 0, hooks: 0 };
+  if (stack.frontend) {
+    frontend.exists = true;
+    frontend.components = (await glob("{src/,}**/components/**/*.{tsx,jsx,vue}", { cwd: ROOT, ignore: ["**/node_modules/**"] })).length;
+    frontend.pages = (await glob("{src/,}{app,pages}/**/{page,index}.{tsx,jsx,vue}", { cwd: ROOT, ignore: ["**/node_modules/**"] })).length;
+    frontend.hooks = (await glob("{src/,}**/hooks/**/*.{ts,js}", { cwd: ROOT, ignore: ["**/node_modules/**"] })).length;
+  }
+
+  // App Router RSC/Client overall stats (for project-analysis.json)
+  if (stack.frontend === "nextjs") {
+    const allClientFiles = await glob("{app,src/app}/**/client.{tsx,ts,jsx,js}", { cwd: ROOT });
+    const allPageFiles = await glob("{app,src/app}/**/page.{tsx,ts,jsx,js}", { cwd: ROOT });
+    const allLayoutFiles = await glob("{app,src/app}/**/layout.{tsx,ts,jsx,js}", { cwd: ROOT });
+    frontend.clientComponents = allClientFiles.length;
+    frontend.serverPages = allPageFiles.length;
+    frontend.layouts = allLayoutFiles.length;
+    frontend.rscPattern = allClientFiles.length > 0;
+  }
+
+  // All domains = backend + frontend (with type tags)
+  const allDomains = [
+    ...backendDomains.sort((a, b) => b.totalFiles - a.totalFiles),
+    ...frontendDomains.sort((a, b) => b.totalFiles - a.totalFiles),
+  ];
+
+  return { domains: allDomains, backendDomains, frontendDomains, rootPackage, frontend };
+}
+
+// ─── Resolve shared query modules ────────────────────────────────
+// When a shared query module (e.g., common-query-server) contains controllers/services
+// for multiple domains, extract the actual domains and merge them into existing entries.
+// Supports two extraction patterns:
+//   A) Package-based: .../kotlin/com/company/.../DOMAIN/controller/XxxController.kt
+//   B) Class-name-based: .../controller/ReservationQueryController.kt → "reservation"
+// Safety: if no shared modules are found, this function does nothing (no-op).
+
+function resolveSharedQueryDomains(backendDomains, ktFiles) {
+  const genericNames = ["common", "shared", "base", "core", "global"];
+  const layerNames = new Set([
+    "controller", "service", "repository", "mapper", "api", "handler",
+    "dto", "model", "entity", "config", "configuration", "util", "utils",
+    "infra", "infrastructure", "framework", "common", "shared", "base",
+    "core", "global", "internal", "external", "exception", "interceptor",
+    "filter", "converter", "event", "listener", "client", "feign",
+    "adapter", "port", "domain", "application", "presentation",
+    "persistence", "web", "rest", "grpc", "query", "command",
+    "aggregate", "aggregator", "vo", "valueobject",
+  ]);
+  const skipPackages = new Set([
+    "com", "org", "net", "io", "kr", "jp", "cn", "de", "fr", "uk", "us",
+    "dev", "app", "main", "server", "backend", "project", "kotlin",
+  ]);
+  const classSuffixes = new Set([
+    "Controller", "Service", "Repository", "Mapper", "Handler", "Api",
+    "Query", "Command", "Read", "Write", "Get", "Find", "List", "Search",
+    "Admin", "Dto", "Request", "Response", "Entity", "Model", "Impl",
+    "Factory", "Builder", "Adapter", "Client", "Facade", "Provider",
+  ]);
+
+  // Find shared modules: generic name + query server type
+  const sharedModules = backendDomains.filter(d =>
+    d.pattern === "kotlin-multimodule" &&
+    d.serverTypes && d.serverTypes.includes("query") &&
+    genericNames.some(g => d.name.startsWith(g))
+  );
+  if (sharedModules.length === 0) return;
+
+  // Existing domain names for Pattern B-1 matching (longest-first for greedy match)
+  const existingDomains = backendDomains
+    .filter(d => !sharedModules.includes(d) && d.pattern === "kotlin-multimodule")
+    .map(d => d.name)
+    .sort((a, b) => b.length - a.length);
+
+  for (const shared of sharedModules) {
+    const moduleNames = shared.modules || [];
+    const sharedKtFiles = ktFiles.filter(f =>
+      moduleNames.some(m => f.includes(`/${m}/`) || f.startsWith(`${m}/`))
+    );
+    if (sharedKtFiles.length === 0) continue;
+
+    const domainFileMap = {}; // { domainName: [filePaths] }
+
+    for (const filePath of sharedKtFiles) {
+      let domain = null;
+      const parts = filePath.replace(/\\/g, "/").split("/");
+
+      // ── Pattern A: Package-based ──
+      // Looks for: .../kotlin/com/company/[project/]DOMAIN/LAYER/File.kt
+      // Uses depth >= 3 from kotlin/ to skip base package segments
+      const kotlinIdx = parts.findIndex(p => p === "kotlin");
+      if (kotlinIdx >= 0) {
+        for (let i = kotlinIdx + 1; i < parts.length - 1; i++) {
+          if (layerNames.has(parts[i].toLowerCase())) {
+            if (i - 1 > kotlinIdx) {
+              const candidate = parts[i - 1].toLowerCase();
+              const depth = (i - 1) - kotlinIdx; // distance from kotlin/
+              if (
+                depth >= 3 &&
+                !layerNames.has(candidate) &&
+                !skipPackages.has(candidate) &&
+                candidate.length > 2
+              ) {
+                domain = candidate;
+              }
+            }
+            break; // only check first layer directory encountered
+          }
+        }
+      }
+
+      // ── Pattern B-1: Match class name against existing domain names ──
+      if (!domain) {
+        const fileName = parts[parts.length - 1].replace(/\.kt$/, "").toLowerCase();
+        for (const ed of existingDomains) {
+          const normalized = ed.replace(/-/g, "");
+          if (fileName.startsWith(normalized) && fileName.length > normalized.length) {
+            domain = ed;
+            break;
+          }
+        }
+      }
+
+      // ── Pattern B-2: Extract from PascalCase class name ──
+      if (!domain) {
+        const fileName = parts[parts.length - 1].replace(/\.kt$/, "");
+        const words = fileName.match(/[A-Z][a-z]+|[A-Z]+(?=[A-Z][a-z]|$)/g);
+        if (words && words.length >= 2) {
+          const domainWords = [];
+          for (const w of words) {
+            if (classSuffixes.has(w)) break;
+            domainWords.push(w);
+          }
+          if (domainWords.length > 0) {
+            const extracted = domainWords.join("").toLowerCase();
+            if (
+              !genericNames.includes(extracted) &&
+              !skipPackages.has(extracted) &&
+              extracted.length > 2
+            ) {
+              domain = extracted;
+            }
+          }
+        }
+      }
+
+      if (domain) {
+        if (!domainFileMap[domain]) domainFileMap[domain] = [];
+        domainFileMap[domain].push(filePath);
+      }
+    }
+
+    // ── Merge extracted domains into backendDomains ──
+    let distributedFiles = 0;
+    for (const [domain, files] of Object.entries(domainFileMap)) {
+      // Find matching existing domain (exact or normalized)
+      const existing = backendDomains.find(d =>
+        d !== shared &&
+        (d.name === domain || d.name.replace(/-/g, "") === domain.replace(/-/g, ""))
+      );
+
+      const ctrlCount = files.filter(f =>
+        /\/controller\//i.test(f) || /Controller\.kt$/i.test(f)
+      ).length;
+      const svcCount = files.filter(f =>
+        /\/service\//i.test(f) || /Service\.kt$/i.test(f)
+      ).length;
+      const repoCount = files.filter(f =>
+        /\/repository\//i.test(f) || /\/mapper\//i.test(f) ||
+        /Repository\.kt$/i.test(f) || /Mapper\.kt$/i.test(f)
+      ).length;
+      const dtoCount = files.filter(f =>
+        (/\/dto\//i.test(f) || /\/vo\//i.test(f) || /Dto\.kt$/i.test(f) ||
+         /Vo\.kt$/i.test(f) || /Request\.kt$/i.test(f) || /Response\.kt$/i.test(f)) &&
+        !/\/controller\//i.test(f) && !/\/service\//i.test(f) &&
+        !/\/repository\//i.test(f)
+      ).length;
+
+      if (existing) {
+        // Merge into existing domain
+        if (!existing.modules) existing.modules = [];
+        for (const m of moduleNames) {
+          if (!existing.modules.includes(m)) existing.modules.push(m);
+        }
+        if (!existing.serverTypes) existing.serverTypes = [];
+        if (!existing.serverTypes.includes("query")) existing.serverTypes.push("query");
+        existing.controllers += ctrlCount;
+        existing.services += svcCount;
+        if (existing.mappers != null) existing.mappers += repoCount;
+        existing.dtos += dtoCount;
+        existing.totalFiles += files.length;
+      } else {
+        // Create new domain entry
+        backendDomains.push({
+          name: domain,
+          type: "backend",
+          controllers: ctrlCount,
+          services: svcCount,
+          mappers: repoCount,
+          dtos: dtoCount,
+          totalFiles: files.length,
+          modules: [...moduleNames],
+          serverTypes: ["query"],
+          pattern: "kotlin-multimodule",
+          resolvedFrom: shared.name,
+        });
+      }
+      distributedFiles += files.length;
+    }
+
+    // Adjust shared module: keep only undistributed files
+    if (distributedFiles > 0) {
+      shared.totalFiles = Math.max(0, shared.totalFiles - distributedFiles);
+      shared.resolvedDomains = Object.keys(domainFileMap);
+      if (shared.totalFiles === 0) shared._resolved = true;
+    }
+  }
+
+  // Remove fully resolved shared entries (all files distributed)
+  for (let i = backendDomains.length - 1; i >= 0; i--) {
+    if (backendDomains[i]._resolved) backendDomains.splice(i, 1);
+  }
+}
+
+
+module.exports = { scanStructure, resolveSharedQueryDomains };