claudeos-core 1.2.4 → 1.3.1

package/plan-installer/index.js

@@ -1,1279 +1,36 @@
 #!/usr/bin/env node
 
 /**
- * ClaudeOS-Core — plan-installer
+ * ClaudeOS-Core — plan-installer (orchestrator)
  *
- * Role: Project analysis → Stack detection → Domain list → Auto group splitting → Dynamic prompt generation
- * Output:
- *   - claudeos-core/generated/project-analysis.json  (stack/structure info, multi-stack aware)
- *   - claudeos-core/generated/domain-groups.json     (group splitting for Pass 1 execution, per type)
- *   - claudeos-core/generated/pass1-backend-prompt.md (backend analysis prompt)
- *   - claudeos-core/generated/pass1-frontend-prompt.md (frontend analysis prompt, if detected)
- *   - claudeos-core/generated/pass1-prompt.md        (single-stack backward compat)
- *   - claudeos-core/generated/pass2-prompt.md
- *   - claudeos-core/generated/pass3-prompt.md        (combined prompt for multi-stack)
- *
- * Usage: npx claudeos-core <cmd> or node claudeos-core-tools/plan-installer/index.js
+ * Modules:
+ *   - stack-detector.js      — detectStack()
+ *   - structure-scanner.js   — scanStructure(), resolveSharedQueryDomains()
+ *   - domain-grouper.js      — splitDomainGroups(), determineActiveDomains(), selectTemplates()
+ *   - prompt-generator.js    — generatePrompts()
  */
 
-const fs = require("fs");
 const path = require("path");
