@nikelyh/metamorph 2.1.1 → 2.2.0

package/README.md

@@ -20,10 +20,15 @@ Metamorph is a CLI tool powered by [Mozaik](https://github.com/jigjoy-ai/mozaik)
 
 ## Features
 
+- **Project Intelligence Engine (PIE)** -- Autonomously detects project architecture, frameworks, dynamic entrypoints, 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.
+- **Structural Validation Plugins** -- Deterministic shadow workspace assertions, scaffold verifications, and repair heuristics for both frontend (Vue, Svelte, Angular) and backend (Express, Fastify, NestJS) migration targets.
+- **Cascading Configuration System** -- Tiered configuration management via `metamorph config` across CLI flags, env vars, `.metamorphrc.json`, and global user defaults.
+- **Token Accounting & Real-Time Cost Estimation** -- Live token tracking per model and estimated inference costs persisted in SQLite and displayed in the dashboard.
 - **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
@@ -96,6 +101,25 @@ Clear the local database and reset all events:
 metamorph reset
 ```
 
+### 5. Managing Configuration
+
+Metamorph provides a tiered configuration system that resolves settings across CLI flags, environment variables, local `.metamorphrc.json`, and global user config (`~/.metamorphrc.json`):
+
+```bash
+# View all effective configuration values and their sources
+metamorph config list
+
+# Set a persistent config value (e.g. LLM model or concurrency)
+metamorph config set model "gpt-4o"
+metamorph config set concurrency 3
+
+# Disable specific swarm agents for specialized runs
+metamorph config set disabledAgents "reporter"
+
+# Inspect the resolved config path
+metamorph config path
+```
+
 ### Utility Commands
 
 Test the technology detection on your repository without starting a migration:
@@ -120,4 +144,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-TPATF25O.js

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

package/dist/chunk-4G3X6IOY.js

@@ -0,0 +1,533 @@
+// ../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"],
+    devPackageKeys: ["@types/express"],
+    configPrefixes: [],
+    suggestedTargets: ["fastify", "nestjs"]
+  },
+  {
+    framework: "fastify",
+    category: "backend-api",
+    packageKeys: ["fastify"],
+    devPackageKeys: ["fastify-plugin"],
+    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 === "react" && structure.extensionCounts.reactJsx > 0) {
+      score += 20;
+      evidence.push(`source: found ${structure.extensionCounts.reactJsx} .tsx/.jsx file(s)`);
+    } else 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
+};