@nikelyh/metamorph 2.1.1 → 2.2.0

package/dist/{chunk-L7B6KUCW.js → chunk-6PDOFLME.js}

@@ -1,6 +1,9 @@
 import {
-  resolveMigrationCatalog
-} from "./chunk-VEAYUIOZ.js";
+  DEFAULT_METAMORPH_CONFIG,
+  createEmptyMigrationCostSummary,
+  resolveMigrationCatalog,
+  validateDisabledAgents
+} from "./chunk-7LIGC5J3.js";
 
 // ../infrastructure/src/db/SQLiteStateStore.ts
 import { DatabaseSync } from "node:sqlite";
@@ -62,6 +65,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,
@@ -81,11 +88,29 @@ var SQLiteStateStore = class {
         timestamp TEXT
       );
     `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS token_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT NOT NULL,
+        plan_id TEXT NOT NULL,
+        agent_role TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        prompt_tokens INTEGER NOT NULL,
+        completion_tokens INTEGER NOT NULL,
+        total_tokens INTEGER NOT NULL,
+        cost_usd REAL NOT NULL,
+        timestamp TEXT NOT NULL
+      );
+    `);
+    try {
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_token_usage_run ON token_usage(run_id);");
+    } catch (e) {
+    }
   }
   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 +124,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 +146,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,
@@ -185,10 +212,65 @@ var SQLiteStateStore = class {
       timestamp: new Date(row.timestamp)
     }));
   }
+  async recordTokenUsage(record) {
+    const stmt = this.db.prepare(`
+      INSERT INTO token_usage (run_id, plan_id, agent_role, model_id, prompt_tokens, completion_tokens, total_tokens, cost_usd, timestamp)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const timestamp = (record.timestamp || /* @__PURE__ */ new Date()).toISOString();
+    stmt.run(
+      record.runId,
+      record.planId,
+      record.agentRole,
+      record.modelId,
+      record.promptTokens,
+      record.completionTokens,
+      record.totalTokens,
+      record.costUsd,
+      timestamp
+    );
+  }
+  async getCostSummary(runId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM token_usage WHERE run_id = ? ORDER BY id ASC
+    `);
+    const rows = stmt.all(runId);
+    const planId = rows.length > 0 ? rows[0].plan_id : "";
+    const summary = createEmptyMigrationCostSummary(runId, planId);
+    for (const row of rows) {
+      summary.totalTokens += row.total_tokens;
+      summary.promptTokens += row.prompt_tokens;
+      summary.completionTokens += row.completion_tokens;
+      summary.totalCostUsd += row.cost_usd;
+      const role = row.agent_role;
+      if (summary.byAgentRole[role]) {
+        summary.byAgentRole[role].tokens += row.total_tokens;
+        summary.byAgentRole[role].promptTokens += row.prompt_tokens;
+        summary.byAgentRole[role].completionTokens += row.completion_tokens;
+        summary.byAgentRole[role].costUsd += row.cost_usd;
+        summary.byAgentRole[role].executions += 1;
+      }
+      if (!summary.byModel[row.model_id]) {
+        summary.byModel[row.model_id] = {
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+          costUsd: 0
+        };
+      }
+      summary.byModel[row.model_id].promptTokens += row.prompt_tokens;
+      summary.byModel[row.model_id].completionTokens += row.completion_tokens;
+      summary.byModel[row.model_id].totalTokens += row.total_tokens;
+      summary.byModel[row.model_id].costUsd += row.cost_usd;
+    }
+    summary.totalCostUsd = Math.round(summary.totalCostUsd * 1e6) / 1e6;
+    return summary;
+  }
   async reset() {
     this.db.exec(`DELETE FROM tasks`);
     this.db.exec(`DELETE FROM plans`);
     this.db.exec(`DELETE FROM events`);
+    this.db.exec(`DELETE FROM token_usage`);
   }
 };
 
