@nikelyh/metamorph 2.1.0 → 2.1.1

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

@@ -1,5 +1,5 @@
 import {
-  findMigrationCatalogEntry
+  resolveMigrationCatalog
 } from "./chunk-VEAYUIOZ.js";
 
 // ../infrastructure/src/db/SQLiteStateStore.ts
@@ -50,6 +50,10 @@ var SQLiteStateStore = class {
       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) {
@@ -80,8 +84,8 @@ var SQLiteStateStore = class {
   }
   async savePlan(plan) {
     const stmtPlan = this.db.prepare(`
-      INSERT OR REPLACE INTO plans (id, run_id, target_path, source_framework, target_framework, rules_json, created_at, integration_rounds, phase, applied_at, applied_branch)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT OR REPLACE INTO plans (id, run_id, target_path, source_framework, target_framework, rules_json, created_at, integration_rounds, phase, outcome, applied_at, applied_branch)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
     stmtPlan.run(
       plan.id,
@@ -93,6 +97,7 @@ var SQLiteStateStore = class {
       plan.createdAt.toISOString(),
       plan.integrationRounds ?? 0,
       plan.phase || "files",
+      plan.outcome || null,
       plan.appliedAt ? plan.appliedAt.toISOString() : null,
       plan.appliedBranch || null
     );
@@ -123,6 +128,7 @@ var SQLiteStateStore = class {
       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) => ({
@@ -195,7 +201,8 @@ function assertSandbox(filePath, sandboxDir) {
   const resolved = path.resolve(filePath);
   if (sandboxDir) {
     const resolvedSandbox = path.resolve(sandboxDir);
-    if (!resolved.startsWith(resolvedSandbox)) {
+    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.`
       );
@@ -396,6 +403,16 @@ function createListDirectoryTool(sandboxDir) {
     }
   };
 }
+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";
@@ -454,15 +471,16 @@ var ShadowWorkspace = class {
    * 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) {
+  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();
-    if (runs.length > keepCount) {
-      const toDelete = runs.slice(0, runs.length - keepCount);
-      for (const run of toDelete) {
-        this.rollback(run);
-      }
+    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);
     }
   }
 };
@@ -472,7 +490,11 @@ 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"];
-var GITIGNORE_ENTRIES = [".metamorph/", ".next/", "node_modules/", "dist/", "build/", "coverage/", ".env"];
+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) {
@@ -494,6 +516,20 @@ var MigrationIntegrator = class {
         "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.`
@@ -536,22 +572,17 @@ var MigrationIntegrator = class {
       throw new Error(`git ${args.join(" ")} failed: ${detail || "unknown git error"}`);
     }
   }
-  ensureApplyGitignore(gitRoot) {
-    const gitignorePath = path2.join(gitRoot, ".gitignore");
-    const existing = fs2.existsSync(gitignorePath) ? fs2.readFileSync(gitignorePath, "utf-8") : "";
-    const missing = GITIGNORE_ENTRIES.filter((entry) => {
-      const name = entry.replace(/\/$/, "").replace(".", "\\.");
-      const pattern = new RegExp(`(^|\\n)${name}(/)?(\\n|$)`);
-      return !pattern.test(existing.replace(/\r/g, "\n"));
-    });
-    if (missing.length === 0) return;
-    const block = `
-# Metamorph apply
-${missing.join("\n")}
-`;
-    fs2.appendFileSync(gitignorePath, block, "utf-8");
-  }
   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) {
@@ -561,9 +592,6 @@ ${missing.join("\n")}
       throw new Error(`Failed to create/reset git branch ${branchName}: ${String(e)}`);
     }
     this.copyShadowToTarget(shadowDir, targetPath);
-    this.ensureApplyGitignore(gitRoot);
-    const relativeTarget = path2.relative(gitRoot, targetPath).replace(/\\/g, "/");
-    const addPath = relativeTarget === "" ? "." : relativeTarget;
     try {
       try {
         this.git(["-c", "advice.addIgnoredFile=false", "add", "-A", "--", addPath], gitRoot);
@@ -597,13 +625,13 @@ ${missing.join("\n")}
     if (fs2.existsSync(targetPath)) {
       const targetItems = fs2.readdirSync(targetPath);
       for (const item of targetItems) {
-        if (COPY_IGNORED.includes(item)) continue;
+        if (isCopyIgnored(item)) continue;
         fs2.removeSync(path2.join(targetPath, item));
       }
     }
     const shadowItems = fs2.readdirSync(shadowDir);
     for (const item of shadowItems) {
-      if (COPY_IGNORED.includes(item)) continue;
+      if (isCopyIgnored(item)) continue;
       const itemSrc = path2.join(shadowDir, item);
       const itemDest = path2.join(targetPath, item);
       fs2.copySync(itemSrc, itemDest, { overwrite: true });
@@ -702,7 +730,7 @@ async function createApiServer(store, migrationRunner) {
           });
           return;
         }
-        const catalogEntry = findMigrationCatalogEntry(from, to);
+        const catalogEntry = resolveMigrationCatalog(from, to);
         if (!catalogEntry) {
           res.status(400).json({
             error: `Unsupported migration profile: ${from} -> ${to}. Please check the supported catalog.`
@@ -732,15 +760,29 @@ async function createApiServer(store, migrationRunner) {
           });
           return;
         }
-        const integrator = new MigrationIntegrator(migrationRunner.workspace);
-        const result = await integrator.applyMigration(runId, targetPath);
         const plans = await store.getAllPlans();
         const plan = plans.find((item) => item.runId === runId);
-        if (plan) {
-          plan.appliedAt = /* @__PURE__ */ new Date();
-          plan.appliedBranch = result.branch;
-          await store.savePlan(plan);
+        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) {
@@ -918,7 +960,11 @@ function parseImplicatedFiles(output, shadowPath) {
     const resolved = path4.resolve(abs);
     const inside = resolved === root || resolved.startsWith(root + path4.sep);
     if (!inside) return;
-    if (fs3.existsSync(resolved) && fs3.statSync(resolved).isFile()) found.add(resolved);
+    if (fs3.existsSync(resolved)) {
+      if (fs3.statSync(resolved).isFile()) found.add(resolved);
+    } else {
+      found.add(resolved);
+    }
   };
   for (const re of patterns) {
     let match;
@@ -953,13 +999,16 @@ ${result.output}`;
 
 export {
   SQLiteStateStore,
+  assertSandbox,
   createReadFileTool,
   createWriteFileTool,
   createRenameFileTool,
   createCreateFileTool,
   createDeleteFileTool,
   createListDirectoryTool,
+  createShadowTools,
   ShadowWorkspace,
+  isCopyIgnored,
   MigrationIntegrator,
   createApiServer,
   createCheckProjectDiagnosticsTool,