@nikelyh/metamorph 2.0.0

package/dist/index.js

@@ -0,0 +1,2700 @@
+#!/usr/bin/env node
+import {
+  require_ts_morph
+} from "./chunk-RCULELX2.js";
+import {
+  detectTechnologies
+} from "./chunk-3QN2Q75J.js";
+import {
+  MetamorphState,
+  initializeRuntime,
+  join,
+  leave,
+  resolveRuntime,
+  runLoop,
+  sendEvent
+} from "./chunk-DJO6FY4K.js";
+import {
+  SituationSpecification,
+  createAgent
+} from "./chunk-XHQSMB6V.js";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-VS2QQHAK.js";
+
+// ../../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../../node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs7 = __require("fs");
+    var path6 = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs7.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path6.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs7.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path6.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path6.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path7 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs7.readFileSync(path7, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path7} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative2 = path6.relative(process.cwd(), filePath);
+            shortPaths.push(relative2);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// ../../../node_modules/dotenv/lib/env-options.js
+var require_env_options = __commonJS({
+  "../../../node_modules/dotenv/lib/env-options.js"(exports, module) {
+    "use strict";
+    var options = {};
+    if (process.env.DOTENV_CONFIG_ENCODING != null) {
+      options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+    }
+    if (process.env.DOTENV_CONFIG_PATH != null) {
+      options.path = process.env.DOTENV_CONFIG_PATH;
+    }
+    if (process.env.DOTENV_CONFIG_QUIET != null) {
+      options.quiet = process.env.DOTENV_CONFIG_QUIET;
+    }
+    if (process.env.DOTENV_CONFIG_DEBUG != null) {
+      options.debug = process.env.DOTENV_CONFIG_DEBUG;
+    }
+    if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+      options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+    }
+    if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+      options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+    }
+    module.exports = options;
+  }
+});
+
+// ../../../node_modules/dotenv/lib/cli-options.js
+var require_cli_options = __commonJS({
+  "../../../node_modules/dotenv/lib/cli-options.js"(exports, module) {
+    "use strict";
+    var re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+    module.exports = function optionMatcher(args) {
+      const options = args.reduce(function(acc, cur) {
+        const matches = cur.match(re);
+        if (matches) {
+          acc[matches[1]] = matches[2];
+        }
+        return acc;
+      }, {});
+      if (!("quiet" in options)) {
+        options.quiet = "true";
+      }
+      return options;
+    };
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// ../../../node_modules/dotenv/config.js
+(function() {
+  require_main().config(
+    Object.assign(
+      {},
+      require_env_options(),
+      require_cli_options()(process.argv)
+    )
+  );
+})();
+
+// ../infrastructure/src/db/SQLiteStateStore.ts
+import { DatabaseSync } from "sqlite";
+import { join as join2 } from "path";
+import { mkdirSync } from "fs";
+var SQLiteStateStore = class {
+  db;
+  constructor(storageDir = ".metamorph") {
+    try {
+      mkdirSync(storageDir, { recursive: true });
+    } catch (e) {
+    }
+    const dbPath = join2(storageDir, "history.db");
+    this.db = new DatabaseSync(dbPath);
+    this.initTables();
+  }
+  /**
+   * Creates the necessary tables if they do not exist.
+   */
+  initTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS plans (
+        id TEXT PRIMARY KEY,
+        run_id TEXT,
+        target_path TEXT,
+        source_framework TEXT,
+        target_framework TEXT,
+        rules_json TEXT,
+        created_at TEXT
+      );
+    `);
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN run_id TEXT");
+    } catch (e) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN target_path TEXT");
+    } catch (e) {
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        plan_id TEXT,
+        file_path TEXT,
+        status TEXT,
+        dependencies_json TEXT,
+        error TEXT,
+        PRIMARY KEY (plan_id, file_path),
+        FOREIGN KEY (plan_id) REFERENCES plans(id)
+      );
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        event_name TEXT,
+        payload_json TEXT,
+        timestamp TEXT
+      );
+    `);
+  }
+  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)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmtPlan.run(
+      plan.id,
+      plan.runId,
+      plan.targetPath || "",
+      plan.profile.source,
+      plan.profile.target,
+      JSON.stringify(plan.profile.rules || []),
+      plan.createdAt.toISOString()
+    );
+    const stmtTask = this.db.prepare(`
+      INSERT OR REPLACE INTO tasks (plan_id, file_path, status, dependencies_json, error)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    for (const task of plan.tasks) {
+      stmtTask.run(
+        plan.id,
+        task.filePath,
+        task.status,
+        JSON.stringify(task.dependencies || []),
+        task.error || null
+      );
+    }
+  }
+  async getPlan(id) {
+    const stmtPlan = this.db.prepare(`SELECT * FROM plans WHERE id = ?`);
+    const planRow = stmtPlan.get(id);
+    if (!planRow) {
+      return null;
+    }
+    const stmtTasks = this.db.prepare(`SELECT * FROM tasks WHERE plan_id = ?`);
+    const taskRows = stmtTasks.all(id);
+    return {
+      id: planRow.id,
+      runId: planRow.run_id,
+      targetPath: planRow.target_path,
+      profile: {
+        source: planRow.source_framework,
+        target: planRow.target_framework,
+        rules: JSON.parse(planRow.rules_json)
+      },
+      createdAt: new Date(planRow.created_at),
+      tasks: taskRows.map((row) => ({
+        filePath: row.file_path,
+        status: row.status,
+        dependencies: JSON.parse(row.dependencies_json),
+        error: row.error || void 0
+      }))
+    };
+  }
+  async updateTaskStatus(planId, filePath, status, error) {
+    const stmt = this.db.prepare(`
+      INSERT INTO tasks (plan_id, file_path, status, error, dependencies_json)
+      VALUES (?, ?, ?, ?, '[]')
+      ON CONFLICT(plan_id, file_path) DO UPDATE 
+      SET status = excluded.status, error = excluded.error
+    `);
+    stmt.run(planId, filePath, status, error || null);
+  }
+  async logEvent(eventName, payload) {
+    const stmt = this.db.prepare(`
+      INSERT INTO events (event_name, payload_json, timestamp)
+      VALUES (?, ?, ?)
+    `);
+    stmt.run(eventName, JSON.stringify(payload), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async getAllPlans() {
+    const stmtPlans = this.db.prepare(`SELECT * FROM plans ORDER BY created_at DESC`);
+    const planRows = stmtPlans.all();
+    const stmtTasks = this.db.prepare(`SELECT * FROM tasks`);
+    const taskRows = stmtTasks.all();
+    return planRows.map((planRow) => {
+      const planTasks = taskRows.filter((t) => t.plan_id === planRow.id);
+      return {
+        id: planRow.id,
+        runId: planRow.run_id,
+        targetPath: planRow.target_path,
+        profile: {
+          source: planRow.source_framework,
+          target: planRow.target_framework,
+          rules: JSON.parse(planRow.rules_json)
+        },
+        createdAt: new Date(planRow.created_at),
+        tasks: planTasks.map((row) => ({
+          filePath: row.file_path,
+          status: row.status,
+          dependencies: JSON.parse(row.dependencies_json),
+          error: row.error || void 0
+        }))
+      };
+    });
+  }
+  async getEvents() {
+    const stmt = this.db.prepare(`SELECT * FROM events ORDER BY id DESC LIMIT 100`);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      id: row.id,
+      eventName: row.event_name,
+      payload: JSON.parse(row.payload_json),
+      timestamp: new Date(row.timestamp)
+    }));
+  }
+  async reset() {
+    this.db.exec(`DELETE FROM tasks`);
+    this.db.exec(`DELETE FROM plans`);
+    this.db.exec(`DELETE FROM events`);
+  }
+};
+
+// ../infrastructure/src/tools/AstTools.ts
+var import_ts_morph = __toESM(require_ts_morph(), 1);
+import { existsSync } from "fs";
+var project = new import_ts_morph.Project();
+function createReadFileTool() {
+  return {
+    type: "function",
+    name: "read_file",
+    description: "Reads the content of a source file using ts-morph.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "The relative path to the file to read." }
+      },
+      required: ["filePath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath }) => {
+      if (!existsSync(filePath)) {
+        return { error: `File not found: ${filePath}` };
+      }
+      let sourceFile = project.getSourceFile(filePath);
+      if (!sourceFile) {
+        project.addSourceFileAtPath(filePath);
+        sourceFile = project.getSourceFileOrThrow(filePath);
+      } else {
+        await sourceFile.refreshFromFileSystem();
+      }
+      return {
+        filePath,
+        content: sourceFile.getFullText()
+      };
+    }
+  };
+}
+function createWriteFileTool() {
+  return {
+    type: "function",
+    name: "write_file",
+    description: "Overwrites the content of a source file with the provided refactored code using ts-morph.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "The relative path to the file to modify." },
+        newContent: { type: "string", description: "The entire new source code to write to the file." }
+      },
+      required: ["filePath", "newContent"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath, newContent }) => {
+      let sourceFile = project.getSourceFile(filePath);
+      if (!sourceFile) {
+        if (existsSync(filePath)) {
+          project.addSourceFileAtPath(filePath);
+          sourceFile = project.getSourceFileOrThrow(filePath);
+        } else {
+          sourceFile = project.createSourceFile(filePath, "");
+        }
+      }
+      sourceFile.replaceWithText(newContent);
+      await sourceFile.save();
+      return {
+        success: true,
+        message: `File ${filePath} successfully updated.`
+      };
+    }
+  };
+}
+function createRenameFileTool() {
+  return {
+    type: "function",
+    name: "rename_file",
+    description: "Renames a file in the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        oldPath: { type: "string", description: "Current relative path of the file." },
+        newPath: { type: "string", description: "New relative path for the file." }
+      },
+      required: ["oldPath", "newPath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ oldPath, newPath }) => {
+      const { renameSync, existsSync: existsSync5 } = await import("fs");
+      if (!existsSync5(oldPath)) {
+        return { error: `File not found: ${oldPath}` };
+      }
+      renameSync(oldPath, newPath);
+      const sourceFile = project.getSourceFile(oldPath);
+      if (sourceFile) {
+        project.removeSourceFile(sourceFile);
+        if (existsSync5(newPath)) {
+          project.addSourceFileAtPath(newPath);
+        }
+      }
+      return { success: true, message: `File renamed from ${oldPath} to ${newPath}.` };
+    }
+  };
+}
+function createCreateFileTool() {
+  return {
+    type: "function",
+    name: "create_file",
+    description: "Creates a new file with the specified content.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Relative path of the new file to create." },
+        content: { type: "string", description: "The content of the new file." }
+      },
+      required: ["filePath", "content"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath, content }) => {
+      const { writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
+      const { dirname: dirname2 } = await import("path");
+      mkdirSync2(dirname2(filePath), { recursive: true });
+      writeFileSync2(filePath, content, "utf-8");
+      project.addSourceFileAtPath(filePath);
+      return { success: true, message: `File created at ${filePath}.` };
+    }
+  };
+}
+function createDeleteFileTool() {
+  return {
+    type: "function",
+    name: "delete_file",
+    description: "Deletes a file from the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Relative path of the file to delete." }
+      },
+      required: ["filePath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath }) => {
+      const { renameSync, existsSync: existsSync5 } = await import("fs");
+      if (!existsSync5(filePath)) {
+        return { error: `File not found: ${filePath}` };
+      }
+      const obsoletePath = `${filePath}.obsolete`;
+      renameSync(filePath, obsoletePath);
+      const sourceFile = project.getSourceFile(filePath);
+      if (sourceFile) {
+        project.removeSourceFile(sourceFile);
+      }
+      return { success: true, message: `File marked as obsolete at ${obsoletePath} instead of deleting.` };
+    }
+  };
+}
+
+// ../infrastructure/src/workspace/ShadowWorkspace.ts
+import fs from "fs-extra";
+import { join as join3, resolve } from "path";
+var ShadowWorkspace = class {
+  baseDir;
+  constructor(basePath = ".metamorph/shadow") {
+    this.baseDir = resolve(process.cwd(), basePath);
+  }
+  /**
+   * Clones a target directory into the shadow workspace.
+   * @param targetPath The absolute or relative path to the directory to clone.
+   * @param runId A unique identifier for this run (e.g. timestamp).
+   * @returns The absolute path to the cloned directory inside the shadow workspace.
+   */
+  cloneDirectory(targetPath, runId) {
+    const sourceDir = resolve(process.cwd(), targetPath);
+    if (!fs.existsSync(sourceDir)) {
+      throw new Error(`Target directory does not exist: ${sourceDir}`);
+    }
+    const shadowDir = join3(this.baseDir, runId);
+    if (fs.existsSync(shadowDir)) {
+      fs.emptyDirSync(shadowDir);
+    }
+    const ignoredDirs = ["node_modules", ".git", ".metamorph", "dist", "build", "out", "coverage", ".next"];
+    const items = fs.readdirSync(sourceDir);
+    for (const item of items) {
+      if (ignoredDirs.includes(item)) {
+        continue;
+      }
+      const itemSrc = join3(sourceDir, item);
+      const itemDest = join3(shadowDir, item);
+      fs.copySync(itemSrc, itemDest, {
+        filter: (src) => !ignoredDirs.some((dir) => src.includes(`/${dir}/`) || src.endsWith(`/${dir}`) || src.includes(`\\${dir}\\`) || src.endsWith(`\\${dir}`))
+      });
+    }
+    return shadowDir;
+  }
+  /**
+   * Removes the shadow workspace for a given run, effectively
+   * discarding any in-progress migration work.
+   */
+  rollback(runId) {
+    const shadowDir = join3(this.baseDir, runId);
+    if (fs.existsSync(shadowDir)) {
+      fs.removeSync(shadowDir);
+    }
+  }
+  /**
+   * Returns the absolute path of the shadow dir for a given runId.
+   */
+  getShadowPath(runId) {
+    return join3(this.baseDir, runId);
+  }
+  /**
+   * Cleans up old shadow runs to save disk space, keeping only the specified number of most recent runs.
+   * @param keepCount Number of recent runs to keep (default: 3)
+   */
+  cleanupOldRuns(keepCount = 3) {
+    if (!fs.existsSync(this.baseDir)) return;
+    const runs = fs.readdirSync(this.baseDir).filter((f) => f.startsWith("run_") && fs.statSync(join3(this.baseDir, f)).isDirectory());
+    runs.sort();
+    if (runs.length > keepCount) {
+      const toDelete = runs.slice(0, runs.length - keepCount);
+      for (const run of toDelete) {
+        this.rollback(run);
+      }
+    }
+  }
+};
+
+// ../infrastructure/src/workspace/MigrationIntegrator.ts
+import fs2 from "fs-extra";
+import * as path from "path";
+import { execSync } from "child_process";
+var MigrationIntegrator = class {
+  shadowWorkspace;
+  constructor(shadowWorkspace) {
+    this.shadowWorkspace = shadowWorkspace;
+  }
+  /**
+   * Applies the migrated code from the shadow workspace back to the target directory.
+   * Prioritizes Git if available, otherwise falls back to a Zip backup.
+   * 
+   * @param runId The ID of the migration run to apply.
+   * @param targetPath The original target path of the project.
+   */
+  async applyMigration(runId, targetPath) {
+    const shadowDir = this.shadowWorkspace.getShadowPath(runId);
+    if (!fs2.existsSync(shadowDir)) {
+      throw new Error(`Shadow run not found: ${shadowDir}`);
+    }
+    const resolvedTarget = path.resolve(process.cwd(), targetPath);
+    if (this.isGitRepo(resolvedTarget)) {
+      return this.applyWithGit(runId, shadowDir, resolvedTarget);
+    } else {
+      return this.applyWithZipFallback(runId, shadowDir, resolvedTarget);
+    }
+  }
+  isGitRepo(targetPath) {
+    try {
+      execSync("git rev-parse --is-inside-work-tree", { cwd: targetPath, stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async applyWithGit(runId, shadowDir, targetPath) {
+    const branchName = `metamorph/${runId}`;
+    try {
+      execSync(`git checkout -B ${branchName}`, { cwd: targetPath, stdio: "ignore" });
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`Failed to create/reset git branch ${branchName}: ${e.message}`);
+      }
+      throw new Error(`Failed to create/reset git branch ${branchName}: ${String(e)}`);
+    }
+    this.copyShadowToTarget(shadowDir, targetPath);
+    try {
+      execSync(`git add .`, { cwd: targetPath, stdio: "ignore" });
+      execSync(`git commit --allow-empty -m "chore: apply metamorph ai migration (${runId})"`, { cwd: targetPath, stdio: "ignore" });
+    } catch (e) {
+      if (e instanceof Error) {
+        throw new Error(`Failed to commit changes to branch ${branchName}: ${e.message}`);
+      }
+      throw new Error(`Failed to commit changes to branch ${branchName}: ${String(e)}`);
+    }
+    return `Successfully applied migration via Git to branch: ${branchName}`;
+  }
+  async applyWithZipFallback(runId, shadowDir, targetPath) {
+    const backupDir = path.resolve(process.cwd(), `.metamorph/backups/${runId}_backup`);
+    fs2.ensureDirSync(backupDir);
+    fs2.copySync(targetPath, backupDir, {
+      filter: (src) => !src.includes("node_modules") && !src.includes(".git") && !src.includes(".metamorph")
+    });
+    this.copyShadowToTarget(shadowDir, targetPath);
+    return `Successfully applied migration. Git was not detected, so a backup was saved at: ${backupDir}`;
+  }
+  copyShadowToTarget(shadowDir, targetPath) {
+    const ignoredDirs = ["node_modules", ".git", ".metamorph"];
+    if (fs2.existsSync(targetPath)) {
+      const targetItems = fs2.readdirSync(targetPath);
+      for (const item of targetItems) {
+        if (ignoredDirs.includes(item)) continue;
+        fs2.removeSync(path.join(targetPath, item));
+      }
+    }
+    const shadowItems = fs2.readdirSync(shadowDir);
+    for (const item of shadowItems) {
+      if (ignoredDirs.includes(item)) continue;
+      const itemSrc = path.join(shadowDir, item);
+      const itemDest = path.join(targetPath, item);
+      fs2.copySync(itemSrc, itemDest, { overwrite: true });
+    }
+  }
+};
+
+// ../domain/src/entities/catalogs/backendCatalog.ts
+var backendCatalog = [
+  {
+    source: "nestjs",
+    target: "express",
+    description: "Migration from NestJS framework to a plain Express application structure.",
+    filesToDelete: ["nest-cli.json", "tsconfig.build.json"],
+    dependenciesToRemove: ["@nestjs/common", "@nestjs/core", "@nestjs/platform-express", "reflect-metadata", "rxjs"],
+    dependenciesToAdd: { "express": "^4.18.2" },
+    devDependenciesToRemove: ["@nestjs/cli", "@nestjs/schematics", "@nestjs/testing", "@types/express", "@types/supertest", "source-map-support", "supertest"],
+    devDependenciesToAdd: { "@types/express": "^4.17.17" },
+    architecturalRules: [
+      "Remove all NestJS decorators (@Module, @Controller, @Injectable, @Get, @Post, etc.).",
+      'Remove all NestJS core imports (e.g., from "@nestjs/common" or "@nestjs/core").',
+      "Controllers must be converted into Express Router factory functions or classes that return an Express Router.",
+      "Modules must be converted to plain dependency composition functions or startup scripts that wire Routers together.",
+      "Services/Providers must be converted to plain TypeScript classes or functions, with dependencies passed explicitly via constructors (manual dependency injection) since NestJS DI is gone.",
+      "Make sure to export the router or the configured Express application, not a Nest module."
+    ],
+    examples: [
+      {
+        description: "Converting a NestJS Controller to an Express Router",
+        before: `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}`,
+        after: `import { Router } from 'express';
+import { AppService } from './app.service';
+
+export function createAppRouter(appService: AppService): Router {
+  const router = Router();
+
+  router.get('/', (req, res) => {
+    const result = appService.getHello();
+    res.send(result);
+  });
+
+  return router;
+}`
+      }
+    ]
+  },
+  {
+    source: "express",
+    target: "nestjs",
+    description: "Migration from a plain Express application to the NestJS framework.",
+    dependenciesToRemove: ["express"],
+    dependenciesToAdd: {
+      "@nestjs/common": "latest",
+      "@nestjs/core": "latest",
+      "@nestjs/platform-express": "latest",
+      "reflect-metadata": "^0.1.13",
+      "rxjs": "^7.8.1"
+    },
+    devDependenciesToRemove: ["@types/express"],
+    devDependenciesToAdd: {
+      "@nestjs/cli": "latest",
+      "@nestjs/schematics": "latest",
+      "@nestjs/testing": "latest",
+      "@types/supertest": "^2.0.12",
+      "source-map-support": "^0.5.21",
+      "supertest": "^6.3.3"
+    },
+    architecturalRules: [
+      "Express routing logic must be encapsulated in classes decorated with @Controller().",
+      "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
+      "All Controllers and Providers must be registered in a class decorated with @Module().",
+      "Use NestJS decorators for routing (@Get(), @Post(), @Param(), @Body(), etc.) instead of Express route definitions.",
+      "Rely on NestJS dependency injection instead of manual class instantiation or function passing.",
+      "The entry point must use NestFactory.create() to bootstrap the application, replacing app.listen().",
+      "You are authorized to rename, create, or delete files to adhere strictly to the NestJS directory and file structure conventions (e.g., app.module.ts, app.controller.ts, app.service.ts, main.ts)."
+    ],
+    examples: [
+      {
+        description: "Converting an Express Router to a NestJS Controller and Service",
+        before: `import { Router } from 'express';
+import { getHelloLogic } from './logic';
+
+export function createAppRouter(): Router {
+  const router = Router();
+  router.get('/', (req, res) => {
+    res.send(getHelloLogic());
+  });
+  return router;
+}`,
+        after: `import { Controller, Get, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello from logic';
+  }
+}
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}`
+      }
+    ]
+  },
+  {
+    source: "nestjs",
+    target: "fastify",
+    description: "Migration from NestJS framework to a Fastify application structure.",
+    filesToDelete: ["nest-cli.json", "tsconfig.build.json"],
+    dependenciesToRemove: ["@nestjs/common", "@nestjs/core", "@nestjs/platform-express", "reflect-metadata", "rxjs"],
+    dependenciesToAdd: { "fastify": "latest" },
+    devDependenciesToRemove: ["@nestjs/cli", "@nestjs/schematics", "@nestjs/testing", "@types/express", "@types/supertest", "source-map-support", "supertest"],
+    devDependenciesToAdd: { "fastify-plugin": "latest" },
+    architecturalRules: [
+      "Remove all NestJS decorators (@Module, @Controller, @Injectable, @Get, @Post, etc.).",
+      "Remove all NestJS core imports.",
+      "The entry point (main.ts) must initialize a FastifyInstance (fastify()) instead of NestFactory.",
+      "Controllers and routing logic must be converted to Fastify route declarations (fastify.get, fastify.post).",
+      "Ideally, encapsulate routes and modules as Fastify plugins.",
+      "Remove NestJS dependency injection; use standard JavaScript/TypeScript classes or functions passing dependencies directly.",
+      "Ensure standard Fastify schema validation (JSON Schema) is added if types or DTOs are available.",
+      "You are authorized to rename, create, or delete files to adhere to a standard fastify plugin-based directory structure."
+    ],
+    examples: [
+      {
+        description: "Converting a NestJS Controller to a Fastify Plugin",
+        before: `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller('users')
+export class UsersController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getUsers() {
+    return this.appService.getUsers();
+  }
+}`,
+        after: `import { FastifyInstance } from 'fastify';
+import { AppService } from './app.service';
+
+export default async function usersPlugin(fastify: FastifyInstance, options: any) {
+  const appService = new AppService(); // Or inject via options
+
+  fastify.get('/users', async (request, reply) => {
+    return appService.getUsers();
+  });
+}`
+      }
+    ]
+  },
+  {
+    source: "express",
+    target: "fastify",
+    description: "Migration from a plain Express application to Fastify.",
+    dependenciesToRemove: ["express"],
+    dependenciesToAdd: { "fastify": "latest", "fastify-plugin": "latest" },
+    devDependenciesToRemove: ["@types/express"],
+    devDependenciesToAdd: {},
+    architecturalRules: [
+      "Replace all Express app instantiations with fastify().",
+      "Replace Express middleware signatures (req, res, next) with Fastify hooks (onRequest, preHandler, etc.) or Fastify plugins.",
+      "Replace Express routing (app.use(), app.get()) with Fastify routing (fastify.get(), fastify.register()).",
+      "Replace Express response methods (res.send(), res.json()) with Fastify reply methods (reply.send()) or simply return the payload from the async handler.",
+      "Migrate standard Express middlewares (like cors, helmet) to their Fastify native equivalents (@fastify/cors, @fastify/helmet) if they are present.",
+      "You are authorized to rename, create, or delete files to restructure the Express app into modular Fastify plugins."
+    ],
+    examples: [
+      {
+        description: "Converting an Express Route to a Fastify Route",
+        before: `const express = require('express');
+const app = express();
+
+app.get('/api/data', (req, res) => {
+  res.json({ message: 'Hello Express' });
+});
+
+app.listen(3000);`,
+        after: `import Fastify from 'fastify';
+
+const fastify = Fastify({ logger: true });
+
+fastify.get('/api/data', async (request, reply) => {
+  return { message: 'Hello Fastify' };
+});
+
+fastify.listen({ port: 3000 }, (err) => {
+  if (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+});`
+      }
+    ]
+  },
+  {
+    source: "fastify",
+    target: "express",
+    description: "Migration from a Fastify application to Express.",
+    dependenciesToRemove: ["fastify", "fastify-plugin"],
+    dependenciesToAdd: { "express": "latest" },
+    devDependenciesToRemove: [],
+    devDependenciesToAdd: { "@types/express": "latest" },
+    architecturalRules: [
+      "Replace all fastify() app instantiations with express().",
+      "Replace Fastify hooks (onRequest, preHandler, etc.) with standard Express middleware signatures (req, res, next).",
+      "Replace Fastify routing (fastify.get, fastify.register) with Express routing (app.get, express.Router().use).",
+      "Replace Fastify reply methods (reply.send) or implicit returns with Express response methods (res.send, res.json).",
+      "CRITICAL: Fastify catches async errors automatically. When migrating to Express, ensure all asynchronous route handlers use try/catch blocks passing the error to next(err), or wrap them in an async wrapper.",
+      "You are authorized to rename, create, or delete files to restructure the Fastify plugins into standard Express routers."
+    ],
+    examples: [
+      {
+        description: "Converting a Fastify Route to an Express Route",
+        before: `import Fastify from 'fastify';
+
+const fastify = Fastify();
+
+fastify.get('/api/data', async (request, reply) => {
+  return { message: 'Hello Fastify' };
+});
+
+fastify.listen({ port: 3000 });`,
+        after: `const express = require('express');
+const app = express();
+
+app.get('/api/data', async (req, res, next) => {
+  try {
+    res.json({ message: 'Hello Fastify' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+app.listen(3000);`
+      }
+    ]
+  },
+  {
+    source: "fastify",
+    target: "nestjs",
+    description: "Migration from Fastify framework to NestJS (using platform-express by default).",
+    dependenciesToRemove: ["fastify", "fastify-plugin"],
+    dependenciesToAdd: {
+      "@nestjs/common": "latest",
+      "@nestjs/core": "latest",
+      "@nestjs/platform-express": "latest",
+      "reflect-metadata": "^0.1.13",
+      "rxjs": "^7.8.1"
+    },
+    devDependenciesToRemove: [],
+    devDependenciesToAdd: {
+      "@nestjs/cli": "latest",
+      "@nestjs/schematics": "latest",
+      "@nestjs/testing": "latest",
+      "@types/supertest": "^2.0.12",
+      "source-map-support": "^0.5.21",
+      "supertest": "^6.3.3"
+    },
+    architecturalRules: [
+      "Fastify routing logic must be encapsulated in classes decorated with @Controller().",
+      "Business logic must be encapsulated in classes decorated with @Injectable() (Providers/Services).",
+      "All Controllers and Providers must be registered in a class decorated with @Module().",
+      "Use NestJS decorators for routing (@Get(), @Post(), @Param(), @Body(), etc.) instead of fastify route definitions.",
+      "Rely on NestJS dependency injection instead of Fastify decorators or options passing.",
+      "The entry point must use NestFactory.create() to bootstrap the application, replacing fastify().",
+      "You are authorized to rename, create, or delete files to adhere strictly to the NestJS directory and file structure conventions (e.g., app.module.ts, app.controller.ts, app.service.ts, main.ts)."
+    ],
+    examples: [
+      {
+        description: "Converting a Fastify Plugin to a NestJS Controller and Service",
+        before: `export default async function usersPlugin(fastify, options) {
+  fastify.get('/users', async (request, reply) => {
+    return { users: [] };
+  });
+}`,
+        after: `import { Controller, Get, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class UsersService {
+  getUsers() {
+    return { users: [] };
+  }
+}
+
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  @Get()
+  getUsers() {
+    return this.usersService.getUsers();
+  }
+}`
+      }
+    ]
+  }
+];
+
+// ../domain/src/entities/catalogs/frontendCatalog.ts
+var frontendCatalog = [
+  {
+    source: "react",
+    target: "next",
+    description: "Migration from a plain React SPA (like Vite or Create React App) to Next.js using the App Router.",
+    filesToDelete: ["vite.config.ts", "vite.config.js", "index.html"],
+    dependenciesToRemove: ["react-router-dom", "vite", "@vitejs/plugin-react"],
+    dependenciesToAdd: { "next": "latest", "react": "latest", "react-dom": "latest" },
+    devDependenciesToRemove: [],
+    devDependenciesToAdd: {},
+    architecturalRules: [
+      'Migrate standard React routing (e.g. react-router-dom) to Next.js file-system routing in the "app" directory.',
+      "Convert the main entry point (usually main.tsx or index.tsx) into Next.js app/layout.tsx and app/page.tsx.",
+      'For components that use browser-only APIs (like window, useEffect, useState), add the "use client" directive at the very top of the file.',
+      "Remove any react-router-dom <BrowserRouter>, <Routes>, and <Route> components.",
+      "Replace react-router-dom <Link> components with Next.js next/link <Link> components.",
+      "You are authorized to rename, create, or delete files to restructure the source into the Next.js App Router structure (e.g. app/page.tsx, app/layout.tsx)."
+    ],
+    examples: [
+      {
+        description: "Converting a React Router setup to Next.js App Router",
+        before: `import { BrowserRouter, Routes, Route } from 'react-router-dom';
+import Home from './Home';
+import About from './About';
+
+export default function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/about" element={<About />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}`,
+        after: `// This routing logic is deleted.
+// Instead, create app/page.tsx for Home and app/about/page.tsx for About.`
+      }
+    ]
+  },
+  {
+    source: "next",
+    target: "react",
+    description: "Migration from Next.js to a plain React SPA using Vite.",
+    filesToDelete: ["next.config.js", "next.config.mjs", "next.config.ts"],
+    dependenciesToRemove: ["next"],
+    dependenciesToAdd: { "react-router-dom": "latest" },
+    devDependenciesToRemove: [],
+    devDependenciesToAdd: { "vite": "latest", "@vitejs/plugin-react": "latest" },
+    architecturalRules: [
+      "Replace Next.js file-system routing (app/ or pages/) with declarative React Router (react-router-dom) components.",
+      'Remove all "use client" and "use server" directives, as they are Next.js specific.',
+      "Convert Next.js Server Components into standard React Client Components (they will need to fetch data via useEffect or a data-fetching library).",
+      'Replace Next.js <Link href="..."> with React Router <Link to="...">.',
+      "Replace Next.js next/image <Image> with standard HTML <img>.",
+      "Create a standard Vite entry point (index.html at the root, and src/main.tsx) to bootstrap the React application."
+    ]
+  },
+  {
+    source: "vue",
+    target: "react",
+    description: "Migration from Vue.js (Vue 3 Composition API) to React.",
+    filesToDelete: ["vite.config.ts", "vue.config.js"],
+    dependenciesToRemove: ["vue", "vue-router", "pinia"],
+    dependenciesToAdd: { "react": "latest", "react-dom": "latest", "react-router-dom": "latest" },
+    devDependenciesToRemove: ["@vitejs/plugin-vue"],
+    devDependenciesToAdd: { "@vitejs/plugin-react": "latest" },
+    architecturalRules: [
+      "Convert all .vue Single File Components (SFC) into .tsx or .jsx React function components.",
+      "Replace Vue <template> with React JSX/TSX return statements.",
+      "Replace Vue ref() and reactive() with React useState().",
+      "Replace Vue computed() with React useMemo().",
+      "Replace Vue watch() and lifecycle hooks (onMounted, etc.) with React useEffect().",
+      "Replace vue-router with react-router-dom.",
+      "Convert Vue props definition (defineProps) into React function component parameters.",
+      "Convert Vue emit (defineEmits) into React callback props (e.g. onAction={...})."
+    ]
+  },
+  {
+    source: "react",
+    target: "vue",
+    description: "Migration from React to Vue.js (Vue 3 Composition API).",
+    filesToDelete: ["vite.config.ts"],
+    dependenciesToRemove: ["react", "react-dom", "react-router-dom"],
+    dependenciesToAdd: { "vue": "latest", "vue-router": "latest" },
+    devDependenciesToRemove: ["@vitejs/plugin-react"],
+    devDependenciesToAdd: { "@vitejs/plugin-vue": "latest" },
+    architecturalRules: [
+      "Convert React .tsx/.jsx function components into Vue 3 .vue Single File Components (using <script setup>).",
+      "Move the JSX return statement into the Vue <template> block.",
+      "Replace React useState() with Vue ref() or reactive().",
+      "Replace React useMemo() with Vue computed().",
+      "Replace React useEffect() with Vue watch() or lifecycle hooks (onMounted).",
+      "Replace react-router-dom with vue-router.",
+      "Extract component props into defineProps().",
+      "Extract callback props (e.g. onClick) into defineEmits() and emit events."
+    ]
+  }
+];
+
+// ../domain/src/entities/catalogs/index.ts
+var MigrationCatalog = [
+  ...backendCatalog,
+  ...frontendCatalog
+];
+function findMigrationCatalogEntry(source, target) {
+  return MigrationCatalog.find(
+    (entry) => entry.source.toLowerCase() === source.toLowerCase() && entry.target.toLowerCase() === target.toLowerCase()
+  );
+}
+
+// ../infrastructure/src/server/api.ts
+async function createApiServer(store, migrationRunner) {
+  const express = (await import("express")).default;
+  const cors = (await import("cors")).default;
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.get("/api/plans", async (_req, res) => {
+    try {
+      const plans = await store.getAllPlans();
+      res.json(plans);
+    } catch (error) {
+      if (error instanceof Error) {
+        res.status(500).json({ error: error.message });
+      } else {
+        res.status(500).json({ error: String(error) });
+      }
+    }
+  });
+  app.get("/api/events", async (_req, res) => {
+    try {
+      const events = await store.getEvents();
+      res.json(events);
+    } 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: readdirSync2, statSync: statSync2 } = await import("fs");
+      const { resolve: resolve3, join: join8 } = await import("path");
+      const targetPath = req.query.path ? resolve3(String(req.query.path)) : resolve3(".");
+      const entries = readdirSync2(targetPath).filter(
+        (name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist" && name !== "build"
+      ).map((name) => {
+        const full = join8(targetPath, name);
+        try {
+          const stat = statSync2(full);
+          return {
+            name,
+            path: full,
+            isDirectory: stat.isDirectory()
+          };
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      res.json({
+        current: targetPath,
+        parent: resolve3(targetPath, ".."),
+        entries
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        res.status(500).json({ error: error.message });
+      } else {
+        res.status(500).json({ error: String(error) });
+      }
+    }
+  });
+  app.get("/api/detect", async (req, res) => {
+    try {
+      const { detectTechnologies: detectTechnologies2 } = await import("./TechDetector-YCDEZ6OR.js");
+      const targetPath = req.query.path ? String(req.query.path) : ".";
+      const detected = detectTechnologies2(targetPath);
+      res.json({
+        detected,
+        primary: detected.length > 0 ? detected[0].framework : null
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        res.status(500).json({ error: error.message });
+      } else {
+        res.status(500).json({ error: String(error) });
+      }
+    }
+  });
+  if (migrationRunner) {
+    app.post("/api/migrations/start", async (req, res) => {
+      try {
+        const { targetPath, from, to } = req.body;
+        if (!targetPath || !from || !to) {
+          res.status(400).json({
+            error: "Missing required fields: targetPath, from, to"
+          });
+          return;
+        }
+        const catalogEntry = findMigrationCatalogEntry(from, to);
+        if (!catalogEntry) {
+          res.status(400).json({
+            error: `Unsupported migration profile: ${from} -> ${to}. Please check the supported catalog.`
+          });
+          return;
+        }
+        const result = await migrationRunner.startMigration({
+          targetPath,
+          from,
+          to
+        });
+        res.json({ ok: true, ...result });
+      } catch (error) {
+        if (error instanceof Error) {
+          res.status(500).json({ error: error.message });
+        } else {
+          res.status(500).json({ error: String(error) });
+        }
+      }
+    });
+    app.post("/api/migrations/apply", async (req, res) => {
+      try {
+        const { runId, targetPath } = req.body;
+        if (!runId || !targetPath) {
+          res.status(400).json({
+            error: "Missing required fields: runId, targetPath"
+          });
+          return;
+        }
+        const integrator = new MigrationIntegrator(migrationRunner.workspace);
+        const message = await integrator.applyMigration(runId, targetPath);
+        res.json({ ok: true, message });
+      } catch (error) {
+        if (error instanceof Error) {
+          res.status(500).json({ error: error.message });
+        } else {
+          res.status(500).json({ error: String(error) });
+        }
+      }
+    });
+    app.post("/api/migrations/rollback", async (req, res) => {
+      try {
+        const { runId } = req.body;
+        if (!runId) {
+          res.status(400).json({
+            error: "Missing required field: runId"
+          });
+          return;
+        }
+        await migrationRunner.rollbackMigration(runId);
+        res.json({ ok: true, message: `Rolled back run: ${runId}` });
+      } catch (error) {
+        if (error instanceof Error) {
+          res.status(500).json({ error: error.message });
+        } else {
+          res.status(500).json({ error: String(error) });
+        }
+      }
+    });
+    app.post("/api/migrations/reset", async (_req, res) => {
+      try {
+        await store.reset();
+        res.json({ ok: true, message: "Migration state reset successfully" });
+      } catch (error) {
+        if (error instanceof Error) {
+          res.status(500).json({ error: error.message });
+        } else {
+          res.status(500).json({ error: String(error) });
+        }
+      }
+    });
+  }
+  const path6 = await import("path");
+  const fs7 = await import("fs");
+  const publicDir = path6.join(__dirname, "../public");
+  if (fs7.existsSync(publicDir)) {
+    app.use(express.static(publicDir));
+    app.get("*", (_req, res) => {
+      res.sendFile(path6.join(publicDir, "index.html"));
+    });
+  }
+  return app;
+}
+
+// ../application/src/agents/MapperAgent.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+var WhenMigrationStarts = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
+  }
+};
+var mapFilesProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[MapperAgent] Migration started for Plan: ${payload.planId}`);
+    const shadowDir = payload.shadowWorkspacePath || "";
+    if (!shadowDir) {
+      console.warn("[MapperAgent] No shadow workspace provided. Skipping.");
+      return;
+    }
+    const filesToMigrate = [];
+    const scanDir = (dir) => {
+      if (!fs3.existsSync(dir)) return;
+      const files = fs3.readdirSync(dir);
+      const ignoredDirs = ["node_modules", "dist", "build", "out", "coverage", ".next"];
+      for (const file of files) {
+        if (ignoredDirs.includes(file) || file.startsWith(".")) continue;
+        const fullPath = path2.join(dir, file);
+        if (fs3.statSync(fullPath).isDirectory()) {
+          scanDir(fullPath);
+        } else if (file.endsWith(".ts") || file.endsWith(".js")) {
+          filesToMigrate.push(fullPath);
+        }
+      }
+    };
+    scanDir(shadowDir);
+    const runtime = resolveRuntime();
+    const repository = runtime.state.repository;
+    for (const discoveredFile of filesToMigrate) {
+      console.log(`[MapperAgent] Discovered file: ${discoveredFile}`);
+      await repository.updateTaskStatus(payload.planId, discoveredFile, "pending");
+      sendEvent(
+        {
+          type: "file.discovered" /* FILE_DISCOVERED */,
+          producerId: participant.getId(),
+          occurredAt: /* @__PURE__ */ new Date(),
+          payload: {
+            planId: payload.planId,
+            filePath: discoveredFile
+          }
+        },
+        participant.getId()
+      );
+    }
+  }
+};
+var mapFilesHandler = {
+  specification: new WhenMigrationStarts(),
+  processor: mapFilesProcessor
+};
+function createMapperAgent() {
+  return createAgent({
+    name: "Mapper",
+    capabilities: ["code_analysis"],
+    instruction: "You are the Architect Mapper. Your job is to analyze the source code and discover files that need migration.",
+    tools: [],
+    // AST scanning tools will go here later
+    handlers: [mapFilesHandler]
+  });
+}
+
+// ../application/src/agents/WorkerAgent.ts
+import * as fs4 from "fs";
+
+// ../application/src/utils/FileTreeBuilder.ts
+import * as path3 from "path";
+function getCommonBaseDir(filePaths) {
+  if (!filePaths || filePaths.length === 0) return "";
+  if (filePaths.length === 1) return path3.dirname(filePaths[0]);
+  const splitPaths = filePaths.map((p) => path3.normalize(p).split(path3.sep));
+  let commonPath = "";
+  for (let i = 0; i < splitPaths[0].length; i++) {
+    const part = splitPaths[0][i];
+    const isCommon = splitPaths.every((parts) => parts[i] === part);
+    if (isCommon) {
+      commonPath = commonPath === "" ? part : commonPath + path3.sep + part;
+    } else {
+      break;
+    }
+  }
+  return commonPath;
+}
+function buildFileTree(filePaths) {
+  if (!filePaths || filePaths.length === 0) return "No files found.";
+  const baseDir = getCommonBaseDir(filePaths);
+  const relativePaths = filePaths.map((p) => path3.relative(baseDir, p)).filter((p) => p.length > 0).sort();
+  if (relativePaths.length === 0) return "No files found.";
+  const tree = {};
+  for (const relPath of relativePaths) {
+    const parts = relPath.split(path3.sep);
+    let current = tree;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (i === parts.length - 1) {
+        current[part] = null;
+      } else {
+        current[part] = current[part] || {};
+        current = current[part];
+      }
+    }
+  }
+  let output = `/
+`;
+  function renderTree(node, prefix = "") {
+    if (node === null) return;
+    const keys = Object.keys(node);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const isLast = i === keys.length - 1;
+      const isFile = node[key] === null;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      output += `${prefix}${connector}${key}
+`;
+      if (!isFile) {
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        renderTree(node[key], nextPrefix);
+      }
+    }
+  }
+  renderTree(tree);
+  return output.trim();
+}
+
+// ../application/src/agents/WorkerAgent.ts
+var retryCountMap = /* @__PURE__ */ new Map();
+var MAX_RETRIES = 2;
+var ConcurrencyQueue = class {
+  constructor(concurrencyLimit) {
+    this.concurrencyLimit = concurrencyLimit;
+  }
+  queue = [];
+  activeCount = 0;
+  async enqueue(task) {
+    this.queue.push(task);
+    this.pump();
+  }
+  async pump() {
+    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
+      return;
+    }
+    const task = this.queue.shift();
+    if (task) {
+      this.activeCount++;
+      try {
+        await task();
+      } catch (error) {
+        console.error("Task error:", error);
+      } finally {
+        this.activeCount--;
+        this.pump();
+      }
+    }
+  }
+};
+var workerQueue = new ConcurrencyQueue(2);
+var WhenFileDiscovered = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.discovered" /* FILE_DISCOVERED */;
+  }
+};
+var WhenFileRejected = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.rejected" /* FILE_REJECTED */;
+  }
+};
+var WhenFileFatalMismatch = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */;
+  }
+};
+var WhenInferenceCompleted = class extends SituationSpecification {
+  isSatisfiedBy({ event, participant }) {
+    return event.type === "model.answer" && event.producerId === participant.getId();
+  }
+};
+async function startWorkerLoop(planId, filePath, prompt, participant) {
+  return new Promise(async (originalResolve) => {
+    let isDone = false;
+    const resolve3 = () => {
+      if (!isDone) {
+        isDone = true;
+        originalResolve();
+      }
+    };
+    const runtime = resolveRuntime();
+    const repository = runtime.state.repository;
+    console.log(`[WorkerAgent] Marking file as 'in_progress' in database...`);
+    await repository.updateTaskStatus(planId, filePath, "in_progress");
+    const { createAgent: createMozaikAgent } = await import("./dist-63RNBEIQ.js");
+    const tempAgent = createMozaikAgent({
+      name: `Worker-${Date.now()}-${Math.floor(Math.random() * 1e3)}`,
+      capabilities: ["code_refactoring", "inference"],
+      instruction: "You are the Programmer Worker. Your job is to refactor specific files based on the migration profile. If the target framework requires a different file structure, you are authorized to use your tools to rename, create, or delete files to adhere to architectural rules. When you are done modifying the file(s), simply finish your response.",
+      tools: participant.getTools(),
+      handlers: [
+        {
+          specification: new WhenInferenceCompleted(),
+          processor: {
+            async apply({ event: completionEvent, participant: tempParticipant }) {
+              console.log(`[WorkerAgent:${tempParticipant.getId()}] Inference completed. Emitting FILE_MIGRATED.`);
+              let fileContent = "No content available";
+              try {
+                if (fs4.existsSync(filePath)) {
+                  fileContent = fs4.readFileSync(filePath, "utf-8");
+                  console.log(`[WorkerAgent:${tempParticipant.getId()}] Read ${fileContent.length} chars from ${filePath}`);
+                } else {
+                  console.warn(`[WorkerAgent:${tempParticipant.getId()}] File not found on disk: ${filePath}`);
+                }
+              } catch (e) {
+                console.error(`[WorkerAgent:${tempParticipant.getId()}] Error reading file:`, e);
+              }
+              await repository.updateTaskStatus(planId, filePath, "completed");
+              sendEvent(
+                {
+                  type: "file.migrated" /* FILE_MIGRATED */,
+                  producerId: tempParticipant.getId(),
+                  occurredAt: /* @__PURE__ */ new Date(),
+                  payload: {
+                    planId,
+                    filePath,
+                    diff: fileContent
+                  }
+                },
+                tempParticipant.getId()
+              );
+              leave(tempParticipant);
+              resolve3();
+            }
+          }
+        }
+      ]
+    });
+    join(tempAgent);
+    const modelToUse = process.env.METAMORPH_MODEL || "gpt-5.4";
+    try {
+      console.log(`[WorkerAgent:${tempAgent.getId()}] Starting inference loop for ${filePath}...`);
+      runLoop(tempAgent.getId(), prompt, {
+        model: modelToUse,
+        context: tempAgent.getMemory().getContext(),
+        tools: tempAgent.getTools()
+      });
+      setTimeout(async () => {
+        if (!isDone) {
+          console.error(`[WorkerAgent:${tempAgent.getId()}] Inference timed out.`);
+          await repository.updateTaskStatus(planId, filePath, "failed", "Inference timed out");
+          leave(tempAgent);
+          resolve3();
+        }
+      }, 45e3);
+    } catch (error) {
+      console.error(`[WorkerAgent:${tempAgent.getId()}] Sync error:`, error);
+      if (!isDone) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await repository.updateTaskStatus(planId, filePath, "failed", errorMessage || "Sync error");
+        leave(tempAgent);
+        resolve3();
+      }
+    }
+  });
+}
+var workOnFileProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[WorkerAgent] Received file to migrate: ${payload.filePath}`);
+    const runtime = resolveRuntime();
+    const plan = await runtime.state.repository.getPlan(payload.planId);
+    let prompt = `You need to migrate the file at path: ${payload.filePath}
+`;
+    if (plan) {
+      prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
+`;
+      const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+      if (catalogEntry) {
+        prompt += `
+Strict Architectural Rules for this Migration:
+`;
+        catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
+`);
+        if (catalogEntry.examples && catalogEntry.examples.length > 0) {
+          prompt += `
+Reference Examples:
+`;
+          catalogEntry.examples.forEach((ex) => {
+            prompt += `Example (${ex.description}):
+Before:
+\`\`\`
+${ex.before}
+\`\`\`
+After:
+\`\`\`
+${ex.after}
+\`\`\`
+
+`;
+          });
+        }
+      }
+      if (plan.profile.rules) {
+        prompt += `Specific User Rules: ${plan.profile.rules.join(", ")}
+`;
+      }
+      if (plan.tasks && plan.tasks.length > 0) {
+        const allFiles = plan.tasks.map((t) => t.filePath);
+        const projectTree = buildFileTree(allFiles);
+        prompt += `
+Global Project Architecture (Files being migrated):
+`;
+        prompt += `\`\`\`text
+${projectTree}
+\`\`\`
+`;
+        prompt += `Use this context to ensure your changes align with the overall project structure and other files.
+`;
+      }
+    }
+    prompt += `Please read the file using your tools, rewrite it according to the rules, and write it back. If the rules require breaking this file into multiple files, use your create, rename, or delete file tools accordingly.`;
+    workerQueue.enqueue(async () => {
+      await startWorkerLoop(payload.planId, payload.filePath, prompt, participant);
+    });
+  }
+};
+var fixRejectedFileProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    const retryKey = `${payload.planId}:${payload.filePath}`;
+    const currentRetries = retryCountMap.get(retryKey) || 0;
+    if (currentRetries >= MAX_RETRIES) {
+      console.warn(`[WorkerAgent] File ${payload.filePath} exceeded max retries (${MAX_RETRIES}). Marking as failed.`);
+      const runtime2 = resolveRuntime();
+      await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", `Exceeded max retries (${MAX_RETRIES})`);
+      retryCountMap.delete(retryKey);
+      return;
+    }
+    retryCountMap.set(retryKey, currentRetries + 1);
+    console.log(`[WorkerAgent] File REJECTED (attempt ${currentRetries + 1}/${MAX_RETRIES}), initiating repair loop: ${payload.filePath}`);
+    const runtime = resolveRuntime();
+    const plan = await runtime.state.repository.getPlan(payload.planId);
+    let prompt = `You need to FIX the file at path: ${payload.filePath}
+`;
+    prompt += `Your previous migration was REJECTED by the Quality Assurance Reviewer.
+`;
+    prompt += `Feedback/Errors:
+${payload.errors.join("\n")}
+
+`;
+    if (plan) {
+      prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
+`;
+      const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+      if (catalogEntry) {
+        prompt += `
+Strict Architectural Rules for this Migration:
+`;
+        catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
+`);
+      }
+      if (plan.tasks && plan.tasks.length > 0) {
+        const allFiles = plan.tasks.map((t) => t.filePath);
+        const projectTree = buildFileTree(allFiles);
+        prompt += `
+Global Project Architecture (Files being migrated):
+`;
+        prompt += `\`\`\`text
+${projectTree}
+\`\`\`
+`;
+        prompt += `Ensure you respect this overall project structure while fixing the issues.
+`;
+      }
+    }
+    prompt += `Please read the file, fix the issues mentioned, and write it back. You may restructure the files if the architectural rules demand it.`;
+    workerQueue.enqueue(async () => {
+      await startWorkerLoop(payload.planId, payload.filePath, prompt, participant);
+    });
+  }
+};
+var fatalMismatchProcessor = {
+  async apply({ event }) {
+    const payload = event.payload;
+    console.error(`[WorkerAgent] \u{1F6D1} FATAL MISMATCH received for ${payload.filePath}. Reason: ${payload.reason}`);
+    const retryKey = `${payload.planId}:${payload.filePath}`;
+    retryCountMap.delete(retryKey);
+    const runtime = resolveRuntime();
+    await runtime.state.repository.updateTaskStatus(
+      payload.planId,
+      payload.filePath,
+      "failed",
+      `Fatal Architectural Mismatch: ${payload.reason}`
+    );
+  }
+};
+function createWorkerAgent(tools) {
+  return createAgent({
+    name: "Worker",
+    capabilities: ["code_refactoring", "inference"],
+    instruction: "You are the Programmer Worker. You migrate code and adapt file structures.",
+    tools,
+    handlers: [
+      { specification: new WhenFileDiscovered(), processor: workOnFileProcessor },
+      { specification: new WhenFileRejected(), processor: fixRejectedFileProcessor },
+      { specification: new WhenFileFatalMismatch(), processor: fatalMismatchProcessor }
+    ]
+  });
+}
+
+// ../application/src/agents/ReviewerAgent.ts
+var ConcurrencyQueue2 = class {
+  constructor(concurrencyLimit) {
+    this.concurrencyLimit = concurrencyLimit;
+  }
+  queue = [];
+  activeCount = 0;
+  async enqueue(task) {
+    this.queue.push(task);
+    this.pump();
+  }
+  async pump() {
+    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
+      return;
+    }
+    const task = this.queue.shift();
+    if (task) {
+      this.activeCount++;
+      try {
+        await task();
+      } catch (error) {
+        console.error("Task error:", error);
+      } finally {
+        this.activeCount--;
+        this.pump();
+      }
+    }
+  }
+};
+var reviewerQueue = new ConcurrencyQueue2(2);
+var WhenFileMigrated = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.migrated" /* FILE_MIGRATED */;
+  }
+};
+var WhenReviewCompleted = class extends SituationSpecification {
+  isSatisfiedBy({ event, participant }) {
+    console.log(`[DEBUG:WhenReviewCompleted] Event received -> type: "${event.type}", producerId: "${event.producerId}", participantId: "${participant.getId()}", match: ${event.type === "model.answer" && event.producerId === participant.getId()}`);
+    return event.type === "model.answer" && event.producerId === participant.getId();
+  }
+};
+var WhenAnythingHappens = class extends SituationSpecification {
+  isSatisfiedBy() {
+    return true;
+  }
+};
+var reviewFileProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[ReviewerAgent] Reviewing migrated file: ${payload.filePath}`);
+    reviewerQueue.enqueue(async () => {
+      return new Promise(async (originalResolve) => {
+        let isDone = false;
+        const resolve3 = () => {
+          if (!isDone) {
+            isDone = true;
+            console.log(`[DEBUG:ReviewerAgent] Promise resolved for ${payload.filePath}`);
+            originalResolve();
+          }
+        };
+        const { createAgent: createMozaikAgent } = await import("./dist-63RNBEIQ.js");
+        const { sendEvent: sendEvent3 } = await import("./runtime-WTVS3IND.js");
+        const reviewerId = `Reviewer-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
+        const tempAgent = createMozaikAgent({
+          name: reviewerId,
+          capabilities: ["code_review", "inference"],
+          instruction: "You are the Quality Assurance Reviewer. You must review the migrated code. Note that you are reviewing a SINGLE FILE within a larger migration. Evaluate if the file violates architectural rules, but DO NOT reject it simply because it does not demonstrate all architectural features (e.g. do not reject a test file or a bootstrap file just because it lacks a Controller). If the worker completely violated the architectural paradigm in a way that cannot be fixed by a simple code edit, use status FATAL_MISMATCH to abort.",
+          tools: [],
+          // No tools to avoid Gemini thought_signature crash
+          handlers: [
+            // DEBUG: Catch-all handler to log every event this agent receives
+            {
+              specification: new WhenAnythingHappens(),
+              processor: {
+                async apply({ event: anyEvent, participant: anyParticipant }) {
+                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}:CATCH_ALL] Event -> type: "${anyEvent.type}", producerId: "${anyEvent.producerId}", myId: "${anyParticipant.getId()}", payload keys: ${Object.keys(anyEvent.payload || {}).join(",")}`);
+                }
+              }
+            },
+            {
+              specification: new WhenReviewCompleted(),
+              processor: {
+                async apply({ event: event2, participant: tempParticipant }) {
+                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}] model.answer RECEIVED!`);
+                  const answerItem = event2.payload.answer;
+                  const answerText = answerItem?.content?.text || answerItem?.text || null;
+                  console.log(`[DEBUG:ReviewerAgent:${reviewerId}] answerText:`, answerText);
+                  let reviewResult = null;
+                  if (answerText) {
+                    try {
+                      reviewResult = JSON.parse(answerText);
+                      console.log(`[DEBUG:ReviewerAgent:${reviewerId}] Parsed result:`, JSON.stringify(reviewResult));
+                    } catch (e) {
+                      console.error(`[ReviewerAgent:${reviewerId}] Failed to parse JSON:`, e);
+                    }
+                  } else {
+                    console.warn(`[DEBUG:ReviewerAgent:${reviewerId}] answerItem has no extractable text.`);
+                  }
+                  if (reviewResult) {
+                    const participantId = tempParticipant.getId();
+                    try {
+                      if (reviewResult.status === "APPROVED") {
+                        console.log(`[ReviewerAgent:${reviewerId}] File ${payload.filePath} APPROVED!`);
+                        sendEvent3({
+                          type: "file.reviewed" /* FILE_REVIEWED */,
+                          producerId: participantId,
+                          occurredAt: /* @__PURE__ */ new Date(),
+                          payload: { planId: payload.planId, filePath: payload.filePath }
+                        }, participantId);
+                      } else if (reviewResult.status === "FATAL_MISMATCH") {
+                        console.error(`[ReviewerAgent:${reviewerId}] File ${payload.filePath} FATAL_MISMATCH! Aborting repair. Errors:`, reviewResult.errors);
+                        sendEvent3({
+                          type: "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */,
+                          producerId: participantId,
+                          occurredAt: /* @__PURE__ */ new Date(),
+                          payload: { planId: payload.planId, filePath: payload.filePath, reason: reviewResult.errors?.join(" | ") || "Fundamental architectural mismatch" }
+                        }, participantId);
+                      } else {
+                        console.log(`[ReviewerAgent:${reviewerId}] File ${payload.filePath} REJECTED. Errors:`, reviewResult.errors);
+                        sendEvent3({
+                          type: "file.rejected" /* FILE_REJECTED */,
+                          producerId: participantId,
+                          occurredAt: /* @__PURE__ */ new Date(),
+                          payload: { planId: payload.planId, filePath: payload.filePath, errors: reviewResult.errors || ["Migration rejected by reviewer"] }
+                        }, participantId);
+                      }
+                    } catch (e) {
+                      console.error(`[ReviewerAgent:${reviewerId}] Failed to send review event:`, e);
+                    }
+                    try {
+                      const runtime2 = await resolveRuntime();
+                      const plan2 = await runtime2.state.repository.getPlan(payload.planId);
+                      if (plan2) {
+                        const allTerminal = plan2.tasks.every((t) => t.status === "completed" || t.status === "failed");
+                        if (allTerminal) {
+                          console.log(`[App] All tasks reached terminal state. Emitting MIGRATION_COMPLETED.`);
+                          sendEvent3({
+                            type: "migration.completed" /* MIGRATION_COMPLETED */,
+                            producerId: participantId,
+                            occurredAt: /* @__PURE__ */ new Date(),
+                            payload: { planId: payload.planId }
+                          }, participantId);
+                        }
+                      }
+                    } catch (e) {
+                      console.error(`[ReviewerAgent:${reviewerId}] Failed to check migration completion:`, e);
+                    }
+                  }
+                  leave(tempParticipant);
+                  resolve3();
+                }
+              }
+            }
+          ]
+        });
+        console.log(`[DEBUG:ReviewerAgent:${reviewerId}] tempAgent created with id: ${tempAgent.getId()}`);
+        join(tempAgent);
+        console.log(`[DEBUG:ReviewerAgent:${reviewerId}] tempAgent joined the runtime`);
+        const runtime = resolveRuntime();
+        if (payload.filePath.endsWith(".ts") || payload.filePath.endsWith(".tsx")) {
+          try {
+            const { Project: Project2 } = await import("./ts-morph-LFNGDRSW.js");
+            const tsProject = new Project2();
+            const sf = tsProject.addSourceFileAtPath(payload.filePath);
+            const diagnostics = sf.getPreEmitDiagnostics();
+            const syntaxErrors = diagnostics.filter((d) => d.getCode() >= 1e3 && d.getCode() < 2e3);
+            if (syntaxErrors.length > 0) {
+              console.error(`[ReviewerAgent:${reviewerId}] Syntax Error in ${payload.filePath}. Rejecting immediately.`);
+              const { sendEvent: sendEvent4 } = await import("./runtime-WTVS3IND.js");
+              sendEvent4({
+                type: "file.rejected" /* FILE_REJECTED */,
+                producerId: tempAgent.getId(),
+                occurredAt: /* @__PURE__ */ new Date(),
+                payload: {
+                  planId: payload.planId,
+                  filePath: payload.filePath,
+                  errors: syntaxErrors.map((d) => `TS${d.getCode()}: ${d.getMessageText()}`)
+                }
+              }, tempAgent.getId());
+              leave(tempAgent);
+              resolve3();
+              return;
+            }
+          } catch (e) {
+            console.warn(`[ReviewerAgent:${reviewerId}] Failed to run syntax check:`, e);
+          }
+        }
+        const plan = await runtime.state.repository.getPlan(payload.planId);
+        let prompt = `Review the following file migration: ${payload.filePath}
+`;
+        if (plan) {
+          prompt += `Migration Profile: Transform from ${plan.profile.source} to ${plan.profile.target}.
+`;
+          const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+          if (catalogEntry) {
+            prompt += `
+Strict Architectural Rules for this Migration (apply only if relevant to this file's purpose):
+`;
+            catalogEntry.architecturalRules.forEach((rule) => prompt += `- ${rule}
+`);
+          }
+        }
+        prompt += `
+Diff or new content:
+${payload.diff}
+Does it meet the criteria? You MUST respond in JSON.`;
+        const modelToUse = process.env.METAMORPH_REVIEWER_MODEL || process.env.METAMORPH_MODEL || "gpt-5.4-mini";
+        console.log(`[ReviewerAgent:${reviewerId}] Starting inference loop for ${payload.filePath} with model ${modelToUse}...`);
+        try {
+          console.log(`[DEBUG:ReviewerAgent:${reviewerId}] Calling runLoop with agentId: ${tempAgent.getId()}`);
+          runLoop(tempAgent.getId(), prompt, {
+            model: modelToUse,
+            context: tempAgent.getMemory().getContext(),
+            structuredOutput: {
+              name: "review_result",
+              schema: {
+                type: "object",
+                properties: {
+                  status: { type: "string", enum: ["APPROVED", "REJECTED", "FATAL_MISMATCH"] },
+                  errors: { type: "array", items: { type: "string" } }
+                },
+                required: ["status", "errors"],
+                additionalProperties: false
+              },
+              strict: true
+            }
+          });
+          console.log(`[DEBUG:ReviewerAgent:${reviewerId}] runLoop called successfully (fire-and-forget)`);
+          setTimeout(async () => {
+            if (!isDone) {
+              console.error(`[ReviewerAgent:${reviewerId}] \u23F0 TIMEOUT after 45s for ${payload.filePath}. Model never responded.`);
+              const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+              const runtime2 = resolveRuntime2();
+              await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", "Inference timed out after 45s");
+              leave(tempAgent);
+              resolve3();
+            }
+          }, 45e3);
+        } catch (error) {
+          console.error(`[ReviewerAgent:${reviewerId}] Sync error:`, error);
+          if (!isDone) {
+            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+            const runtime2 = resolveRuntime2();
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await runtime2.state.repository.updateTaskStatus(payload.planId, payload.filePath, "failed", errorMessage || "Sync error");
+            leave(tempAgent);
+            resolve3();
+          }
+        }
+      });
+    });
+  }
+};
+var reviewFileHandler = {
+  specification: new WhenFileMigrated(),
+  processor: reviewFileProcessor
+};
+function createReviewerAgent(tools) {
+  return createAgent({
+    name: "Reviewer",
+    capabilities: ["code_review", "inference"],
+    instruction: "You are the Reviewer Worker.",
+    tools: [],
+    // No tools
+    handlers: [reviewFileHandler]
+  });
+}
+
+// ../application/src/agents/PackageManagerAgent.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+var WhenMigrationStarts2 = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
+  }
+};
+var managePackagesProcessor = {
+  async apply({ event, participant }) {
+    const payload = event.payload;
+    console.log(`[PackageManagerAgent] Managing dependencies and cleanup for Plan: ${payload.planId}`);
+    const shadowDir = payload.shadowWorkspacePath || "";
+    if (!shadowDir || !fs5.existsSync(shadowDir)) {
+      console.warn("[PackageManagerAgent] No valid shadow workspace provided. Skipping.");
+      return;
+    }
+    const runtime = resolveRuntime();
+    const plan = await runtime.state.repository.getPlan(payload.planId);
+    if (!plan) {
+      console.warn("[PackageManagerAgent] Migration plan not found.");
+      return;
+    }
+    const catalogEntry = findMigrationCatalogEntry(plan.profile.source, plan.profile.target);
+    if (!catalogEntry) {
+      console.log(`[PackageManagerAgent] No catalog entry found for ${plan.profile.source} -> ${plan.profile.target}`);
+      return;
+    }
+    if (catalogEntry.filesToDelete && catalogEntry.filesToDelete.length > 0) {
+      for (const fileToDelete of catalogEntry.filesToDelete) {
+        const fullPath = path4.join(shadowDir, fileToDelete);
+        if (fs5.existsSync(fullPath)) {
+          fs5.unlinkSync(fullPath);
+          console.log(`[PackageManagerAgent] Deleted deprecated file: ${fileToDelete}`);
+        }
+      }
+    }
+    const packageJsonPath = path4.join(shadowDir, "package.json");
+    if (fs5.existsSync(packageJsonPath)) {
+      const { execSync: execSync2 } = __require("child_process");
+      const execOpts = { cwd: shadowDir, stdio: "inherit" };
+      try {
+        let toRemove = [];
+        if (catalogEntry.dependenciesToRemove) toRemove.push(...catalogEntry.dependenciesToRemove);
+        if (catalogEntry.devDependenciesToRemove) toRemove.push(...catalogEntry.devDependenciesToRemove);
+        if (toRemove.length > 0) {
+          console.log(`[PackageManagerAgent] Uninstalling: ${toRemove.join(" ")}`);
+          execSync2(`npm uninstall ${toRemove.join(" ")}`, execOpts);
+        }
+        if (catalogEntry.dependenciesToAdd && Object.keys(catalogEntry.dependenciesToAdd).length > 0) {
+          const deps = Object.entries(catalogEntry.dependenciesToAdd).map(([pkg, ver]) => `${pkg}@${ver}`);
+          console.log(`[PackageManagerAgent] Installing dependencies: ${deps.join(" ")}`);
+          execSync2(`npm install ${deps.join(" ")}`, execOpts);
+        }
+        if (catalogEntry.devDependenciesToAdd && Object.keys(catalogEntry.devDependenciesToAdd).length > 0) {
+          const devDeps = Object.entries(catalogEntry.devDependenciesToAdd).map(([pkg, ver]) => `${pkg}@${ver}`);
+          console.log(`[PackageManagerAgent] Installing devDependencies: ${devDeps.join(" ")}`);
+          execSync2(`npm install -D ${devDeps.join(" ")}`, execOpts);
+        }
+        console.log(`[PackageManagerAgent] Successfully updated dependencies via npm.`);
+      } catch (err) {
+        console.error(`[PackageManagerAgent] Error running npm commands:`, err);
+      }
+    } else {
+      console.log(`[PackageManagerAgent] No package.json found at ${packageJsonPath}`);
+    }
+  }
+};
+var managePackagesHandler = {
+  specification: new WhenMigrationStarts2(),
+  processor: managePackagesProcessor
+};
+function createPackageManagerAgent() {
+  return createAgent({
+    name: "PackageManager",
+    capabilities: ["package_management"],
+    instruction: "You are the Package Manager Agent. Your job is to resolve dependencies and clean up unused framework files.",
+    tools: [],
+    handlers: [managePackagesHandler]
+  });
+}
+
+// ../application/src/agents/ReporterAgent.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+var WhenMigrationStarted = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.started" /* MIGRATION_STARTED */;
+  }
+};
+var WhenFileMigrated2 = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.migrated" /* FILE_MIGRATED */;
+  }
+};
+var WhenFileReviewed = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.reviewed" /* FILE_REVIEWED */;
+  }
+};
+var WhenFileRejected2 = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.rejected" /* FILE_REJECTED */;
+  }
+};
+var WhenFileFatalMismatch2 = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "file.fatal_mismatch" /* FILE_FATAL_MISMATCH */;
+  }
+};
+var WhenMigrationCompleted = class extends SituationSpecification {
+  isSatisfiedBy({ event }) {
+    return event.type === "migration.completed" /* MIGRATION_COMPLETED */;
+  }
+};
+function appendToReport(shadowDir, content) {
+  if (!shadowDir) return;
+  const reportPath = path5.join(shadowDir, "migration-report.md");
+  try {
+    fs6.appendFileSync(reportPath, content + "\n", "utf-8");
+  } catch (e) {
+    console.error("[ReporterAgent] Error writing to report:", e);
+  }
+}
+var startedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    if (!("shadowWorkspacePath" in p)) return;
+    const shadowPath = p.shadowWorkspacePath;
+    if (!shadowPath) return;
+    const reportPath = path5.join(shadowPath, "migration-report.md");
+    const header = `# Metamorph Migration Report
+**Plan ID**: ${p.planId}
+**Date Started**: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+---
+
+## Migration Log
+
+`;
+    fs6.writeFileSync(reportPath, header, "utf-8");
+    console.log(`[ReporterAgent] Initialized report at ${reportPath}`);
+  }
+};
+var migratedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+    const runtime = resolveRuntime2();
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    const shadowDir = plan.targetPath;
+    appendToReport(shadowDir, `- \u23F3 **Refactored**: \`${p.filePath}\` (Pending Review)`);
+  }
+};
+var reviewedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+    const runtime = resolveRuntime2();
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    appendToReport(plan.targetPath, `- \u2705 **Approved**: \`${p.filePath}\``);
+  }
+};
+var rejectedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+    const runtime = resolveRuntime2();
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    appendToReport(plan.targetPath, `- \u26A0\uFE0F **Rejected**: \`${p.filePath}\`
+  > Errors: ${p.errors?.join(", ")}`);
+  }
+};
+var fatalProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+    const runtime = resolveRuntime2();
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    appendToReport(plan.targetPath, `- \u274C **FATAL MISMATCH**: \`${p.filePath}\`
+  > Reason: ${p.reason}`);
+  }
+};
+var completedProcessor = {
+  async apply({ event }) {
+    const p = event.payload;
+    const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+    const runtime = resolveRuntime2();
+    const plan = await runtime.state.repository.getPlan(p.planId);
+    if (!plan) return;
+    const totalFiles = plan.tasks ? plan.tasks.length : 0;
+    const migratedFiles = plan.tasks ? plan.tasks.filter((t) => t.status === "completed").length : 0;
+    const footer = `
+---
+## Migration Completed
+**Date Finished**: ${(/* @__PURE__ */ new Date()).toLocaleString()}
+**Total Files**: ${totalFiles}
+**Successfully Migrated**: ${migratedFiles}
+`;
+    appendToReport(plan.targetPath, footer);
+  }
+};
+function createReporterAgent() {
+  return createAgent({
+    name: "Reporter",
+    capabilities: ["reporting"],
+    instruction: "You are the Reporter Agent. Your job is to compile a human-readable markdown report of the migration process.",
+    tools: [],
+    handlers: [
+      { specification: new WhenMigrationStarted(), processor: startedProcessor },
+      { specification: new WhenFileMigrated2(), processor: migratedProcessor },
+      { specification: new WhenFileReviewed(), processor: reviewedProcessor },
+      { specification: new WhenFileRejected2(), processor: rejectedProcessor },
+      { specification: new WhenFileFatalMismatch2(), processor: fatalProcessor },
+      { specification: new WhenMigrationCompleted(), processor: completedProcessor }
+    ]
+  });
+}
+
+// ../application/src/MigrationRunner.ts
+import { randomUUID } from "crypto";
+var MigrationRunner = class {
+  store;
+  tools;
+  workspace;
+  initialized = false;
+  constructor(store, tools) {
+    this.store = store;
+    this.tools = tools;
+    this.workspace = new ShadowWorkspace();
+  }
+  /**
+   * Bootstraps the Mozaik swarm if not already initialized.
+   * Idempotent: safe to call multiple times.
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      bootstrapMetamorph(this.store, this.tools);
+      this.initialized = true;
+    }
+  }
+  /**
+   * Starts a new migration run.
+   * 1. Creates a Shadow Workspace copy of the target directory.
+   * 2. Persists the MigrationPlan in the database.
+   * 3. Emits MIGRATION_STARTED to wake the swarm.
+   */
+  async startMigration(request) {
+    this.ensureInitialized();
+    await this.store.reset();
+    this.workspace.cleanupOldRuns(3);
+    const runId = `run_${Date.now()}`;
+    const shadowPath = this.workspace.cloneDirectory(request.targetPath, runId);
+    const planId = `plan_${randomUUID()}`;
+    const plan = {
+      id: planId,
+      runId,
+      profile: { source: request.from, target: request.to },
+      targetPath: request.targetPath,
+      tasks: [],
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.store.savePlan(plan);
+    const { createHuman } = await import("./dist-63RNBEIQ.js");
+    const human = createHuman({ name: "System", capabilities: [], handlers: [] });
+    join(human);
+    sendEvent(
+      {
+        type: "migration.started" /* MIGRATION_STARTED */,
+        producerId: human.getId(),
+        occurredAt: /* @__PURE__ */ new Date(),
+        payload: {
+          planId,
+          profile: plan.profile,
+          shadowWorkspacePath: shadowPath
+        }
+      },
+      human.getId()
+    );
+    return { planId, shadowPath, runId };
+  }
+  /**
+   * Rolls back a migration by deleting its Shadow Workspace.
+   * The original source code is never touched, so rollback
+   * simply means discarding the shadow copy.
+   */
+  async rollbackMigration(runId) {
+    this.workspace.rollback(runId);
+  }
+};
+
+// ../application/src/index.ts
+function bootstrapMetamorph(repository, tools = []) {
+  initializeRuntime({
+    state: new MetamorphState(repository)
+  });
+  class AllEventsSpecification extends SituationSpecification {
+    isSatisfiedBy() {
+      return true;
+    }
+  }
+  const loggerAgent = createAgent({
+    name: "TelemetryLogger",
+    capabilities: [],
+    instruction: "You silently log everything.",
+    tools: [],
+    handlers: [
+      {
+        specification: new AllEventsSpecification(),
+        processor: {
+          async apply({ event }) {
+            const { resolveRuntime: resolveRuntime2 } = await import("./runtime-WTVS3IND.js");
+            const runtime = resolveRuntime2();
+            const repository2 = runtime.state.repository;
+            if (event.type.includes("migration") || event.type.includes("file")) {
+              await repository2.logEvent(event.type, {
+                ...event.payload,
+                producerId: event.producerId
+              });
+            }
+          }
+        }
+      }
+    ]
+  });
+  join(loggerAgent);
+  const mapper = createMapperAgent();
+  const worker = createWorkerAgent(tools);
+  const reviewer = createReviewerAgent(tools);
+  const packageManager = createPackageManagerAgent();
+  const reporter = createReporterAgent();
+  join(mapper);
+  join(worker);
+  join(reviewer);
+  join(packageManager);
+  join(reporter);
+  console.log(`[App] Mozaik initialized. Agents joined: Mapper, Worker, Reviewer, PackageManager, Reporter`);
+  return {
+    mapperId: mapper.getId(),
+    workerId: worker.getId(),
+    reviewerId: reviewer.getId()
+  };
+}
+
+// src/index.ts
+var program = new Command();
+program.name("metamorph").description("AI-powered technology migration tool using Mozaik Agents").version("1.0.0");
+program.command("run [path]").description("Run a migration on the specified directory").option("--from <source>", "Source framework (e.g. express)").option("--to <target>", "Target framework (e.g. fastify)").action(async (targetPathArg, options) => {
+  let targetPath = targetPathArg || ".";
+  const { select, input } = await import("@inquirer/prompts");
+  let from = options.from;
+  let to = options.to;
+  const SUPPORTED_MIGRATIONS = {
+    express: ["fastify", "nestjs"],
+    fastify: ["nestjs", "express"],
+    react: ["next"],
+    vue: ["react", "next"],
+    angular: ["react", "next"],
+    svelte: ["react", "next"]
+  };
+  if (!from) {
+    console.log(chalk.gray(`
+\u{1F50D} Scanning directory: ${targetPath}`));
+    const detected = detectTechnologies(targetPath);
+    const supportedDetected = detected.filter((d) => Object.keys(SUPPORTED_MIGRATIONS).includes(d.framework));
+    if (supportedDetected.length > 0) {
+      from = await select({
+        message: "What technology do you want to migrate FROM?",
+        choices: supportedDetected.map((d) => ({ name: `${d.framework} (Detected ${d.confidence}%)`, value: d.framework }))
+      });
+    } else {
+      console.log(chalk.yellow(`No supported technologies detected in the current directory.`));
+      process.exit(0);
+    }
+  }
+  if (!to) {
+    const validTargets = SUPPORTED_MIGRATIONS[from] || [];
+    if (validTargets.length > 0) {
+      to = await select({
+        message: `What framework do you want to migrate TO from ${from}?`,
+        choices: validTargets.map((t) => ({ name: t, value: t }))
+      });
+    } else {
+      console.log(chalk.red(`No supported target frameworks for ${from}.`));
+      process.exit(1);
+    }
+  }
+  console.log(chalk.blue(`
+\u{1F680} Starting Metamorph Migration`));
+  console.log(chalk.gray(`Target: ${targetPath} | ${from} -> ${to}
+`));
+  if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+    console.log(chalk.yellow(`\u26A0\uFE0F WARNING: No LLM API key detected.
+`));
+  }
+  const spinner = ora("Initializing...").start();
+  try {
+    const store = new SQLiteStateStore(".metamorph");
+    const tools = [
+      createReadFileTool(),
+      createWriteFileTool(),
+      createRenameFileTool(),
+      createCreateFileTool(),
+      createDeleteFileTool()
+    ];
+    const runner = new MigrationRunner(store, tools);
+    const result = await runner.startMigration({
+      targetPath,
+      from,
+      to
+    });
+    spinner.succeed(`Migration dispatched! Plan: ${result.planId}`);
+    console.log(chalk.gray(`Shadow: ${result.shadowPath}`));
+    console.log(chalk.blue(`
+\u23F3 Agents are now working...`));
+    await new Promise((resolve3) => setTimeout(resolve3, 2e4));
+    console.log(chalk.green(`
+\u2705 Migration simulation finished.`));
+    process.exit(0);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    spinner.fail(`Migration failed: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.command("apply <runId> <targetPath>").description("Apply a completed migration to the target project").action(async (runId, targetPath) => {
+  try {
+    const integrator = new MigrationIntegrator(new ShadowWorkspace());
+    const message = await integrator.applyMigration(runId, targetPath);
+    console.log(chalk.green(`\u2705 ${message}`));
+  } catch (error) {
+    console.error(chalk.red(`\u274C Failed to apply migration: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+program.command("rollback <runId>").description("Rollback and discard an unapplied migration shadow workspace").action(async (runId) => {
+  try {
+    const store = new SQLiteStateStore(".metamorph");
+    const runner = new MigrationRunner(store, []);
+    await runner.rollbackMigration(runId);
+    console.log(chalk.green(`\u2705 Rolled back run: ${runId}`));
+  } catch (error) {
+    console.error(chalk.red(`\u274C Failed to rollback: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+program.command("reset").description("Clear all migration history and events from the database").action(async () => {
+  try {
+    const store = new SQLiteStateStore(".metamorph");
+    await store.reset();
+    console.log(chalk.green(`\u2705 Migration state reset successfully.`));
+  } catch (error) {
+    console.error(chalk.red(`\u274C Failed to reset: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+program.command("detect [path]").description("Detect frameworks and libraries in a directory").action(async (targetPath) => {
+  try {
+    const detected = detectTechnologies(targetPath || ".");
+    if (detected.length === 0) {
+      console.log(chalk.yellow(`No known technologies detected.`));
+    } else {
+      console.log(chalk.blue(`
+\u{1F50D} Detected Technologies:`));
+      detected.forEach((d) => console.log(` - ${chalk.green(d.framework)} (Confidence: ${d.confidence}%) 
+    Evidence: ${chalk.gray(d.evidence.join(", "))}`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`\u274C Detection failed: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+program.command("list").description("List past migration plans").action(async () => {
+  try {
+    const store = new SQLiteStateStore(".metamorph");
+    const plans = await store.getAllPlans();
+    if (plans.length === 0) {
+      console.log(chalk.yellow(`No migration plans found.`));
+      return;
+    }
+    console.log(chalk.blue(`
+\u{1F4CB} Migration Plans:`));
+    plans.forEach((p) => {
+      console.log(`${chalk.green(p.id)} | ${p.profile.source} -> ${p.profile.target} | Target: ${p.targetPath} | Tasks: ${p.tasks.length}`);
+    });
+  } catch (error) {
+    console.error(chalk.red(`\u274C Failed to list plans: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+program.command("ui").description("Start the Metamorph Dashboard API server").option("-p, --port <number>", "Port for the API server", "9876").action(async (options) => {
+  let desiredPort = parseInt(options.port, 10);
+  const spinner = ora("Starting Metamorph API server...").start();
+  try {
+    const getPort = (await import("get-port")).default;
+    const open = (await import("open")).default;
+    const port = await getPort({ port: desiredPort });
+    const store = new SQLiteStateStore(".metamorph");
+    const tools = [
+      createReadFileTool(),
+      createWriteFileTool(),
+      createRenameFileTool(),
+      createCreateFileTool(),
+      createDeleteFileTool()
+    ];
+    const runner = new MigrationRunner(store, tools);
+    const app = await createApiServer(store, runner);
+    app.listen(port, () => {
+      spinner.succeed(
+        `Metamorph UI running on http://localhost:${port}`
+      );
+      console.log(chalk.blue(`
+Endpoints available:`));
+      console.log(chalk.gray(`  GET  /api/plans`));
+      console.log(chalk.gray(`  GET  /api/events`));
+      console.log(chalk.gray(`  POST /api/migrations/start`));
+      console.log(chalk.gray(`  POST /api/migrations/rollback`));
+      open(`http://localhost:${port}`);
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    spinner.fail(`Failed to start: ${errorMessage}`);
+    process.exit(1);
+  }
+});
+program.parse(process.argv);