@@ -300,9 +382,9 @@ function createRenameFileTool(sandboxDir) {
       if (!fsExists(resolvedOld)) {
         return { error: `File not found: ${resolvedOld}` };
       }
-      const { mkdirSync: mkdirSync2 } = await import("fs");
-      const { dirname } = await import("path");
-      mkdirSync2(dirname(resolvedNew), { recursive: true });
+      const { mkdirSync: mkdirSync3 } = await import("fs");
+      const { dirname: dirname2 } = await import("path");
+      mkdirSync3(dirname2(resolvedNew), { recursive: true });
       renameSync(resolvedOld, resolvedNew);
       const sourceFile = project.getSourceFile(resolvedOld);
       if (sourceFile) {
@@ -332,10 +414,10 @@ function createCreateFileTool(sandboxDir) {
     strict: true,
     invoke: async ({ filePath, content }) => {
       const resolvedPath = assertSandbox(filePath, sandboxDir);
-      const { writeFileSync, mkdirSync: mkdirSync2 } = await import("fs");
-      const { dirname } = await import("path");
-      mkdirSync2(dirname(resolvedPath), { recursive: true });
-      writeFileSync(resolvedPath, content, "utf-8");
+      const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync3 } = await import("fs");
+      const { dirname: dirname2 } = await import("path");
+      mkdirSync3(dirname2(resolvedPath), { recursive: true });
+      writeFileSync2(resolvedPath, content, "utf-8");
       project.addSourceFileAtPath(resolvedPath);
       return { success: true, message: `File created at ${resolvedPath}.` };
     }
@@ -670,15 +752,28 @@ async function createApiServer(store, migrationRunner) {
       }
     }
   });
