@nikelyh/metamorph 2.1.1 → 2.1.2

package/README.md

@@ -20,10 +20,12 @@ Metamorph is a CLI tool powered by [Mozaik](https://github.com/jigjoy-ai/mozaik)
 
 ## Features
 
+- **Project Intelligence Engine (PIE)** -- Autonomously detects project architecture, frameworks, and monorepo workspace topologies (Turborepo, pnpm workspaces, npm/yarn workspaces, Lerna).
+- **Polymorphic Package Manager (PPME)** -- Automatically detects and adapts to your chosen package manager (`npm`, `pnpm`, `yarn`, `bun`) without host process leakage.
 - **Multi-Agent Concurrency** -- Utilizes Mapper, Worker, Reviewer, Integration, and Coordinator agents to migrate code in parallel.
-- **Zero Risk** -- All migrations happen in a `.metamorph/shadow` workspace. Your original code is completely untouched until you explicitly approve and apply the changes.
+- **Zero Risk (Shadow Workspace)** -- All migrations happen in an isolated `.metamorph/shadow` workspace. Your original code is completely untouched until you explicitly approve and apply the changes.
+- **Shadow Build Verification** -- Every migration is validated with your package manager (`npm`, `pnpm`, `yarn`, `bun`) and verification build inside the shadow workspace before completion.
 - **Visual Dashboard** -- Watch your agents work in real-time through the built-in local dashboard UI.
-- **Shadow Build Verification** -- Every migration is validated with `npm install` and `npm run build` inside the shadow workspace before completion.
 - **Extensive Framework Support** -- Easily migrate between popular frontend and backend frameworks.
 
 ## Installation
@@ -120,4 +122,4 @@ See the complete, up-to-date list of all supported frontend and backend framewor
 
 ---
 
-*Built with [Mozaik](https://github.com/jigjoy-ai/mozaik).*
+*Built with [Mozaik](https://github.com/jigjoy-ai/mozaik).* 💖

package/dist/ProjectDetector-WU3OD6WT.js

@@ -0,0 +1,16 @@
+import {
+  detectMonorepo,
+  detectTechnologies,
+  inspectManifest,
+  inspectProject,
+  inspectStructure,
+  resolveProjectRoot
+} from "./chunk-XLD7NXYU.js";
+export {
+  detectMonorepo,
+  detectTechnologies,
+  inspectManifest,
+  inspectProject,
+  inspectStructure,
+  resolveProjectRoot
+};

package/dist/{chunk-L7B6KUCW.js → chunk-APRESSUR.js}

@@ -1,6 +1,6 @@
 import {
   resolveMigrationCatalog
-} from "./chunk-VEAYUIOZ.js";
+} from "./chunk-WLHSZWET.js";
 
 // ../infrastructure/src/db/SQLiteStateStore.ts
 import { DatabaseSync } from "node:sqlite";
@@ -62,6 +62,10 @@ var SQLiteStateStore = class {
       this.db.exec("ALTER TABLE plans ADD COLUMN applied_branch TEXT");
     } catch (e) {
     }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN package_manager TEXT DEFAULT 'npm'");
+    } catch (e) {
+    }
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS tasks (
         plan_id TEXT,
@@ -84,8 +88,8 @@ var SQLiteStateStore = class {
   }
   async savePlan(plan) {
     const stmtPlan = this.db.prepare(`
-      INSERT OR REPLACE INTO plans (id, run_id, target_path, source_framework, target_framework, rules_json, created_at, integration_rounds, phase, outcome, applied_at, applied_branch)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT OR REPLACE INTO plans (id, run_id, target_path, source_framework, target_framework, rules_json, created_at, integration_rounds, phase, outcome, applied_at, applied_branch, package_manager)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmtPlan.run(
       plan.id,
@@ -99,7 +103,8 @@ var SQLiteStateStore = class {
       plan.phase || "files",
       plan.outcome || null,
       plan.appliedAt ? plan.appliedAt.toISOString() : null,
-      plan.appliedBranch || null
+      plan.appliedBranch || null,
+      plan.packageManager || "npm"
     );
     const stmtTask = this.db.prepare(`
       INSERT OR REPLACE INTO tasks (plan_id, file_path, status, dependencies_json, error)
@@ -120,6 +125,7 @@ var SQLiteStateStore = class {
       id: planRow.id,
       runId: planRow.run_id,
       targetPath: planRow.target_path,
+      packageManager: planRow.package_manager || "npm",
       profile: {
         source: planRow.source_framework,
         target: planRow.target_framework,
@@ -705,12 +711,16 @@ async function createApiServer(store, migrationRunner) {
   });
   app.get("/api/detect", async (req, res) => {
     try {
-      const { detectTechnologies } = await import("./TechDetector-5YP44RVR.js");
+      const { detectTechnologies: detectTechnologies2, inspectProject: inspectProject2, detectMonorepo } = await import("./ProjectDetector-WU3OD6WT.js");
       const targetPath = req.query.path ? String(req.query.path) : ".";
-      const detected = detectTechnologies(targetPath);
+      const monorepo = detectMonorepo(targetPath);
+      const profiles = inspectProject2(targetPath);
+      const detected = detectTechnologies2(targetPath);
       res.json({
         detected,
-        primary: detected.length > 0 ? detected[0].framework : null
+        profiles,
+        monorepo: monorepo.isMonorepo ? monorepo : null,
+        primary: profiles.length > 0 ? profiles[0].framework : null
       });
     } catch (error) {
       if (error instanceof Error) {

package/dist/{chunk-VEAYUIOZ.js → chunk-WLHSZWET.js}

@@ -1,3 +1,41 @@
+// ../domain/src/entities/PackageManagerCommands.ts
+function resolvePackageManagerCommands(pm) {
+  switch (pm) {
+    case "pnpm":
+      return {
+        name: "pnpm",
+        install: "pnpm install",
+        cleanInstall: "pnpm install",
+        runBuild: "pnpm run build",
+        runDev: "pnpm dev"
+      };
+    case "yarn":
+      return {
+        name: "yarn",
+        install: "yarn install",
+        cleanInstall: "yarn install",
+        runBuild: "yarn build",
+        runDev: "yarn dev"
+      };
+    case "bun":
+      return {
+        name: "bun",
+        install: "bun install",
+        cleanInstall: "bun install",
+        runBuild: "bun run build",
+        runDev: "bun dev"
+      };
+    default:
+      return {
+        name: "npm",
+        install: "npm install",
+        cleanInstall: "npm install --no-fund --no-audit",
+        runBuild: "npm run build",
+        runDev: "npm run dev"
+      };
+  }
+}
+
 // ../domain/src/entities/catalogs/backendCatalog.ts
 var backendCatalog = [
   {
@@ -1235,6 +1273,7 @@ var SemanticEventName = /* @__PURE__ */ ((SemanticEventName2) => {
 })(SemanticEventName || {});
 
 export {
+  resolvePackageManagerCommands,
   FRAMEWORK_PACKS,
   rulesForFramework,
   packForFramework,

package/dist/chunk-XLD7NXYU.js

@@ -0,0 +1,528 @@
+// ../infrastructure/src/detector/WorkspaceResolver.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join, resolve, dirname } from "path";
+function resolveProjectRoot(startPath) {
+  let current = resolve(startPath);
+  const root = resolve("/");
+  while (current && current !== root && current !== dirname(current)) {
+    if (existsSync(join(current, "package.json"))) {
+      return current;
+    }
+    if (existsSync(join(current, ".git"))) {
+      break;
+    }
+    current = dirname(current);
+  }
+  return resolve(startPath);
+}
+function findWorkspacePackages(rootDir, patterns) {
+  const packages = [];
+  for (const pattern of patterns) {
+    const cleanPattern = pattern.replace(/[\\/]+$/, "");
+    if (cleanPattern.endsWith("/*")) {
+      const parentDir = join(rootDir, cleanPattern.slice(0, -2));
+      if (existsSync(parentDir)) {
+        try {
+          const entries = readdirSync(parentDir);
+          for (const entry of entries) {
+            const subDir = join(parentDir, entry);
+            const pkgJsonPath = join(subDir, "package.json");
+            if (existsSync(pkgJsonPath) && statSync(subDir).isDirectory()) {
+              try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+                packages.push({
+                  name: pkg.name || entry,
+                  relativePath: join(cleanPattern.slice(0, -2), entry).replace(/\\/g, "/"),
+                  absolutePath: subDir
+                });
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      const subDir = join(rootDir, cleanPattern);
+      const pkgJsonPath = join(subDir, "package.json");
+      if (existsSync(pkgJsonPath) && statSync(subDir).isDirectory()) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+          packages.push({
+            name: pkg.name || cleanPattern,
+            relativePath: cleanPattern.replace(/\\/g, "/"),
+            absolutePath: subDir
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  return packages;
+}
+function detectMonorepo(projectPath) {
+  const rootPath = resolve(projectPath);
+  const pkgPath = join(rootPath, "package.json");
+  let tool;
+  let patterns = [];
+  const pnpmWorkspacePath = join(rootPath, "pnpm-workspace.yaml");
+  if (existsSync(pnpmWorkspacePath)) {
+    tool = "pnpm";
+    try {
+      const content = readFileSync(pnpmWorkspacePath, "utf-8");
+      const lines = content.split("\n");
+      let inPackages = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("packages:")) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          if (trimmed.startsWith("-")) {
+            const pattern = trimmed.replace(/^-\s*['"]?/, "").replace(/['"]?\s*$/, "");
+            if (pattern) patterns.push(pattern);
+          } else if (trimmed && !trimmed.startsWith("#")) {
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        if (Array.isArray(pkg.workspaces)) {
+          patterns.push(...pkg.workspaces);
+        } else if (Array.isArray(pkg.workspaces.packages)) {
+          patterns.push(...pkg.workspaces.packages);
+        }
+        if (!tool) tool = "npm";
+      }
+    } catch {
+    }
+  }
+  if (existsSync(join(rootPath, "turbo.json"))) {
+    tool = "turbo";
+  }
+  if (existsSync(join(rootPath, "lerna.json"))) {
+    if (!tool) tool = "lerna";
+    try {
+      const lerna = JSON.parse(readFileSync(join(rootPath, "lerna.json"), "utf-8"));
+      if (Array.isArray(lerna.packages)) {
+        patterns.push(...lerna.packages);
+      }
+    } catch {
+    }
+  }
+  if (existsSync(join(rootPath, "nx.json"))) {
+    if (!tool) tool = "nx";
+  }
+  if (tool && patterns.length === 0) {
+    patterns = ["apps/*", "packages/*", "services/*"];
+  }
+  const uniquePatterns = Array.from(new Set(patterns));
+  const packages = findWorkspacePackages(rootPath, uniquePatterns);
+  return {
+    isMonorepo: !!tool || packages.length > 0,
+    tool,
+    packages,
+    rootPath
+  };
+}
+
+// ../infrastructure/src/detector/ManifestInspector.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function inspectManifest(projectPath) {
+  const pkgPath = join2(projectPath, "package.json");
+  let rawPackageJson;
+  let dependencies = {};
+  let devDependencies = {};
+  let scripts = {};
+  if (existsSync2(pkgPath)) {
+    try {
+      rawPackageJson = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      dependencies = rawPackageJson?.dependencies || {};
+      devDependencies = rawPackageJson?.devDependencies || {};
+      scripts = rawPackageJson?.scripts || {};
+    } catch {
+    }
+  }
+  const allDependencies = {
+    ...devDependencies,
+    ...dependencies
+  };
+  let packageManager = "npm";
+  if (existsSync2(join2(projectPath, "pnpm-lock.yaml"))) {
+    packageManager = "pnpm";
+  } else if (existsSync2(join2(projectPath, "yarn.lock"))) {
+    packageManager = "yarn";
+  } else if (existsSync2(join2(projectPath, "bun.lockb")) || existsSync2(join2(projectPath, "bun.lock"))) {
+    packageManager = "bun";
+  } else if (rawPackageJson?.packageManager && typeof rawPackageJson.packageManager === "string") {
+    const pm = rawPackageJson.packageManager.toLowerCase();
+    if (pm.startsWith("pnpm")) packageManager = "pnpm";
+    else if (pm.startsWith("yarn")) packageManager = "yarn";
+    else if (pm.startsWith("bun")) packageManager = "bun";
+  }
+  let hasTsConfig = false;
+  let pathAliases = {};
+  const tsConfigPath = join2(projectPath, "tsconfig.json");
+  if (existsSync2(tsConfigPath)) {
+    hasTsConfig = true;
+    try {
+      const content = readFileSync2(tsConfigPath, "utf-8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "");
+      const tsconfig = JSON.parse(content);
+      if (tsconfig?.compilerOptions?.paths) {
+        pathAliases = tsconfig.compilerOptions.paths;
+      }
+    } catch {
+    }
+  }
+  const hasTsDependency = !!(allDependencies["typescript"] || allDependencies["ts-node"] || allDependencies["tsx"]);
+  const language = hasTsConfig || hasTsDependency ? "typescript" : "javascript";
+  return {
+    rawPackageJson,
+    allDependencies,
+    dependencies,
+    devDependencies,
+    scripts,
+    packageManager,
+    hasTsConfig,
+    language,
+    pathAliases
+  };
+}
+
+// ../infrastructure/src/detector/StructureInspector.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+function hasAnyFile(projectPath, relativePaths) {
+  for (const rel of relativePaths) {
+    if (existsSync3(join3(projectPath, rel))) {
+      return rel;
+    }
+  }
+  return void 0;
+}
+function scanCharacteristicExtensions(projectPath) {
+  const counts = {
+    vue: 0,
+    svelte: 0,
+    reactJsx: 0,
+    nestDecorators: 0
+  };
+  const srcDir = existsSync3(join3(projectPath, "src")) ? join3(projectPath, "src") : projectPath;
+  if (!existsSync3(srcDir)) return counts;
+  function traverse(dir, depth) {
+    if (depth > 3) return;
+    try {
+      const entries = readdirSync2(dir);
+      for (const entry of entries) {
+        if (entry === "node_modules" || entry === ".git" || entry === "dist" || entry === "build" || entry === ".next") {
+          continue;
+        }
+        const fullPath = join3(dir, entry);
+        try {
+          const stat = statSync2(fullPath);
+          if (stat.isDirectory()) {
+            traverse(fullPath, depth + 1);
+          } else if (stat.isFile()) {
+            const lower = entry.toLowerCase();
+            if (lower.endsWith(".vue")) counts.vue++;
+            else if (lower.endsWith(".svelte")) counts.svelte++;
+            else if (lower.endsWith(".tsx") || lower.endsWith(".jsx")) counts.reactJsx++;
+            else if (lower.endsWith(".controller.ts") || lower.endsWith(".module.ts")) counts.nestDecorators++;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  traverse(srcDir, 0);
+  return counts;
+}
+function inspectStructure(projectPath, deps, scripts) {
+  const existingConfigFiles = [];
+  const candidateConfigs = [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "next.config.cjs",
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+    "svelte.config.js",
+    "svelte.config.ts",
+    "angular.json",
+    "nest-cli.json",
+    "webpack.config.js",
+    "webpack.config.ts",
+    "vue.config.js"
+  ];
+  for (const config of candidateConfigs) {
+    if (existsSync3(join3(projectPath, config))) {
+      existingConfigFiles.push(config);
+    }
+  }
+  let bundler = "unknown";
+  if (existingConfigFiles.some((c) => c.startsWith("vite.config"))) {
+    bundler = "vite";
+  } else if (existingConfigFiles.includes("angular.json")) {
+    bundler = "angular-cli";
+  } else if (deps["next"] || existingConfigFiles.some((c) => c.startsWith("next.config"))) {
+    const scriptValues = Object.values(scripts).join(" ");
+    bundler = scriptValues.includes("--turbo") ? "turbopack" : "webpack";
+  } else if (existingConfigFiles.some((c) => c.startsWith("webpack.config")) || deps["webpack"]) {
+    bundler = "webpack";
+  } else if (deps["vite"]) {
+    bundler = "vite";
+  } else if (deps["esbuild"]) {
+    bundler = "esbuild";
+  } else if (deps["rollup"]) {
+    bundler = "rollup";
+  }
+  let routerVariant = "none";
+  const hasAppRouter = hasAnyFile(projectPath, [
+    "src/app/layout.tsx",
+    "src/app/layout.js",
+    "src/app/page.tsx",
+    "src/app/page.js",
+    "app/layout.tsx",
+    "app/layout.js",
+    "app/page.tsx",
+    "app/page.js"
+  ]);
+  const hasPagesRouter = hasAnyFile(projectPath, [
+    "src/pages/_app.tsx",
+    "src/pages/_app.js",
+    "src/pages/index.tsx",
+    "src/pages/index.js",
+    "pages/_app.tsx",
+    "pages/_app.js",
+    "pages/index.tsx",
+    "pages/index.js"
+  ]);
+  if (hasAppRouter) {
+    routerVariant = "next-app-router";
+  } else if (hasPagesRouter) {
+    routerVariant = "next-pages-router";
+  } else if (hasAnyFile(projectPath, ["src/routes/+page.svelte", "src/routes/+layout.svelte", "routes/+page.svelte"]) || deps["@sveltejs/kit"]) {
+    routerVariant = "sveltekit";
+  } else if (deps["vue-router"] || hasAnyFile(projectPath, ["src/router/index.ts", "src/router/index.js"])) {
+    routerVariant = "vue-router";
+  } else if (deps["react-router-dom"] || deps["react-router"] || deps["@remix-run/react"]) {
+    routerVariant = "react-router";
+  } else if (deps["@angular/router"]) {
+    routerVariant = "angular-router";
+  }
+  const extensionCounts = scanCharacteristicExtensions(projectPath);
+  return {
+    routerVariant,
+    bundler,
+    existingConfigFiles,
+    extensionCounts
+  };
+}
+
+// ../infrastructure/src/detector/rules/detectionRules.ts
+var FRAMEWORK_DETECTION_RULES = [
+  {
+    framework: "next",
+    category: "frontend-meta",
+    packageKeys: ["next"],
+    configPrefixes: ["next.config"],
+    routerVariants: ["next-app-router", "next-pages-router"],
+    subsumes: ["react", "react-dom"],
+    suggestedTargets: ["react", "vue", "angular", "svelte"]
+  },
+  {
+    framework: "react",
+    category: "frontend-spa",
+    packageKeys: ["react"],
+    configPrefixes: ["vite.config", "webpack.config"],
+    routerVariants: ["react-router"],
+    suggestedTargets: ["next", "vue", "angular", "svelte"]
+  },
+  {
+    framework: "vue",
+    category: "frontend-spa",
+    packageKeys: ["vue"],
+    devPackageKeys: ["@vitejs/plugin-vue"],
+    configPrefixes: ["vue.config", "vite.config"],
+    routerVariants: ["vue-router"],
+    suggestedTargets: ["react", "next", "angular", "svelte"]
+  },
+  {
+    framework: "svelte",
+    category: "frontend-spa",
+    packageKeys: ["svelte", "@sveltejs/kit"],
+    devPackageKeys: ["@sveltejs/vite-plugin-svelte"],
+    configPrefixes: ["svelte.config", "vite.config"],
+    routerVariants: ["sveltekit"],
+    suggestedTargets: ["react", "next", "vue", "angular"]
+  },
+  {
+    framework: "angular",
+    category: "frontend-spa",
+    packageKeys: ["@angular/core"],
+    devPackageKeys: ["@angular/cli", "@angular-devkit/build-angular"],
+    configPrefixes: ["angular.json"],
+    routerVariants: ["angular-router"],
+    suggestedTargets: ["react", "next", "vue", "svelte"]
+  },
+  {
+    framework: "nestjs",
+    category: "backend-api",
+    packageKeys: ["@nestjs/core", "@nestjs/common"],
+    configPrefixes: ["nest-cli.json"],
+    subsumes: ["express", "fastify", "@nestjs/platform-express", "@nestjs/platform-fastify"],
+    suggestedTargets: ["express", "fastify"]
+  },
+  {
+    framework: "express",
+    category: "backend-api",
+    packageKeys: ["express"],
+    configPrefixes: [],
+    suggestedTargets: ["fastify", "nestjs"]
+  },
+  {
+    framework: "fastify",
+    category: "backend-api",
+    packageKeys: ["fastify"],
+    configPrefixes: [],
+    suggestedTargets: ["express", "nestjs"]
+  }
+];
+
+// ../infrastructure/src/detector/SubsumptionEngine.ts
+function evaluateAndDisambiguate(manifest, structure) {
+  const candidates = [];
+  for (const rule of FRAMEWORK_DETECTION_RULES) {
+    const hasPackageMatch = rule.packageKeys.some((k) => manifest.dependencies[k] || manifest.devDependencies[k]) || rule.devPackageKeys && rule.devPackageKeys.some((k) => manifest.devDependencies[k]) || rule.framework === "vue" && structure.extensionCounts.vue > 0 || rule.framework === "svelte" && structure.extensionCounts.svelte > 0 || rule.framework === "nestjs" && structure.extensionCounts.nestDecorators > 0;
+    const hasDedicatedConfig = structure.existingConfigFiles.some(
+      (c) => rule.configPrefixes.some((p) => p !== "vite.config" && p !== "webpack.config" && c.startsWith(p))
+    );
+    if (!hasPackageMatch && !hasDedicatedConfig) {
+      continue;
+    }
+    let score = 0;
+    const evidence = [];
+    const subsumed = [];
+    for (const key of rule.packageKeys) {
+      if (manifest.dependencies[key]) {
+        score += 50;
+        evidence.push(`dependencies: "${key}": "${manifest.dependencies[key]}"`);
+      } else if (manifest.devDependencies[key]) {
+        score += 35;
+        evidence.push(`devDependencies: "${key}": "${manifest.devDependencies[key]}"`);
+      }
+    }
+    if (rule.devPackageKeys) {
+      for (const devKey of rule.devPackageKeys) {
+        if (manifest.devDependencies[devKey]) {
+          score += 25;
+          evidence.push(`devTooling: "${devKey}": "${manifest.devDependencies[devKey]}"`);
+        }
+      }
+    }
+    for (const prefix of rule.configPrefixes) {
+      const match = structure.existingConfigFiles.find((c) => c.startsWith(prefix));
+      if (match) {
+        score += 25;
+        evidence.push(`config: ${match}`);
+      }
+    }
+    if (rule.routerVariants && rule.routerVariants.includes(structure.routerVariant)) {
+      score += 30;
+      evidence.push(`router: ${structure.routerVariant}`);
+    }
+    if (rule.framework === "vue" && structure.extensionCounts.vue > 0) {
+      score += 20;
+      evidence.push(`source: found ${structure.extensionCounts.vue} .vue file(s)`);
+    } else if (rule.framework === "svelte" && structure.extensionCounts.svelte > 0) {
+      score += 20;
+      evidence.push(`source: found ${structure.extensionCounts.svelte} .svelte file(s)`);
+    } else if (rule.framework === "nestjs" && structure.extensionCounts.nestDecorators > 0) {
+      score += 20;
+      evidence.push(`source: found ${structure.extensionCounts.nestDecorators} nest decorator file(s)`);
+    }
+    if (score > 0) {
+      candidates.push({
+        rule,
+        score,
+        evidence,
+        subsumed
+      });
+    }
+  }
+  for (const candidate of candidates) {
+    if (candidate.rule.subsumes && candidate.score >= 50) {
+      for (const subsumedTarget of candidate.rule.subsumes) {
+        const targetCandidate = candidates.find((c) => c.rule.framework === subsumedTarget);
+        if (targetCandidate) {
+          candidate.subsumed.push(subsumedTarget);
+          candidate.evidence.push(
+            `subsumed "${subsumedTarget}" as an internal runtime/driver of ${candidate.rule.framework}`
+          );
+          targetCandidate.score = 0;
+        }
+      }
+    }
+  }
+  const activeCandidates = candidates.filter((c) => c.score > 0).sort((a, b) => b.score - a.score);
+  return activeCandidates.map((c) => {
+    return {
+      framework: c.rule.framework,
+      category: c.rule.category,
+      variant: structure.routerVariant,
+      bundler: structure.bundler,
+      packageManager: manifest.packageManager,
+      language: manifest.language,
+      hasTsConfig: manifest.hasTsConfig,
+      pathAliases: manifest.pathAliases,
+      confidence: Math.min(c.score, 100),
+      evidence: c.evidence,
+      subsumedDependencies: c.subsumed,
+      suggestedTargets: c.rule.suggestedTargets
+    };
+  });
+}
+
+// ../infrastructure/src/detector/ProjectDetector.ts
+function inspectProject(targetPath) {
+  const normalizedPath = resolveProjectRoot(targetPath);
+  const monorepo = detectMonorepo(normalizedPath);
+  const manifest = inspectManifest(normalizedPath);
+  const structure = inspectStructure(normalizedPath, manifest.allDependencies, manifest.scripts);
+  const profiles = evaluateAndDisambiguate(manifest, structure);
+  for (const profile of profiles) {
+    if (monorepo.isMonorepo) {
+      profile.monorepo = monorepo;
+    }
+  }
+  return profiles;
+}
+function detectTechnologies(targetPath) {
+  const profiles = inspectProject(targetPath);
+  return profiles.map((p) => ({
+    framework: p.framework,
+    confidence: p.confidence,
+    evidence: p.evidence,
+    profile: p
+  }));
+}
+
+export {
+  resolveProjectRoot,
+  detectMonorepo,
+  inspectManifest,
+  inspectStructure,
+  inspectProject,
+  detectTechnologies
+};