@nikelyh/metamorph 2.0.11 → 2.1.1

package/dist/chunk-L7B6KUCW.js

@@ -0,0 +1,1018 @@
+import {
+  resolveMigrationCatalog
+} from "./chunk-VEAYUIOZ.js";
+
+// ../infrastructure/src/db/SQLiteStateStore.ts
+import { DatabaseSync } from "node:sqlite";
+import { join } from "path";
+import { mkdirSync } from "fs";
+var SQLiteStateStore = class {
+  db;
+  constructor(storageDir = ".metamorph") {
+    try {
+      mkdirSync(storageDir, { recursive: true });
+    } catch (e) {
+    }
+    const dbPath = join(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,
+        integration_rounds INTEGER DEFAULT 0,
+        phase 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) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN integration_rounds INTEGER");
+    } catch (e) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN phase TEXT");
+    } catch (e) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN outcome TEXT");
+    } catch (e) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN applied_at TEXT");
+    } catch (e) {
+    }
+    try {
+      this.db.exec("ALTER TABLE plans ADD COLUMN applied_branch 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, integration_rounds, phase, outcome, applied_at, applied_branch)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmtPlan.run(
+      plan.id,
+      plan.runId,
+      plan.targetPath || "",
+      plan.profile.source,
+      plan.profile.target,
+      JSON.stringify(plan.profile.rules || []),
+      plan.createdAt.toISOString(),
+      plan.integrationRounds ?? 0,
+      plan.phase || "files",
+      plan.outcome || null,
+      plan.appliedAt ? plan.appliedAt.toISOString() : null,
+      plan.appliedBranch || null
+    );
+    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
+      );
+    }
+  }
+  mapPlan(planRow, taskRows) {
+    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),
+      integrationRounds: planRow.integration_rounds ?? 0,
+      phase: planRow.phase || "files",
+      outcome: planRow.outcome || void 0,
+      appliedAt: planRow.applied_at ? new Date(planRow.applied_at) : void 0,
+      appliedBranch: planRow.applied_branch || void 0,
+      tasks: taskRows.map((row) => ({
+        filePath: row.file_path,
+        status: row.status,
+        dependencies: JSON.parse(row.dependencies_json),
+        error: row.error || void 0
+      }))
+    };
+  }
+  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 this.mapPlan(planRow, taskRows);
+  }
+  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 this.mapPlan(planRow, planTasks);
+    });
+  }
+  async getEvents() {
+    const stmt = this.db.prepare(`SELECT * FROM events ORDER BY id DESC LIMIT 2000`);
+    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
+import { Project } from "ts-morph";
+import { existsSync } from "fs";
+import * as path from "path";
+var project = new Project();
+function assertSandbox(filePath, sandboxDir) {
+  const resolved = path.resolve(filePath);
+  if (sandboxDir) {
+    const resolvedSandbox = path.resolve(sandboxDir);
+    const isInside = resolved === resolvedSandbox || resolved.startsWith(resolvedSandbox + path.sep);
+    if (!isInside) {
+      throw new Error(
+        `BLOCKED: Path "${resolved}" is outside the sandbox "${resolvedSandbox}". All file operations must stay within the shadow workspace.`
+      );
+    }
+  }
+  return resolved;
+}
+function createReadFileTool(sandboxDir) {
+  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 absolute path to the file to read." }
+      },
+      required: ["filePath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath }) => {
+      const resolvedPath = assertSandbox(filePath, sandboxDir);
+      if (!existsSync(resolvedPath)) {
+        return { error: `File not found: ${resolvedPath}` };
+      }
+      let sourceFile = project.getSourceFile(resolvedPath);
+      if (!sourceFile) {
+        project.addSourceFileAtPath(resolvedPath);
+        sourceFile = project.getSourceFileOrThrow(resolvedPath);
+      } else {
+        await sourceFile.refreshFromFileSystem();
+      }
+      return {
+        filePath: resolvedPath,
+        content: sourceFile.getFullText()
+      };
+    }
+  };
+}
+function createWriteFileTool(sandboxDir) {
+  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 absolute 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 }) => {
+      const resolvedPath = assertSandbox(filePath, sandboxDir);
+      let sourceFile = project.getSourceFile(resolvedPath);
+      if (!sourceFile) {
+        if (existsSync(resolvedPath)) {
+          project.addSourceFileAtPath(resolvedPath);
+          sourceFile = project.getSourceFileOrThrow(resolvedPath);
+        } else {
+          sourceFile = project.createSourceFile(resolvedPath, "");
+        }
+      }
+      sourceFile.replaceWithText(newContent);
+      await sourceFile.save();
+      return {
+        success: true,
+        message: `File ${resolvedPath} successfully updated.`
+      };
+    }
+  };
+}
+function createRenameFileTool(sandboxDir) {
+  return {
+    type: "function",
+    name: "rename_file",
+    description: "Renames a file in the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        oldPath: { type: "string", description: "Current absolute path of the file." },
+        newPath: { type: "string", description: "New absolute path for the file." }
+      },
+      required: ["oldPath", "newPath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ oldPath, newPath }) => {
+      const resolvedOld = assertSandbox(oldPath, sandboxDir);
+      const resolvedNew = assertSandbox(newPath, sandboxDir);
+      const { renameSync, existsSync: fsExists } = await import("fs");
+      if (!fsExists(resolvedOld)) {
+        return { error: `File not found: ${resolvedOld}` };
+      }
+      const { mkdirSync: mkdirSync2 } = await import("fs");
+      const { dirname } = await import("path");
+      mkdirSync2(dirname(resolvedNew), { recursive: true });
+      renameSync(resolvedOld, resolvedNew);
+      const sourceFile = project.getSourceFile(resolvedOld);
+      if (sourceFile) {
+        project.removeSourceFile(sourceFile);
+        if (fsExists(resolvedNew)) {
+          project.addSourceFileAtPath(resolvedNew);
+        }
+      }
+      return { success: true, message: `File renamed from ${resolvedOld} to ${resolvedNew}.` };
+    }
+  };
+}
+function createCreateFileTool(sandboxDir) {
+  return {
+    type: "function",
+    name: "create_file",
+    description: "Creates a new file with the specified content.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Absolute 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 resolvedPath = assertSandbox(filePath, sandboxDir);
+      const { writeFileSync, mkdirSync: mkdirSync2 } = await import("fs");
+      const { dirname } = await import("path");
+      mkdirSync2(dirname(resolvedPath), { recursive: true });
+      writeFileSync(resolvedPath, content, "utf-8");
+      project.addSourceFileAtPath(resolvedPath);
+      return { success: true, message: `File created at ${resolvedPath}.` };
+    }
+  };
+}
+function createDeleteFileTool(sandboxDir) {
+  return {
+    type: "function",
+    name: "delete_file",
+    description: "Deletes a file from the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        filePath: { type: "string", description: "Absolute path of the file to delete." }
+      },
+      required: ["filePath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ filePath }) => {
+      const resolvedPath = assertSandbox(filePath, sandboxDir);
+      const { renameSync, existsSync: fsExists } = await import("fs");
+      if (!fsExists(resolvedPath)) {
+        return { error: `File not found: ${resolvedPath}` };
+      }
+      const obsoletePath = `${resolvedPath}.obsolete`;
+      renameSync(resolvedPath, obsoletePath);
+      const sourceFile = project.getSourceFile(resolvedPath);
+      if (sourceFile) {
+        project.removeSourceFile(sourceFile);
+      }
+      return { success: true, message: `File marked as obsolete at ${obsoletePath} instead of deleting.` };
+    }
+  };
+}
+function createListDirectoryTool(sandboxDir) {
+  return {
+    type: "function",
+    name: "list_directory",
+    description: "Lists files and folders in a directory inside the shadow workspace. Use this to find existing screens, entry files, or imports instead of guessing paths.",
+    parameters: {
+      type: "object",
+      properties: {
+        dirPath: { type: "string", description: "Absolute directory path inside the shadow workspace." }
+      },
+      required: ["dirPath"],
+      additionalProperties: false
+    },
+    strict: true,
+    invoke: async ({ dirPath }) => {
+      const resolvedPath = assertSandbox(dirPath, sandboxDir);
+      const { readdirSync, statSync: statSync2, existsSync: fsExists } = await import("fs");
+      if (!fsExists(resolvedPath)) {
+        return { error: `Directory not found: ${resolvedPath}` };
+      }
+      if (!statSync2(resolvedPath).isDirectory()) {
+        return { error: `Not a directory: ${resolvedPath}` };
+      }
+      const entries = readdirSync(resolvedPath, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules").slice(0, 80).map((entry) => ({
+        name: entry.name,
+        path: path.join(resolvedPath, entry.name),
+        kind: entry.isDirectory() ? "dir" : "file"
+      }));
+      return { dirPath: resolvedPath, entries };
+    }
+  };
+}
+function createShadowTools(shadowDir) {
+  return [
+    createReadFileTool(shadowDir),
+    createWriteFileTool(shadowDir),
+    createRenameFileTool(shadowDir),
+    createCreateFileTool(shadowDir),
+    createDeleteFileTool(shadowDir),
+    createListDirectoryTool(shadowDir)
+  ];
+}
+
+// ../infrastructure/src/workspace/ShadowWorkspace.ts
+import fs from "fs-extra";
+import { join as join3, resolve as resolve2 } from "path";
+var ShadowWorkspace = class {
+  baseDir;
+  constructor(basePath = ".metamorph/shadow") {
+    this.baseDir = resolve2(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 = resolve2(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, protectedRunIds = []) {
+    if (!fs.existsSync(this.baseDir)) return;
+    const protectedSet = new Set(protectedRunIds);
+    const runs = fs.readdirSync(this.baseDir).filter((f) => f.startsWith("run_") && fs.statSync(join3(this.baseDir, f)).isDirectory());
+    runs.sort();
+    const unprotected = runs.filter((run) => !protectedSet.has(run));
+    if (unprotected.length <= keepCount) return;
+    const toDelete = unprotected.slice(0, unprotected.length - keepCount);
+    for (const run of toDelete) {
+      this.rollback(run);
+    }
+  }
+};
+
+// ../infrastructure/src/workspace/MigrationIntegrator.ts
+import fs2 from "fs-extra";
+import * as path2 from "path";
+import { execFileSync } from "child_process";
+var COPY_IGNORED = ["node_modules", ".git", ".metamorph", "dist", "build", "out", "coverage", ".next"];
+function isCopyIgnored(itemName) {
+  if (COPY_IGNORED.includes(itemName)) return true;
+  if (itemName === ".env" || itemName.startsWith(".env.")) return true;
+  return false;
+}
+var MigrationIntegrator = class {
+  shadowWorkspace;
+  constructor(shadowWorkspace) {
+    this.shadowWorkspace = shadowWorkspace;
+  }
+  /**
+   * Applies the migrated code from the shadow workspace back to the target directory.
+   * Requires a Git repository that actually versions the target (not a parent repo that gitignores it).
+   */
+  async applyMigration(runId, targetPath) {
+    const shadowDir = this.shadowWorkspace.getShadowPath(runId);
+    if (!fs2.existsSync(shadowDir)) {
+      throw new Error(`Shadow run not found: ${shadowDir}`);
+    }
+    const resolvedTarget = path2.resolve(process.cwd(), targetPath);
+    const gitRoot = this.resolveGitRoot(resolvedTarget);
+    if (!gitRoot) {
+      throw new Error(
+        "Metamorph apply requires a Git repository. Run this from a project that already has git (including monorepo packages whose .git lives in a parent folder). Nested git init is not supported."
+      );
+    }
+    const rootPkgJson = path2.join(gitRoot, "package.json");
+    if (fs2.existsSync(rootPkgJson)) {
+      try {
+        const pkg = JSON.parse(fs2.readFileSync(rootPkgJson, "utf-8"));
+        const normalizedTarget = resolvedTarget.replace(/\\/g, "/");
+        if (pkg.name === "metamorph-monorepo" && normalizedTarget.includes("/scratch/")) {
+          throw new Error(
+            `BLOCKED: Cannot apply to "${resolvedTarget}" because it is inside the development scratch/ directory of the Metamorph repository. Use a standalone git repository for user project migrations.`
+          );
+        }
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("BLOCKED:")) throw e;
+      }
+    }
+    if (this.isIgnoredByGit(gitRoot, resolvedTarget)) {
+      throw new Error(
+        `Cannot apply via Git: "${resolvedTarget}" is ignored by the repository at "${gitRoot}" (.gitignore). Metamorph will not create branches on a parent repo for ignored sandboxes. Use a standalone git project, or a tracked package inside a monorepo.`
+      );
+    }
+    return this.applyWithGit(runId, shadowDir, resolvedTarget, gitRoot, `metamorph/${runId}`);
+  }
+  /**
+   * Walks up from targetPath via `git rev-parse --show-toplevel`.
+   */
+  resolveGitRoot(targetPath) {
+    try {
+      const root = this.git(["rev-parse", "--show-toplevel"], targetPath).trim();
+      return root || null;
+    } catch {
+      return null;
+    }
+  }
+  isIgnoredByGit(gitRoot, targetPath) {
+    try {
+      execFileSync("git", ["check-ignore", "-q", "--", targetPath], {
+        cwd: gitRoot,
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  git(args, cwd) {
+    try {
+      return execFileSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (error) {
+      const err = error;
+      const detail = [err.stderr, err.stdout, err.message].map((part) => (Buffer.isBuffer(part) ? part.toString("utf-8") : part) || "").filter(Boolean).join("\n").trim();
+      throw new Error(`git ${args.join(" ")} failed: ${detail || "unknown git error"}`);
+    }
+  }
+  async applyWithGit(runId, shadowDir, targetPath, gitRoot, branchName) {
+    const relativeTarget = path2.relative(gitRoot, targetPath).replace(/\\/g, "/");
+    const addPath = relativeTarget === "" ? "." : relativeTarget;
+    const dirtyStatus = this.git(["status", "--porcelain", "--", addPath], gitRoot).trim();
+    if (dirtyStatus) {
+      throw new Error(
+        `Cannot apply migration: the target directory has uncommitted changes:
+${dirtyStatus}
+Please commit or stash your changes before applying.`
+      );
+    }
+    try {
+      this.git(["checkout", "-B", branchName], gitRoot);
+    } 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 {
+      try {
+        this.git(["-c", "advice.addIgnoredFile=false", "add", "-A", "--", addPath], gitRoot);
+      } catch (addError) {
+        const detail = addError instanceof Error ? addError.message : String(addError);
+        const ignoredOnly = /paths are ignored by one of your \.gitignore/i.test(detail) && !/not a git repository|index\.lock|permission denied|tell me who you are/i.test(detail);
+        if (!ignoredOnly) {
+          throw addError;
+        }
+      }
+      this.git(
+        ["-c", "advice.addIgnoredFile=false", "commit", "--allow-empty", "-m", `chore: apply metamorph ai migration (${runId})`],
+        gitRoot
+      );
+    } catch (e) {
+      const detail = e instanceof Error ? e.message : String(e);
+      if (/tell me who you are|user\.email|user\.name/i.test(detail)) {
+        throw new Error(
+          `Failed to commit to branch ${branchName}: Git user.name / user.email are not set. Run git config user.email and git config user.name in this repo, then retry apply.`
+        );
+      }
+      throw new Error(`Failed to commit changes to branch ${branchName}: ${detail}`);
+    }
+    return {
+      message: `Successfully applied migration via Git to branch: ${branchName}`,
+      gitUsed: true,
+      branch: branchName
+    };
+  }
+  copyShadowToTarget(shadowDir, targetPath) {
+    if (fs2.existsSync(targetPath)) {
+      const targetItems = fs2.readdirSync(targetPath);
+      for (const item of targetItems) {
+        if (isCopyIgnored(item)) continue;
+        fs2.removeSync(path2.join(targetPath, item));
+      }
+    }
+    const shadowItems = fs2.readdirSync(shadowDir);
+    for (const item of shadowItems) {
+      if (isCopyIgnored(item)) continue;
+      const itemSrc = path2.join(shadowDir, item);
+      const itemDest = path2.join(targetPath, item);
+      fs2.copySync(itemSrc, itemDest, { overwrite: true });
+    }
+  }
+};
+
+// ../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, statSync: statSync2 } = await import("fs");
+      const { resolve: resolve5, join: join7 } = await import("path");
+      const targetPath = req.query.path ? resolve5(String(req.query.path)) : resolve5(".");
+      const entries = readdirSync(targetPath).filter(
+        (name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist" && name !== "build"
+      ).map((name) => {
+        const full = join7(targetPath, name);
+        try {
+          const stat = statSync2(full);
+          return {
+            name,
+            path: full,
+            isDirectory: stat.isDirectory()
+          };
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      res.json({
+        current: targetPath,
+        parent: resolve5(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 } = await import("./TechDetector-5YP44RVR.js");
+      const targetPath = req.query.path ? String(req.query.path) : ".";
+      const detected = detectTechnologies(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 = resolveMigrationCatalog(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 plans = await store.getAllPlans();
+        const plan = plans.find((item) => item.runId === runId);
+        if (!plan) {
+          res.status(404).json({ error: `Plan for run "${runId}" not found in database.` });
+          return;
+        }
+        if (plan.phase !== "completed" || plan.outcome !== "success") {
+          res.status(400).json({
+            error: `Cannot apply migration: plan is not completed successfully (phase: "${plan.phase}", outcome: "${plan.outcome || "none"}"). Only successful migrations can be applied.`
+          });
+          return;
+        }
+        if (plan.appliedAt) {
+          res.status(400).json({
+            error: `Migration for run "${runId}" has already been applied at ${new Date(plan.appliedAt).toISOString()} to branch ${plan.appliedBranch || "unknown"}.`
+          });
+          return;
+        }
+        const integrator = new MigrationIntegrator(migrationRunner.workspace);
+        const result = await integrator.applyMigration(runId, targetPath);
+        plan.appliedAt = /* @__PURE__ */ new Date();
+        plan.appliedBranch = result.branch;
+        await store.savePlan(plan);
+        await store.logEvent("migration.applied", { runId, branch: result.branch, targetPath });
+        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/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 path5 = await import("path");
+  const fs4 = await import("fs");
+  let publicDir = path5.join(import.meta.dirname, "public");
+  if (!fs4.existsSync(publicDir)) {
+    publicDir = path5.join(import.meta.dirname, "../public");
+  }
+  if (fs4.existsSync(publicDir)) {
+    app.use(express.static(publicDir));
+    app.get(/^(.*)$/, (_req, res) => {
+      res.sendFile(path5.join(publicDir, "index.html"));
+    });
+  }
+  return app;
+}
+
+// ../infrastructure/src/tools/LinterTools.ts
+import { Project as Project2 } from "ts-morph";
+import * as path3 from "path";
+var createCheckProjectDiagnosticsTool = (shadowBase) => ({
+  type: "function",
+  name: "check_project_diagnostics",
+  description: "Checks the project for TypeScript errors like broken imports/exports. Call this to see if the project has cross-file integration issues. Returns a list of errors.",
+  parameters: {
+    type: "object",
+    properties: {}
+    // No params needed, it checks the whole shadow workspace
+  },
+  strict: true,
+  invoke: async () => {
+    try {
+      const tsConfigPath = path3.join(shadowBase, "tsconfig.json");
+      let project2;
+      try {
+        project2 = new Project2({
+          tsConfigFilePath: tsConfigPath,
+          skipAddingFilesFromTsConfig: false
+        });
+      } catch (err) {
+        project2 = new Project2();
+      }
+      project2.addSourceFilesAtPaths(path3.join(shadowBase, "src/**/*.ts"));
+      project2.addSourceFilesAtPaths(path3.join(shadowBase, "src/**/*.tsx"));
+      const diagnostics = project2.getPreEmitDiagnostics();
+      const relevantErrors = diagnostics.filter((d) => {
+        const code = d.getCode();
+        const message = d.getMessageText().toString();
+        if (code === 17004) return false;
+        if (code === 2307 || code === 2792) {
+          if (message.includes("'.") || message.includes("'/") || message.includes("'@/")) {
+            return true;
+          }
+          return false;
+        }
+        if ([2304, 2305, 2306, 2614, 2552, 2322, 2786].includes(code)) {
+          return true;
+        }
+        return false;
+      });
+      if (relevantErrors.length === 0) {
+        return "No local import/export errors found! The project integration looks solid.";
+      }
+      const formattedErrors = relevantErrors.map((d) => {
+        const file = d.getSourceFile();
+        const start = d.getStart();
+        const line = file && start !== void 0 ? file.getLineAndColumnAtPos(start).line : "unknown";
+        const filePath = file ? path3.relative(shadowBase, file.getFilePath()) : "unknown path";
+        return `[TS${d.getCode()}] ${filePath}:${line} - ${d.getMessageText().toString()}`;
+      }).join("\n");
+      return `Found ${relevantErrors.length} integration errors:
+${formattedErrors}`;
+    } catch (e) {
+      return `Failed to run diagnostics: ${e.message}. Note: if tsconfig.json is missing, you may need to check files manually.`;
+    }
+  }
+});
+
+// ../infrastructure/src/tools/BuildTools.ts
+import { spawn } from "child_process";
+import * as fs3 from "fs";
+import * as path4 from "path";
+async function runInShadowWorkspace(shadowBase, command, onChunk) {
+  return new Promise((resolve5) => {
+    const child = spawn(command, {
+      cwd: shadowBase,
+      shell: true,
+      env: {
+        ...process.env,
+        CI: "true",
+        NPM_CONFIG_WORKSPACES: "false",
+        NPM_CONFIG_FUND: "false",
+        NPM_CONFIG_AUDIT: "false",
+        npm_config_progress: "false"
+      }
+    });
+    let output = "";
+    const append = (buf) => {
+      const text = buf.toString("utf-8");
+      output += text;
+      onChunk?.(text);
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      resolve5({
+        ok: false,
+        output: `${output}
+Command timed out after 5 minutes: ${command}`
+      });
+    }, 3e5);
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve5({ ok: false, output: `${output}
+${error.message}` });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      resolve5({ ok: code === 0, output: output.trim() });
+    });
+  });
+}
+function parseImplicatedFiles(output, shadowPath) {
+  const found = /* @__PURE__ */ new Set();
+  const root = path4.resolve(shadowPath);
+  const ext = String.raw`tsx|ts|jsx|js|mjs|cjs|css`;
+  const patterns = [
+    new RegExp(String.raw`(?:^|[\s'"(\`])((?:\.{1,2}[\\/])?[^\s:'"()<>]+\.(?:${ext}))`, "g"),
+    new RegExp(String.raw`\b([A-Za-z]:[\\/][^\s'"()<>]+\.(?:${ext}))`, "g")
+  ];
+  const consider = (raw) => {
+    const stripped = raw.replace(/[\\/]+$/, "").replace(/:[\d]+(?::[\d]+)?$/, "");
+    const abs = /^[A-Za-z]:[\\/]/.test(stripped) || path4.isAbsolute(stripped) ? stripped : path4.join(shadowPath, stripped.replace(/^\.[\\/]/, ""));
+    const resolved = path4.resolve(abs);
+    const inside = resolved === root || resolved.startsWith(root + path4.sep);
+    if (!inside) return;
+    if (fs3.existsSync(resolved)) {
+      if (fs3.statSync(resolved).isFile()) found.add(resolved);
+    } else {
+      found.add(resolved);
+    }
+  };
+  for (const re of patterns) {
+    let match;
+    while ((match = re.exec(output)) !== null) consider(match[1]);
+  }
+  return [...found];
+}
+var createRunBuildTool = (shadowBase) => ({
+  type: "function",
+  name: "run_project_build",
+  description: `Runs a command (typically "npm install" or "npm run build") in the shadow workspace for this migration run. Never runs against the user's original tree.`,
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: 'The command to run. Use "npm install" then "npm run build".'
+      }
+    },
+    required: ["command"]
+  },
+  strict: true,
+  invoke: async (args) => {
+    const result = await runInShadowWorkspace(shadowBase, args.command || "npm run build", (chunk) => {
+      process.stdout.write(chunk);
+    });
+    return result.ok ? `Build Output:
+${result.output}` : `Build Failed!
+${result.output}`;
+  }
+});
+
+export {
+  SQLiteStateStore,
+  assertSandbox,
+  createReadFileTool,
+  createWriteFileTool,
+  createRenameFileTool,
+  createCreateFileTool,
+  createDeleteFileTool,
+  createListDirectoryTool,
+  createShadowTools,
+  ShadowWorkspace,
+  isCopyIgnored,
+  MigrationIntegrator,
+  createApiServer,
+  createCheckProjectDiagnosticsTool,
+  runInShadowWorkspace,
+  parseImplicatedFiles,
+  createRunBuildTool
+};