+  app.get("/api/cost/:runId", async (req, res) => {
+    try {
+      const runId = String(req.params.runId);
+      const summary = await store.getCostSummary(runId);
+      res.json(summary);
+    } catch (error) {
+      if (error instanceof Error) {
+        res.status(500).json({ error: error.message });
+      } else {
+        res.status(500).json({ error: String(error) });
+      }
+    }
+  });
   app.get("/api/browse", async (req, res) => {
     try {
       const { readdirSync, statSync: statSync2 } = await import("fs");
-      const { resolve: resolve5, join: join7 } = await import("path");
+      const { resolve: resolve5, join: join8 } = await import("path");
       const targetPath = req.query.path ? resolve5(String(req.query.path)) : resolve5(".");
       const entries = readdirSync(targetPath).filter(
         (name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist" && name !== "build"
       ).map((name) => {
-        const full = join7(targetPath, name);
+        const full = join8(targetPath, name);
         try {
           const stat = statSync2(full);
           return {
@@ -705,12 +800,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-TPATF25O.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) {
@@ -825,16 +924,16 @@ async function createApiServer(store, migrationRunner) {
       }
     });
   }
-  const path5 = await import("path");
-  const fs4 = await import("fs");
-  let publicDir = path5.join(import.meta.dirname, "public");
-  if (!fs4.existsSync(publicDir)) {
-    publicDir = path5.join(import.meta.dirname, "../public");
+  const path6 = await import("path");
+  const fs5 = await import("fs");
+  let publicDir = path6.join(import.meta.dirname, "public");
+  if (!fs5.existsSync(publicDir)) {
+    publicDir = path6.join(import.meta.dirname, "../public");
   }
-  if (fs4.existsSync(publicDir)) {
+  if (fs5.existsSync(publicDir)) {
     app.use(express.static(publicDir));
     app.get(/^(.*)$/, (_req, res) => {
-      res.sendFile(path5.join(publicDir, "index.html"));
+      res.sendFile(path6.join(publicDir, "index.html"));
     });
   }
   return app;
@@ -997,6 +1096,156 @@ ${result.output}`;
   }
 });
 
+// ../infrastructure/src/config/ConfigStore.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as os from "os";
+var CONFIG_FILE_NAME = ".metamorphrc.json";
+var ConfigStore = class {
+  /**
+   * Retrieves the absolute path to the local or global configuration file.
+   */
+  static getConfigPath(isGlobal = false, cwd = process.cwd()) {
+    return isGlobal ? path5.join(os.homedir(), CONFIG_FILE_NAME) : path5.join(cwd, CONFIG_FILE_NAME);
+  }
+  /**
+   * Reads a JSON configuration file safely.
+   */
+  static readConfigFile(filePath) {
+    if (!fs4.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const raw = fs4.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return null;
+      }
+      if (Array.isArray(parsed.disabledAgents)) {
+        const validation = validateDisabledAgents(parsed.disabledAgents);
+        if (validation.valid) {
+          parsed.disabledAgents = validation.disabled;
+        } else {
+          delete parsed.disabledAgents;
+        }
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Writes a JSON configuration file safely, creating parent folders if necessary.
+   */
+  static writeConfigFile(filePath, config) {
+    const dir = path5.dirname(filePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf-8");
+  }
+  /**
+   * Reads the local configuration file (.metamorphrc.json) from the target directory.
+   */
+  static loadLocalConfig(cwd = process.cwd()) {
+    return this.readConfigFile(this.getConfigPath(false, cwd));
+  }
+  /**
+   * Reads the global configuration file (~/.metamorphrc.json) from the user's home directory.
+   */
+  static loadGlobalConfig() {
+    return this.readConfigFile(this.getConfigPath(true));
+  }
+  /**
+   * Persists a key-value update into the local configuration file.
+   */
+  static saveLocalConfig(config, cwd = process.cwd()) {
+    const existing = this.loadLocalConfig(cwd) || {};
+    const updated = { ...existing, ...config };
+    this.writeConfigFile(this.getConfigPath(false, cwd), updated);
+  }
+  /**
+   * Persists a key-value update into the global configuration file.
+   */
+  static saveGlobalConfig(config) {
+    const existing = this.loadGlobalConfig() || {};
+    const updated = { ...existing, ...config };
+    this.writeConfigFile(this.getConfigPath(true), updated);
+  }
+  /**
+   * Extracts environment variable configurations if present.
+   */
+  static loadEnvConfig(env = process.env) {
+    const envConfig = {};
+    if (env.METAMORPH_MODEL) {
+      envConfig.model = env.METAMORPH_MODEL;
+    }
+    if (env.METAMORPH_REVIEWER_MODEL) {
+      envConfig.reviewerModel = env.METAMORPH_REVIEWER_MODEL;
+    }
+    if (env.METAMORPH_CONCURRENCY) {
+      const parsed = parseInt(env.METAMORPH_CONCURRENCY, 10);
+      if (!Number.isNaN(parsed) && parsed > 0) {
+        envConfig.concurrency = parsed;
+      }
+    }
+    if (env.METAMORPH_INFERENCE_TIMEOUT_MS) {
+      const parsed = parseInt(env.METAMORPH_INFERENCE_TIMEOUT_MS, 10);
+      if (!Number.isNaN(parsed) && parsed > 0) {
+        envConfig.inferenceTimeoutMs = parsed;
+      }
+    }
+    if (env.METAMORPH_MAX_RETRIES) {
+      const parsed = parseInt(env.METAMORPH_MAX_RETRIES, 10);
+      if (!Number.isNaN(parsed) && parsed >= 0) {
+        envConfig.maxRetries = parsed;
+      }
+    }
+    if (env.METAMORPH_INTEGRATION_ROUNDS) {
+      const parsed = parseInt(env.METAMORPH_INTEGRATION_ROUNDS, 10);
+      if (!Number.isNaN(parsed) && parsed > 0) {
+        envConfig.maxIntegrationRounds = parsed;
+      }
+    }
+    if (env.METAMORPH_DISABLED_AGENTS) {
+      const parts = env.METAMORPH_DISABLED_AGENTS.split(",").map((s) => s.trim());
+      const validation = validateDisabledAgents(parts);
+      if (validation.valid) {
+        envConfig.disabledAgents = validation.disabled;
+      }
+    }
+    return envConfig;
+  }
+  /**
+   * Resolves the final effective MetamorphConfig applying the cascading precedence:
+   * CLI Flags > Environment Variables > Local Config > Global Config > Defaults.
+   */
+  static resolveConfig(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const globalConfig = this.loadGlobalConfig() || {};
+    const localConfig = this.loadLocalConfig(cwd) || {};
+    const envConfig = this.loadEnvConfig(options.env || process.env);
+    const cliFlags = options.cliFlags || {};
+    const clean = (obj) => {
+      const res = {};
+      for (const [k, v] of Object.entries(obj)) {
+        if (v !== void 0 && v !== null) {
+          res[k] = v;
+        }
+      }
+      return res;
+    };
+    const merged = {
+      ...DEFAULT_METAMORPH_CONFIG,
+      ...clean(globalConfig),
+      ...clean(localConfig),
+      ...clean(envConfig),
+      ...clean(cliFlags)
+    };
+    return merged;
+  }
+};
+
 export {
   SQLiteStateStore,
   assertSandbox,
@@ -1014,5 +1263,7 @@ export {
   createCheckProjectDiagnosticsTool,
   runInShadowWorkspace,
   parseImplicatedFiles,
-  createRunBuildTool
+  createRunBuildTool,
+  CONFIG_FILE_NAME,
+  ConfigStore
 };

package/dist/{chunk-VEAYUIOZ.js → chunk-7LIGC5J3.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 = [
   {
@@ -65,10 +103,14 @@ export function createAppRouter(appService: AppService): Router {
       "@nestjs/cli": "latest",
       "@nestjs/schematics": "latest",
       "@nestjs/testing": "latest",
+      "@types/node": "^20.0.0",
       "@types/supertest": "^2.0.12",
       "source-map-support": "^0.5.21",
       "supertest": "^6.3.3"
     },
+    scriptsToUpdate: {
+      "build": "tsc"
+    },
     architecturalRules: [
       "Express routing logic must be encapsulated in classes decorated with @Controller().",
       "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
@@ -263,10 +305,15 @@ app.listen(3000);`
       "@nestjs/cli": "latest",
       "@nestjs/schematics": "latest",
       "@nestjs/testing": "latest",
+      "@types/node": "^20.0.0",
       "@types/supertest": "^2.0.12",
       "source-map-support": "^0.5.21",
       "supertest": "^6.3.3"
     },
+    scriptsToUpdate: {
+      "build": "tsc"
+    },
+    scriptsToRemove: ["dev:start", "watch:ts"],
     architecturalRules: [
       "Fastify routing logic must be encapsulated in classes decorated with @Controller().",
       "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
@@ -1218,6 +1265,198 @@ function findMigrationCatalogEntry(source, target) {
   return resolveMigrationCatalog(source, target);
 }
 
+// ../domain/src/entities/MetamorphConfig.ts
+var DEFAULT_METAMORPH_CONFIG = {
+  model: "gpt-5.4",
+  concurrency: 3,
+  inferenceTimeoutMs: 12e4,
+  maxRetries: 2,
+  maxIntegrationRounds: 4,
+  disabledAgents: []
+};
+var MOZAIK_BUNDLED_MODELS = [
+  // OpenAI
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.4-nano",
+  "gpt-5.5",
+  // Anthropic
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+  "claude-opus-4-7",
+  "claude-opus-4-8"
+];
+function isMozaikBundledModel(model) {
+  return MOZAIK_BUNDLED_MODELS.includes(model);
+}
+function isMetamorphConfigKey(key) {
+  return [
+    "model",
+    "reviewerModel",
+    "concurrency",
+    "inferenceTimeoutMs",
+    "maxRetries",
+    "maxIntegrationRounds",
+    "disabledAgents"
+  ].includes(key);
+}
+
+// ../domain/src/entities/AgentTaxonomy.ts
+var CORE_AGENTS = [
+  "coordinator",
+  "mapper",
+  "worker",
+  "packagemanager",
+  "integration"
+];
+var AUXILIARY_AGENTS = [
+  "reporter",
+  "reviewer",
+  "accounting"
+];
+var ALL_SWARM_AGENTS = [
+  ...CORE_AGENTS,
+  ...AUXILIARY_AGENTS
+];
+function isCoreAgentId(id) {
+  return CORE_AGENTS.includes(id.toLowerCase());
+}
+function isAuxiliaryAgentId(id) {
+  return AUXILIARY_AGENTS.includes(id.toLowerCase());
+}
+function validateDisabledAgents(agentNames) {
+  const normalized = [];
+  for (const rawName of agentNames) {
+    const clean = rawName.trim().toLowerCase();
+    if (!clean) continue;
+    if (isCoreAgentId(clean)) {
+      return {
+        valid: false,
+        disabled: [],
+        error: `Cannot disable core agent '${clean}'. Only auxiliary agents [${AUXILIARY_AGENTS.join(", ")}] can be disabled.`
+      };
+    }
+    if (!isAuxiliaryAgentId(clean)) {
+      return {
+        valid: false,
+        disabled: [],
+        error: `Unknown agent '${clean}'. Available auxiliary agents to disable: [${AUXILIARY_AGENTS.join(", ")}].`
+      };
+    }
+    if (!normalized.includes(clean)) {
+      normalized.push(clean);
+    }
+  }
+  return {
+    valid: true,
+    disabled: normalized
+  };
+}
+
+// ../domain/src/entities/TokenUsage.ts
+function createEmptyAgentRoleCost() {
+  return {
+    tokens: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    costUsd: 0,
+    executions: 0
+  };
+}
+function createEmptyMigrationCostSummary(runId = "", planId = "") {
+  return {
+    runId,
+    planId,
+    totalTokens: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    totalCostUsd: 0,
+    byAgentRole: {
+      worker: createEmptyAgentRoleCost(),
+      reviewer: createEmptyAgentRoleCost(),
+      integration: createEmptyAgentRoleCost(),
+      coordinator: createEmptyAgentRoleCost(),
+      mapper: createEmptyAgentRoleCost()
+    },
+    byModel: {}
+  };
+}
+
+// ../domain/src/entities/PricingCatalog.ts
+var BUNDLED_MODEL_PRICING = {
+  // OpenAI
+  "gpt-5.4": {
+    modelId: "gpt-5.4",
+    inputPricePerMillion: 2.5,
+    outputPricePerMillion: 10,
+    currency: "USD"
+  },
+  "gpt-5.4-mini": {
+    modelId: "gpt-5.4-mini",
+    inputPricePerMillion: 0.15,
+    outputPricePerMillion: 0.6,
+    currency: "USD"
+  },
+  "gpt-5.4-nano": {
+    modelId: "gpt-5.4-nano",
+    inputPricePerMillion: 0.05,
+    outputPricePerMillion: 0.2,
+    currency: "USD"
+  },
+  "gpt-5.5": {
+    modelId: "gpt-5.5",
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 12,
+    currency: "USD"
+  },
+  // Anthropic
+  "claude-sonnet-4-6": {
+    modelId: "claude-sonnet-4-6",
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    currency: "USD"
+  },
+  "claude-haiku-4-5": {
+    modelId: "claude-haiku-4-5",
+    inputPricePerMillion: 0.8,
+    outputPricePerMillion: 4,
+    currency: "USD"
+  },
+  "claude-opus-4-7": {
+    modelId: "claude-opus-4-7",
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 75,
+    currency: "USD"
+  },
+  "claude-opus-4-8": {
+    modelId: "claude-opus-4-8",
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 75,
+    currency: "USD"
+  }
+};
+function resolvePricingTier(modelId, customPricing) {
+  if (customPricing && customPricing[modelId]) {
+    return customPricing[modelId];
+  }
+  if (modelId in BUNDLED_MODEL_PRICING) {
+    return BUNDLED_MODEL_PRICING[modelId];
+  }
+  return {
+    modelId,
+    inputPricePerMillion: 0,
+    outputPricePerMillion: 0,
+    currency: "USD"
+  };
+}
+function calculateTokenCost(modelId, promptTokens, completionTokens, customPricing) {
+  const tier = resolvePricingTier(modelId, customPricing);
+  const inputCost = promptTokens / 1e6 * tier.inputPricePerMillion;
+  const outputCost = completionTokens / 1e6 * tier.outputPricePerMillion;
+  const totalCost = inputCost + outputCost;
+  return Math.round(totalCost * 1e6) / 1e6;
+}
+
 // ../domain/src/events/SemanticEvents.ts
 var SemanticEventName = /* @__PURE__ */ ((SemanticEventName2) => {
   SemanticEventName2["MIGRATION_STARTED"] = "migration.started";
@@ -1230,11 +1469,14 @@ var SemanticEventName = /* @__PURE__ */ ((SemanticEventName2) => {
   SemanticEventName2["PHASE_PACKAGES_READY"] = "phase.packages_ready";
   SemanticEventName2["PHASE_INTEGRATION_STARTED"] = "phase.integration_started";
   SemanticEventName2["MIGRATION_COMPLETED"] = "migration.completed";
+  SemanticEventName2["TOKENS_REPORTED"] = "tokens.reported";
+  SemanticEventName2["TOKENS_CONSUMED"] = "tokens.consumed";
   SemanticEventName2["SYSTEM_LOG"] = "system.log";
   return SemanticEventName2;
 })(SemanticEventName || {});
 
 export {
+  resolvePackageManagerCommands,
   FRAMEWORK_PACKS,
   rulesForFramework,
   packForFramework,
@@ -1252,5 +1494,20 @@ export {
   resolveMigrationCatalog,
   MigrationCatalog,
   findMigrationCatalogEntry,
+  DEFAULT_METAMORPH_CONFIG,
+  MOZAIK_BUNDLED_MODELS,
+  isMozaikBundledModel,
+  isMetamorphConfigKey,
+  CORE_AGENTS,
+  AUXILIARY_AGENTS,
+  ALL_SWARM_AGENTS,
+  isCoreAgentId,
+  isAuxiliaryAgentId,
+  validateDisabledAgents,
+  createEmptyAgentRoleCost,
+  createEmptyMigrationCostSummary,
+  BUNDLED_MODEL_PRICING,
+  resolvePricingTier,
+  calculateTokenCost,
   SemanticEventName
 };