-const { glob } = require("glob");
+const { ensureDir, writeFileSafe } = require("../lib/safe-fs");
+const { detectStack } = require("./stack-detector");
+const { scanStructure } = require("./structure-scanner");
+const { splitDomainGroups, determineActiveDomains, selectTemplates } = require("./domain-grouper");
+const { generatePrompts } = require("./prompt-generator");
 
 const ROOT = process.env.CLAUDEOS_ROOT || path.resolve(__dirname, "../..");
 const GENERATED_DIR = path.join(ROOT, "claudeos-core/generated");
 const TEMPLATES_DIR = path.join(__dirname, "../pass-prompts/templates");
 
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-}
-
-// ─── Stack detection (multi-stack) ────────────────────────────────
-async function detectStack() {
-  const stack = {
-    language: null, languageVersion: null,
-    framework: null, frameworkVersion: null,
-    buildTool: null, database: null, orm: null,
-    frontend: null, frontendVersion: null,
-    packageManager: null, detected: [],
-  };
-
-  // ── Java/Kotlin: Gradle ──
-  const gradleFile = fs.existsSync(path.join(ROOT, "build.gradle.kts"))
-    ? "build.gradle.kts"
-    : fs.existsSync(path.join(ROOT, "build.gradle")) ? "build.gradle" : null;
-  if (gradleFile) {
-    const g = fs.readFileSync(path.join(ROOT, gradleFile), "utf-8");
-    stack.buildTool = "gradle"; stack.detected.push(gradleFile);
-    if (g.includes("spring-boot")) { stack.language = "java"; stack.framework = "spring-boot"; stack.detected.push("spring-boot"); }
-    const svPatterns = [
-      /org\.springframework\.boot.*version\s*['"]([^'"]+)['"]/,
-      /id\s*\(\s*["']org\.springframework\.boot["']\s*\)\s*version\s*["']([^"']+)["']/,
-      /spring-boot-dependencies:([^'")\s]+)/,
-    ];
-    for (const pattern of svPatterns) {
-      const sv = g.match(pattern);
-      if (sv) { stack.frameworkVersion = sv[1]; break; }
-    }
-    const jv = g.match(/sourceCompatibility\s*=\s*['"]?(\d+)['"]?/);
-    if (jv) stack.languageVersion = jv[1];
-    // ORM detection (first match wins — order by specificity)
-    if (!stack.orm && g.includes("mybatis")) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
-    if (!stack.orm && (g.includes("jpa") || g.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa"); }
-    if (!stack.orm && g.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed"); }
-    if (!stack.orm && g.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq"); }
-    if (!stack.orm && g.includes("spring-data-jdbc")) { stack.orm = "spring-data-jdbc"; stack.detected.push("spring-data-jdbc"); }
-    if (!stack.orm && g.includes("r2dbc")) { stack.orm = "r2dbc"; stack.detected.push("r2dbc"); }
-    // DB detection
-    if (!stack.database && g.includes("postgresql")) { stack.database = "postgresql"; stack.detected.push("postgresql"); }
-    if (!stack.database && g.includes("mysql")) { stack.database = "mysql"; stack.detected.push("mysql"); }
-    if (!stack.database && g.includes("oracle")) { stack.database = "oracle"; stack.detected.push("oracle"); }
-    if (!stack.database && g.includes("mongodb")) { stack.database = "mongodb"; stack.detected.push("mongodb"); }
-    if (!stack.database && g.includes("h2")) { stack.database = "h2"; stack.detected.push("h2"); }
-    // Kotlin detection: override language if Kotlin plugin found
-    if (g.includes("kotlin") || g.includes("org.jetbrains.kotlin")) {
-      stack.language = "kotlin"; stack.detected.push("kotlin");
-      // Try multiple patterns for Kotlin version extraction
-      const kvPatterns = [
-        /kotlin\S*\s*version\s*['"]([^'"]+)['"]/,
-        /org\.jetbrains\.kotlin\S*\s*version\s*['"]([^'"]+)['"]/,
-        /kotlin\("jvm"\)\s*version\s*["']([^"']+)["']/,
-      ];
-      for (const pattern of kvPatterns) {
-        const match = g.match(pattern);
-        if (match) { stack.languageVersion = match[1]; break; }
-      }
-    }
-  }
-
-  // ── Gradle: version catalogs (libs.versions.toml) — fallback for versions & deps ──
-  const versionCatalog = path.join(ROOT, "gradle/libs.versions.toml");
-  if (fs.existsSync(versionCatalog)) {
-    const vc = fs.readFileSync(versionCatalog, "utf-8");
-    stack.detected.push("libs.versions.toml");
-    // Language version fallback
-    if (!stack.languageVersion) {
-      const kvMatch = vc.match(/kotlin\s*=\s*["']([^"']+)["']/);
-      if (kvMatch) stack.languageVersion = kvMatch[1];
-    }
-    if (!stack.frameworkVersion) {
-      const sbMatch = vc.match(/spring-boot\s*=\s*["']([^"']+)["']/);
-      if (sbMatch) stack.frameworkVersion = sbMatch[1];
-    }
-    // ORM/DB detection from version catalog libraries
-    if (!stack.orm && vc.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed (catalog)"); }
-    if (!stack.orm && vc.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq (catalog)"); }
-    if (!stack.orm && (vc.includes("jpa") || vc.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa (catalog)"); }
-    if (!stack.database && vc.includes("postgresql")) { stack.database = "postgresql"; }
-    if (!stack.database && vc.includes("mysql")) { stack.database = "mysql"; }
-    if (!stack.database && vc.includes("mongodb")) { stack.database = "mongodb"; }
-    // Kotlin detection from catalog
-    if (!stack.language && vc.includes("kotlin")) {
-      stack.language = "kotlin"; stack.detected.push("kotlin (catalog)");
-    }
-  }
-
-  // ── Kotlin: multi-module Gradle detection (check subproject build files) ──
-  if (stack.language !== "kotlin" && stack.buildTool === "gradle") {
-    const subBuildFiles = await glob("**/build.gradle{,.kts}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/build/**"] });
-    for (const sbf of subBuildFiles.slice(0, 5)) {
-      const sc = fs.readFileSync(path.join(ROOT, sbf), "utf-8");
-      if (sc.includes("kotlin") || sc.includes("org.jetbrains.kotlin")) {
-        stack.language = "kotlin"; stack.detected.push("kotlin (submodule)");
-        const kv = sc.match(/kotlin\S*\s*version\s*['"]([^'"]+)['"]/);
-        if (kv) stack.languageVersion = kv[1];
-        break;
-      }
-    }
-  }
-
-  // ── Kotlin: detect CQRS/multi-module architecture from settings.gradle ──
-  const settingsFile = fs.existsSync(path.join(ROOT, "settings.gradle.kts"))
-    ? "settings.gradle.kts"
-    : fs.existsSync(path.join(ROOT, "settings.gradle")) ? "settings.gradle" : null;
-  if (settingsFile && stack.language === "kotlin") {
-    const sg = fs.readFileSync(path.join(ROOT, settingsFile), "utf-8");
-
-    // Extract all module names from include() calls
-    // Handles: include(":m1", ":m2"), include(":m1"), include ":m1", ":m2"
-    // Also strips leading ":" prefix (Gradle subproject path convention)
-    // Pre-filter: remove single-line comments to avoid matching commented-out includes
-    const sgClean = sg.split("\n").filter(l => !l.trimStart().startsWith("//")).join("\n");
-    const includes = [];
-    // Kotlin DSL: include(":m1", ":m2", ":m3") — may span multiple lines
-    const includeBlocks = [...sgClean.matchAll(/include\s*\(([^)]*)\)/gs)];
-    for (const block of includeBlocks) {
-      const quotedValues = [...block[1].matchAll(/["']([^"']+)["']/g)].map(m => m[1]);
-      includes.push(...quotedValues);
-    }
-    // Groovy DSL: include ':m1', ':m2', ':m3' — single line, comma-separated
-    if (includes.length === 0) {
-      const groovyIncludes = [...sgClean.matchAll(/include\s+(.+)/g)];
-      for (const line of groovyIncludes) {
-        const quotedValues = [...line[1].matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1]);
-        includes.push(...quotedValues);
-      }
-    }
-
-    // Strip leading ":" prefix from all module names (Gradle convention)
-    const cleanModules = includes.map(m => m.replace(/^:/, ""));
-
-    if (cleanModules.length > 0) {
-      stack.multiModule = true;
-      stack.modules = cleanModules;
-      stack.detected.push(`multi-module (${cleanModules.length} modules)`);
-      // Detect CQRS from module names
-      const hasCommand = cleanModules.some(m => m.includes("command"));
-      const hasQuery = cleanModules.some(m => m.includes("query"));
-      const hasBff = cleanModules.some(m => m.includes("bff"));
-      if (hasCommand && hasQuery) { stack.architecture = "cqrs"; stack.detected.push("cqrs"); }
-      if (hasBff) { stack.detected.push("bff"); }
-    }
-  }
-
-  // ── Java: Maven ──
-  if (fs.existsSync(path.join(ROOT, "pom.xml"))) {
-    const pom = fs.readFileSync(path.join(ROOT, "pom.xml"), "utf-8");
-    if (!stack.buildTool) { stack.buildTool = "maven"; stack.language = "java"; stack.detected.push("pom.xml"); }
-    const sv = pom.match(/<spring-boot[^>]*version>([^<]+)/);
-    if (sv) stack.frameworkVersion = sv[1];
-    const jv = pom.match(/<java\.version>(\d+)/);
-    if (jv) stack.languageVersion = jv[1];
-    if (pom.includes("spring-boot") && !stack.framework) { stack.framework = "spring-boot"; stack.detected.push("spring-boot"); }
-    if (!stack.orm && pom.includes("mybatis")) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
-    if (!stack.orm && (pom.includes("jpa") || pom.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa"); }
-    if (!stack.orm && pom.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed"); }
-    if (!stack.orm && pom.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq"); }
-    if (!stack.database && pom.includes("postgresql")) stack.database = "postgresql";
-    if (!stack.database && pom.includes("mysql")) stack.database = "mysql";
-    if (!stack.database && pom.includes("oracle")) stack.database = "oracle";
-    if (!stack.database && pom.includes("mongodb")) stack.database = "mongodb";
-    if (!stack.database && pom.includes("h2")) stack.database = "h2";
-    if (!stack.database && pom.includes("sqlite")) stack.database = "sqlite";
-  }
-
-  // ── Node.js ──
-  if (fs.existsSync(path.join(ROOT, "package.json"))) {
-    let pkg;
-    try { pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8")); }
-    catch { console.warn("    ⚠️  package.json parse error — skipping Node.js detection"); pkg = null; }
-    if (pkg) {
-    stack.detected.push("package.json");
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-
-    if (!stack.language) stack.language = deps.typescript ? "typescript" : "javascript";
-    if (deps.typescript) { stack.detected.push("typescript"); stack.languageVersion = deps.typescript.replace(/[^0-9.]/g, ""); }
-
-    // Frontend
-    if (deps.next) { stack.frontend = "nextjs"; stack.detected.push("next.js"); stack.frontendVersion = deps.next.replace(/[^0-9.]/g, ""); }
-    else if (deps.react) { stack.frontend = "react"; stack.detected.push("react"); stack.frontendVersion = deps.react.replace(/[^0-9.]/g, ""); }
-    else if (deps.vue) { stack.frontend = "vue"; stack.detected.push("vue"); stack.frontendVersion = deps.vue.replace(/[^0-9.]/g, ""); }
-
-    // Backend framework
-    if (deps.express && !stack.framework) { stack.framework = "express"; stack.detected.push("express"); }
-    if (deps["@nestjs/core"]) { stack.framework = "nestjs"; stack.detected.push("nestjs"); stack.frameworkVersion = deps["@nestjs/core"].replace(/[^0-9.]/g, ""); }
-
-    // ORM
-    if ((deps["@prisma/client"] || deps.prisma) && !stack.orm) { stack.orm = "prisma"; stack.detected.push("prisma"); }
-    if (deps.typeorm && !stack.orm) { stack.orm = "typeorm"; stack.detected.push("typeorm"); }
-    if (deps.sequelize && !stack.orm) { stack.orm = "sequelize"; stack.detected.push("sequelize"); }
-    if (deps["drizzle-orm"] && !stack.orm) { stack.orm = "drizzle"; stack.detected.push("drizzle"); }
-    if (deps.knex && !stack.orm) { stack.orm = "knex"; stack.detected.push("knex"); }
-    if (deps.mongoose) { if (!stack.database) stack.database = "mongodb"; if (!stack.orm) stack.orm = "mongoose"; stack.detected.push("mongoose"); }
-
-    // DB
-    if (deps.pg && !stack.database) stack.database = "postgresql";
-    if (deps.mysql2 && !stack.database) stack.database = "mysql";
-    if (deps.mongodb && !stack.database) stack.database = "mongodb";
-
-    // Package manager
-    stack.packageManager = fs.existsSync(path.join(ROOT, "pnpm-lock.yaml")) ? "pnpm"
-      : fs.existsSync(path.join(ROOT, "yarn.lock")) ? "yarn" : "npm";
-
-    if (pkg.engines && pkg.engines.node && !stack.languageVersion) stack.languageVersion = pkg.engines.node;
-    } // end if (pkg)
-  }
-
-  // ── Python ──
-  const hasPyproject = fs.existsSync(path.join(ROOT, "pyproject.toml"));
-  const hasRequirements = fs.existsSync(path.join(ROOT, "requirements.txt"));
-  if (hasPyproject || hasRequirements) {
-    if (!stack.language) stack.language = "python";
-    stack.detected.push("python");
-
-    if (hasPyproject) {
-      const pp = fs.readFileSync(path.join(ROOT, "pyproject.toml"), "utf-8");
-      const pv = pp.match(/python\s*=\s*"[><=^~]*(\d+\.\d+)/);
-      if (pv && !stack.languageVersion) stack.languageVersion = pv[1];
-      if (pp.includes("django") && !stack.framework) { stack.framework = "django"; stack.detected.push("django"); }
-      if (pp.includes("fastapi") && !stack.framework) { stack.framework = "fastapi"; stack.detected.push("fastapi"); }
-      if (pp.includes("flask") && !stack.framework) { stack.framework = "flask"; stack.detected.push("flask"); }
-      if (pp.includes("sqlalchemy") && !stack.orm) { stack.orm = "sqlalchemy"; stack.detected.push("sqlalchemy"); }
-      if (pp.includes("tortoise") && !stack.orm) { stack.orm = "tortoise-orm"; stack.detected.push("tortoise-orm"); }
-      if (pp.includes("poetry")) { stack.packageManager = "poetry"; }
-      if (pp.includes("pdm")) { stack.packageManager = "pdm"; }
-    }
-
-    if (hasRequirements) {
-      const r = fs.readFileSync(path.join(ROOT, "requirements.txt"), "utf-8");
-      if (r.includes("django") && !stack.framework) { stack.framework = "django"; stack.detected.push("django"); }
-      if (r.includes("fastapi") && !stack.framework) { stack.framework = "fastapi"; stack.detected.push("fastapi"); }
-      if (r.includes("flask") && !stack.framework) { stack.framework = "flask"; stack.detected.push("flask"); }
-      if (r.includes("sqlalchemy") && !stack.orm) { stack.orm = "sqlalchemy"; }
-      if (r.includes("tortoise") && !stack.orm) { stack.orm = "tortoise-orm"; }
-      if (r.includes("psycopg") && !stack.database) stack.database = "postgresql";
-      if (r.includes("mysqlclient") && !stack.database) stack.database = "mysql";
-    }
-
-    if (!stack.packageManager) {
-      stack.packageManager = fs.existsSync(path.join(ROOT, "Pipfile")) ? "pipenv"
-        : fs.existsSync(path.join(ROOT, "poetry.lock")) ? "poetry" : "pip";
-    }
-  }
-
-  // ── DB from config files ──
-  const ymls = await glob("**/application*.yml", { cwd: ROOT, absolute: true, ignore: ["**/node_modules/**"] });
-  for (const y of ymls) {
-    const c = fs.readFileSync(y, "utf-8");
-    if (!stack.database && c.includes("postgresql")) stack.database = "postgresql";
-    if (!stack.database && c.includes("mysql")) stack.database = "mysql";
-    if (!stack.database && c.includes("oracle")) stack.database = "oracle";
-    if (!stack.database && c.includes("mongodb")) stack.database = "mongodb";
-    if (!stack.database && /\bh2\b/.test(c)) stack.database = "h2";
-    if (!stack.database && c.includes("sqlite")) stack.database = "sqlite";
-    if (!stack.port) {
-      const pm = c.match(/server:\s*\n\s*port:\s*(\d+)/) || c.match(/server\.port\s*[=:]\s*(\d+)/);
-      if (pm) stack.port = parseInt(pm[1]);
-    }
-  }
-
-  // .env
-  for (const ef of [".env", ".env.local", ".env.development"]) {
-    const ep = path.join(ROOT, ef);
-    if (fs.existsSync(ep)) {
-      const ec = fs.readFileSync(ep, "utf-8");
-      if (ec.includes("DATABASE_URL")) {
-        if (ec.includes("postgres") && !stack.database) stack.database = "postgresql";
-        if (ec.includes("mysql") && !stack.database) stack.database = "mysql";
-        if (ec.includes("mongodb") && !stack.database) stack.database = "mongodb";
-        if (ec.includes("sqlite") && !stack.database) stack.database = "sqlite";
-      }
-    }
-  }
-
-  // Prisma schema
-  const prismaSchema = path.join(ROOT, "prisma/schema.prisma");
-  if (fs.existsSync(prismaSchema)) {
-    const ps = fs.readFileSync(prismaSchema, "utf-8");
-    const prov = ps.match(/provider\s*=\s*"(\w+)"/);
-    if (prov && !stack.database) {
-      const db = { postgresql: "postgresql", mysql: "mysql", sqlite: "sqlite", mongodb: "mongodb" };
-      if (db[prov[1]]) stack.database = db[prov[1]];
-    }
-  }
-
-  // ── Config file fallback (monorepo: detect from config files when not in package.json) ──
-  if (!stack.frontend) {
-    const nextConfigs = ["next.config.js", "next.config.mjs", "next.config.ts"];
-    if (nextConfigs.some(c => fs.existsSync(path.join(ROOT, c)))) {
-      stack.frontend = "nextjs"; stack.detected.push("next.config (fallback)");
-      if (!stack.language) stack.language = "typescript";
-    }
-  }
-  if (!stack.frontend) {
-    if (fs.existsSync(path.join(ROOT, "vite.config.ts")) || fs.existsSync(path.join(ROOT, "vite.config.js"))) {
-      if (!stack.frontend) { stack.frontend = "react"; stack.detected.push("vite.config (fallback)"); }
-      if (!stack.language) stack.language = "typescript";
-    }
-  }
-  if (!stack.frontend) {
-    if (fs.existsSync(path.join(ROOT, "nuxt.config.ts")) || fs.existsSync(path.join(ROOT, "nuxt.config.js"))) {
-      stack.frontend = "vue"; stack.detected.push("nuxt.config (fallback)");
-      if (!stack.language) stack.language = "typescript";
-    }
-  }
-
-  return stack;
-}
-
-// ─── Structure scan (multi-stack) ────────────────────────────────
-async function scanStructure(stack) {
-  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$/, "")
-        .replace(/-lib$/, "-lib");
-
-      // 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 (const dir of srcDirs) {
-      const name = path.basename(dir);
-      if (skipDirs.includes(name)) continue;
-      const files = await glob(`${dir}**/*.{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(".")) 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(".")) {
-            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/*/", { cwd: ROOT });
-      for (const dir of appDirs) {
-        const name = path.basename(dir);
-        if (["core", "common", "utils", "__pycache__"].includes(name)) continue;
-        const files = await glob(`${dir}*.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);
-  }
-}
-
-// ─── Domain group splitting (per type) ──────────────────────────
-function splitDomainGroups(domains, type, template) {
-  const MAX_FILES_PER_GROUP = 40;
-  const MAX_DOMAINS_PER_GROUP = 4;
-  const groups = [];
-  let current = [];
-  let fileCount = 0;
-
-  for (const d of domains) {
-    current.push(d.name);
-    fileCount += d.totalFiles;
-    if (fileCount >= MAX_FILES_PER_GROUP || current.length >= MAX_DOMAINS_PER_GROUP) {
-      groups.push({ type, template, domains: [...current], estimatedFiles: fileCount });
-      current = [];
-      fileCount = 0;
-    }
-  }
-  if (current.length > 0) {
-    groups.push({ type, template, domains: [...current], estimatedFiles: fileCount });
-  }
-
-  return groups;
-}
-
-// ─── Determine active domains ───────────────────────────────────
-function determineActiveDomains(stack) {
-  const isBackend = stack.framework && !["nextjs", "react", "vue"].includes(stack.framework);
-  return {
-    "00.core": true,
-    "10.backend": !!isBackend,
-    "20.frontend": !!stack.frontend,
-    "30.security-db": !!(stack.database || stack.framework),
-    "40.infra": true,
-    "50.verification": true,
-    "90.optional": true,
-  };
-}
-
-// ─── Template selection (multi-stack) ──────────────────────────────
-function selectTemplates(stack) {
-  const templates = { backend: null, frontend: null };
-
-  // Backend template
-  if (stack.language === "kotlin") templates.backend = "kotlin-spring";
-  else if (stack.language === "java") templates.backend = "java-spring";
-  else if (stack.framework === "express" || stack.framework === "nestjs") templates.backend = "node-express";
-  else if (stack.framework === "django") templates.backend = "python-django";
-  else if (stack.framework === "fastapi" || stack.framework === "flask") templates.backend = "python-fastapi";
-  else if (stack.language === "typescript" || stack.language === "javascript") templates.backend = "node-express";
-  else if (stack.language === "python") templates.backend = "python-fastapi";
-
-  // Frontend template
-  if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
-    templates.frontend = "node-nextjs";
-  }
-
-  // Pure frontend project with no backend
-  if (!templates.backend && templates.frontend) {
-    templates.backend = null;
-  }
-
-  return templates;
-}
-
-// ─── Dynamic prompt generation (multi-stack) ──────────────────────
-function generatePrompts(templates, lang) {
-  const commonDir  = path.join(TEMPLATES_DIR, "common");
-  const headerPath = path.join(commonDir, "header.md");
-  const footerPath = path.join(commonDir, "pass3-footer.md");
-  const langPath   = path.join(commonDir, "lang-instructions.json");
-
-  const header = fs.existsSync(headerPath) ? fs.readFileSync(headerPath, "utf-8") : "";
-  const footer = fs.existsSync(footerPath) ? fs.readFileSync(footerPath, "utf-8") : "";
-
-  // Load language instruction for Pass 3 (analysis passes stay English)
-  let langInstruction = "";
-  if (lang && lang !== "en" && fs.existsSync(langPath)) {
-    try {
-      const langData = JSON.parse(fs.readFileSync(langPath, "utf-8"));
-      langInstruction = langData.instructions[lang] || "";
-      if (langInstruction) {
-        console.log(`    🌐 Language: ${langData.labels[lang]} (Pass 3 output)`);
-      }
-    } catch (e) {
-      console.warn(`    ⚠️  lang-instructions.json parse error: ${e.message}`);
-    }
-  }
-
-  function readTemplate(templateName, passName) {
-    const src = path.join(TEMPLATES_DIR, templateName, `${passName}.md`);
-    if (!fs.existsSync(src)) return null;
-    let body = fs.readFileSync(src, "utf-8");
-    body = body.replace(/^Project root path:.*\nInterpret all file paths.*\n\n?---\n\n?/s, "");
-    body = body.replace(/\nAfter completion, run the following commands in order:[\s\S]*$/m, "");
-    return body;
-  }
-
-  const activeTemplates = [templates.backend, templates.frontend].filter(Boolean);
-  const primaryTemplate = templates.backend || templates.frontend;
-
-  // ─── Pass 1: Separate prompts per type ──────────────────────
-  for (const tmpl of activeTemplates) {
-    const type = tmpl === templates.frontend ? "frontend" : "backend";
-    const body = readTemplate(tmpl, "pass1");
-    if (body) {
-      const dst = path.join(GENERATED_DIR, `pass1-${type}-prompt.md`);
-      fs.writeFileSync(dst, header + body);
-      console.log(`    ✅ pass1-${type}-prompt.md (${tmpl})`);
-    }
-  }
-
-  // Single-stack backward compat: also generate pass1-prompt.md (primary-based)
-  if (primaryTemplate) {
-    const body = readTemplate(primaryTemplate, "pass1");
-    if (body) {
-      fs.writeFileSync(path.join(GENERATED_DIR, "pass1-prompt.md"), header + body);
-    }
-  }
-
-  // ─── Pass 2: Single prompt (primary-based, merges all pass1 results) ──
-  if (primaryTemplate) {
-    const body = readTemplate(primaryTemplate, "pass2");
-    if (body) {
-      fs.writeFileSync(path.join(GENERATED_DIR, "pass2-prompt.md"), header + body);
-      console.log(`    ✅ pass2-prompt.md (${primaryTemplate})`);
-    }
-  }
-
-  // ─── Pass 3: Combined prompt (backend + frontend merged) ──
-  if (primaryTemplate) {
-    const primaryBody = readTemplate(primaryTemplate, "pass3");
-    let combinedBody = primaryBody || "";
-
-    // Multi-stack: merge frontend-specific sections from frontend pass3 into backend pass3
-    if (templates.backend && templates.frontend && templates.backend !== templates.frontend) {
-      const frontendBody = readTemplate(templates.frontend, "pass3");
-      if (frontendBody) {
-        combinedBody += "\n\n---\n\n";
-        combinedBody += "# Additional: Frontend generation targets (auto-detected)\n\n";
-        combinedBody += "In addition to the backend standards above, also generate the following frontend standards.\n";
-        combinedBody += "Reference the frontend analysis results in pass2-merged.json.\n\n";
-        // Extract only standard sections from frontend pass3 (exclude CLAUDE.md, guide duplicates)
-        const frontendSections = frontendBody
-          .split(/\n(?=\d+\.\s)/)
-          .filter(s => /frontend|component|page|routing|data.fetch|state|styling/i.test(s))
-          .join("\n");
-        if (frontendSections.trim()) {
-          combinedBody += frontendSections;
-        }
-      }
-    }
-
-    const dst = path.join(GENERATED_DIR, "pass3-prompt.md");
-    fs.writeFileSync(dst, header + langInstruction + combinedBody.trimEnd() + "\n" + footer);
-    console.log(`    ✅ pass3-prompt.md${templates.frontend && templates.backend ? " (multi-stack combined)" : ""}`);
-  }
-}
-
-// ─── Main ───────────────────────────────────────────────
 async function main() {
-  console.log("\n╔══════════════════════════════════════╗");
+  console.log("\n╔═══════════════════════════════════════╗");
   console.log("║  ClaudeOS-Core — Plan Installer       ║");
-  console.log("╚══════════════════════════════════════╝\n");
+  console.log("╚═══════════════════════════════════════╝\n");
 
   ensureDir(GENERATED_DIR);
 
   // Phase 1: Stack detection
   console.log("  [Phase 1] Detecting stack...");
-  const stack = await detectStack();
+  const stack = await detectStack(ROOT);
   console.log(`    Language:    ${stack.language || "unknown"} ${stack.languageVersion || ""}`);
   console.log(`    Framework:   ${stack.framework || "none"} ${stack.frameworkVersion || ""}`);
   if (!stack.language && !stack.framework) {
@@ -1288,7 +45,7 @@ async function main() {
 
   // Phase 2: Structure scan
   console.log("  [Phase 2] Scanning structure...");
-  const { domains, backendDomains, frontendDomains, rootPackage, frontend } = await scanStructure(stack);
+  const { domains, backendDomains, frontendDomains, rootPackage, frontend } = await scanStructure(stack, ROOT);
   console.log(`    Backend:     ${backendDomains.length} domains`);
   console.log(`    Frontend:    ${frontendDomains.length} domains`);
   console.log(`    Total:       ${domains.length} domains`);
@@ -1296,33 +53,24 @@ async function main() {
   if (frontend.exists) console.log(`    Components:  ${frontend.components} components, ${frontend.pages} pages, ${frontend.hooks} hooks`);
   if (backendDomains.length === 0 && frontendDomains.length === 0) {
     console.warn("\n  ⚠️  No domains detected.");
-    console.warn("  Pass 1 will be skipped. Generated output may be minimal.");
-    console.warn("  Check your project structure — see README for supported patterns.\n");
+    console.warn("  Pass 1 will be skipped. Generated output may be minimal.\n");
   }
   console.log();
 
-  // Phase 3: Template selection (multi-stack)
+  // Phase 3: Template selection
   console.log("  [Phase 3] Selecting templates...");
   const templates = selectTemplates(stack);
   const isMultiStack = !!(templates.backend && templates.frontend);
   if (templates.backend) console.log(`    Backend:     ${templates.backend}`);
   if (templates.frontend) console.log(`    Frontend:    ${templates.frontend}`);
-  if (isMultiStack) console.log(`    Mode:        🔀 Multi-stack`);
-  else console.log(`    Mode:        Single-stack`);
+  console.log(`    Mode:        ${isMultiStack ? "🔀 Multi-stack" : "Single-stack"}`);
   console.log();
 
-  // Phase 4: Domain group splitting (per type)
+  // Phase 4: Domain group splitting
   console.log("  [Phase 4] Splitting domain groups...");
   const allGroups = [];
-  if (templates.backend && backendDomains.length > 0) {
-    const bg = splitDomainGroups(backendDomains, "backend", templates.backend);
-    allGroups.push(...bg);
-  }
-  if (templates.frontend && frontendDomains.length > 0) {
-    const fg = splitDomainGroups(frontendDomains, "frontend", templates.frontend);
-    allGroups.push(...fg);
-  }
-  // Reassign passNum
+  if (templates.backend && backendDomains.length > 0) allGroups.push(...splitDomainGroups(backendDomains, "backend", templates.backend));
+  if (templates.frontend && frontendDomains.length > 0) allGroups.push(...splitDomainGroups(frontendDomains, "frontend", templates.frontend));
   allGroups.forEach((g, i) => { g.passNum = i + 1; });
   allGroups.forEach((g, i) => {
     const icon = g.type === "backend" ? "⚙️" : "🎨";
@@ -1333,62 +81,44 @@ async function main() {
   // Phase 5: Active domains
   console.log("  [Phase 5] Active domains...");
   const active = determineActiveDomains(stack);
-  Object.entries(active).forEach(([k, v]) => {
-    console.log(`    ${v ? "✅" : "⏭️"} ${k}`);
-  });
+  Object.entries(active).forEach(([k, v]) => console.log(`    ${v ? "✅" : "⏭️"} ${k}`));
   console.log();
 
-  // Phase 6: Prompt generation (multi-stack)
+  // Phase 6: Prompt generation
   const lang = process.env.CLAUDEOS_LANG || "en";
   console.log(`  [Phase 6] Generating prompts (lang: ${lang})...`);
-  generatePrompts(templates, lang);
+  generatePrompts(templates, lang, TEMPLATES_DIR, GENERATED_DIR);
   console.log();
 
-  // Save: project-analysis.json
+  // Save outputs
   const defaultPort = stack.framework === "fastapi" || stack.framework === "django" ? 8000 : 8080;
   const analysis = {
-    analyzedAt: new Date().toISOString(),
-    lang,
+    analyzedAt: new Date().toISOString(), lang,
     stack: { ...stack, port: stack.port || defaultPort },
-    templates,
-    isMultiStack,
-    rootPackage,
-    domains,
-    backendDomains,
-    frontendDomains,
-    frontend,
+    templates, isMultiStack, rootPackage,
+    domains, backendDomains, frontendDomains, frontend,
     activeDomains: active,
     summary: {
-      totalDomains: domains.length,
-      backendDomains: backendDomains.length,
+      totalDomains: domains.length, backendDomains: backendDomains.length,
       frontendDomains: frontendDomains.length,
       totalFiles: domains.reduce((s, d) => s + d.totalFiles, 0),
     },
   };
-  fs.writeFileSync(path.join(GENERATED_DIR, "project-analysis.json"), JSON.stringify(analysis, null, 2));
+  writeFileSafe(path.join(GENERATED_DIR, "project-analysis.json"), JSON.stringify(analysis, null, 2));
   console.log("  💾 project-analysis.json saved");
 
-  // Save: domain-groups.json
   const domainGroups = {
-    generatedAt: new Date().toISOString(),
-    isMultiStack,
-    templates,
-    totalDomains: domains.length,
-    totalGroups: allGroups.length,
-    maxDomainsPerGroup: 4,
-    maxFilesPerGroup: 40,
-    groups: allGroups,
+    generatedAt: new Date().toISOString(), isMultiStack, templates,
+    totalDomains: domains.length, totalGroups: allGroups.length,
+    maxDomainsPerGroup: 4, maxFilesPerGroup: 40, groups: allGroups,
   };
-  fs.writeFileSync(path.join(GENERATED_DIR, "domain-groups.json"), JSON.stringify(domainGroups, null, 2));
+  writeFileSafe(path.join(GENERATED_DIR, "domain-groups.json"), JSON.stringify(domainGroups, null, 2));
   console.log("  💾 domain-groups.json saved\n");
-
   console.log("  ✅ Plan Installer complete\n");
 }
 
 main().catch(e => {
   console.error(`\n  ❌ Plan Installer failed: ${e.message || e}`);
-  if (e.code === "EACCES" || e.code === "EPERM") {
-    console.error("  Check file/directory permissions.");
-  }
+  if (e.code === "EACCES" || e.code === "EPERM") console.error("  Check file/directory permissions.");
   process.exit(1);
 });