claudeos-core 1.2.4 → 1.3.1

package/plan-installer/prompt-generator.js

@@ -0,0 +1,94 @@
+/**
+ * ClaudeOS-Core — Prompt Generator
+ *
+ * Generates dynamic prompts for Pass 1/2/3 based on detected stack and language.
+ * Supports multi-stack combined prompts (backend + frontend merged in Pass 3).
+ */
+
+const path = require("path");
+const { readFileSafe, readJsonSafe, existsSafe, writeFileSafe } = require("../lib/safe-fs");
+
+/**
+ * Generate pass prompts from templates.
+ * @param {object} templates - { backend: string|null, frontend: string|null }
+ * @param {string} lang - output language code (e.g. "ko", "en")
+ * @param {string} templatesDir - path to pass-prompts/templates/
+ * @param {string} generatedDir - path to claudeos-core/generated/
+ */
+function generatePrompts(templates, lang, templatesDir, generatedDir) {
+  const commonDir  = path.join(templatesDir, "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 = existsSafe(headerPath) ? readFileSafe(headerPath) : "";
+  const footer = existsSafe(footerPath) ? readFileSafe(footerPath) : "";
+
+  let langInstruction = "";
+  if (lang && lang !== "en" && existsSafe(langPath)) {
+    const langData = readJsonSafe(langPath);
+    if (langData && langData.instructions && langData.instructions[lang]) {
+      langInstruction = langData.instructions[lang];
+      console.log(`    🌐 Language: ${langData.labels[lang]} (Pass 3 output)`);
+    }
+  }
+
+  function readTemplate(templateName, passName) {
+    const src = path.join(templatesDir, templateName, `${passName}.md`);
+    if (!existsSafe(src)) return null;
+    let body = readFileSafe(src);
+    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]*$/, "");
+    return body;
+  }
+
+  const activeTemplates = [templates.backend, templates.frontend].filter(Boolean);
+  const primaryTemplate = templates.backend || templates.frontend;
+
+  for (let ti = 0; ti < activeTemplates.length; ti++) {
+    const tmpl = activeTemplates[ti];
+    const type = (tmpl === templates.frontend && tmpl !== templates.backend) ? "frontend"
+      : (ti === 1 && templates.frontend) ? "frontend" : "backend";
+    const body = readTemplate(tmpl, "pass1");
+    if (body) {
+      writeFileSafe(path.join(generatedDir, `pass1-${type}-prompt.md`), header + body);
+      console.log(`    ✅ pass1-${type}-prompt.md (${tmpl})`);
+    }
+  }
+
+  if (primaryTemplate) {
+    const body = readTemplate(primaryTemplate, "pass2");
+    if (body) {
+      writeFileSafe(path.join(generatedDir, "pass2-prompt.md"), header + body);
+      console.log(`    ✅ pass2-prompt.md (${primaryTemplate})`);
+    }
+  }
+
+  if (primaryTemplate) {
+    const primaryBody = readTemplate(primaryTemplate, "pass3");
+    let combinedBody = primaryBody || "";
+
+    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";
+        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;
+      }
+    }
+
+    writeFileSafe(
+      path.join(generatedDir, "pass3-prompt.md"),
+      header + langInstruction + combinedBody.trimEnd() + "\n" + footer
+    );
+    console.log(`    ✅ pass3-prompt.md${templates.frontend && templates.backend ? " (multi-stack combined)" : ""}`);
+  }
+}
+
+module.exports = { generatePrompts };

package/plan-installer/stack-detector.js

@@ -0,0 +1,326 @@
+/**
+ * ClaudeOS-Core — Stack Detector
+ *
+ * Detects project language, framework, build tool, database, ORM, and frontend.
+ * Supports: Java, Kotlin, TypeScript/JavaScript, Python
+ * Multi-stack aware (backend + frontend simultaneous detection).
+ */
+
+const path = require("path");
+const { glob } = require("glob");
+const { readFileSafe, readJsonSafe, existsSafe } = require("../lib/safe-fs");
+
+/**
+ * Detect the project's technology stack.
+ * @param {string} ROOT - project root path
+ * @returns {Promise<object>} stack info
+ */
+async function detectStack(ROOT) {
+  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 = existsSafe(path.join(ROOT, "build.gradle.kts"))
+    ? "build.gradle.kts"
+    : existsSafe(path.join(ROOT, "build.gradle")) ? "build.gradle" : null;
+  if (gradleFile) {
+    const g = readFileSafe(path.join(ROOT, gradleFile));
+    if (g) {
+      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 && /\bh2\b/.test(g)) { 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");
+        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) ──
+  const versionCatalog = path.join(ROOT, "gradle/libs.versions.toml");
+  if (existsSafe(versionCatalog)) {
+    const vc = readFileSafe(versionCatalog);
+    if (vc) {
+      stack.detected.push("libs.versions.toml");
+      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];
+      }
+      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"; }
+      if (!stack.language && vc.includes("kotlin")) {
+        stack.language = "kotlin"; stack.detected.push("kotlin (catalog)");
+      }
+    }
+  }
+
+  // ── Kotlin: multi-module Gradle detection ──
+  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 = readFileSafe(path.join(ROOT, sbf));
+      if (sc && (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 from settings.gradle ──
+  const settingsFile = existsSafe(path.join(ROOT, "settings.gradle.kts"))
+    ? "settings.gradle.kts"
+    : existsSafe(path.join(ROOT, "settings.gradle")) ? "settings.gradle" : null;
+  if (settingsFile && stack.language === "kotlin") {
+    const sg = readFileSafe(path.join(ROOT, settingsFile));
+    if (sg) {
+      const sgClean = sg.split("\n").filter(l => !l.trimStart().startsWith("//")).join("\n");
+      const includes = [];
+      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);
+      }
+      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);
+        }
+      }
+      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)`);
+        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 (existsSafe(path.join(ROOT, "pom.xml"))) {
+    const pom = readFileSafe(path.join(ROOT, "pom.xml"));
+    if (pom) {
+      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 && /\bh2\b/.test(pom)) stack.database = "h2";
+      if (!stack.database && pom.includes("sqlite")) stack.database = "sqlite";
+    }
+  }
+
+  // ── Node.js ──
+  if (existsSafe(path.join(ROOT, "package.json"))) {
+    const pkg = readJsonSafe(path.join(ROOT, "package.json"));
+    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"); const tv = deps.typescript.match(/(\d+(?:\.\d+)*)/); if (tv) stack.languageVersion = tv[1]; }
+
+      // 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 = existsSafe(path.join(ROOT, "pnpm-lock.yaml")) ? "pnpm"
+        : existsSafe(path.join(ROOT, "yarn.lock")) ? "yarn" : "npm";
+
+      if (pkg.engines && pkg.engines.node && !stack.languageVersion) {
+        const nv = pkg.engines.node.match(/(\d+(?:\.\d+)*)/);
+        if (nv) stack.languageVersion = nv[1];
+      }
+    }
+  }
+
+  // ── Python ──
+  const hasPyproject = existsSafe(path.join(ROOT, "pyproject.toml"));
+  const hasRequirements = existsSafe(path.join(ROOT, "requirements.txt"));
+  if (hasPyproject || hasRequirements) {
+    if (!stack.language) stack.language = "python";
+    stack.detected.push("python");
+
+    if (hasPyproject) {
+      const pp = readFileSafe(path.join(ROOT, "pyproject.toml"));
+      if (pp) {
+        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 = readFileSafe(path.join(ROOT, "requirements.txt"));
+      if (r) {
+        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 = existsSafe(path.join(ROOT, "Pipfile")) ? "pipenv"
+        : existsSafe(path.join(ROOT, "poetry.lock")) ? "poetry" : "pip";
+    }
+  }
+
+  // ── DB from config files ──
+  const ymls = await glob("**/application*.yml", { cwd: ROOT, absolute: true, ignore: ["**/node_modules/**", "**/build/**", "**/target/**", "**/.gradle/**"] });
+  for (const y of ymls) {
+    const c = readFileSafe(y);
+    if (!c) continue;
+    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 (existsSafe(ep)) {
+      const ec = readFileSafe(ep);
+      if (ec && 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 (existsSafe(prismaSchema)) {
+    const ps = readFileSafe(prismaSchema);
+    if (ps) {
+      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) ──
+  if (!stack.frontend) {
+    const nextConfigs = ["next.config.js", "next.config.mjs", "next.config.ts"];
+    if (nextConfigs.some(c => existsSafe(path.join(ROOT, c)))) {
+      stack.frontend = "nextjs"; stack.detected.push("next.config (fallback)");
+      if (!stack.language) stack.language = "typescript";
+    }
+  }
+  if (!stack.frontend) {
+    if (existsSafe(path.join(ROOT, "vite.config.ts")) || existsSafe(path.join(ROOT, "vite.config.js"))) {
+      stack.frontend = "react"; stack.detected.push("vite.config (fallback)");
+      if (!stack.language) stack.language = "typescript";
+    }
+  }
+  if (!stack.frontend) {
+    if (existsSafe(path.join(ROOT, "nuxt.config.ts")) || existsSafe(path.join(ROOT, "nuxt.config.js"))) {
+      stack.frontend = "vue"; stack.detected.push("nuxt.config (fallback)");
+      if (!stack.language) stack.language = "typescript";
+    }
+  }
+
+  return stack;
+}
+
+module.exports = { detectStack };