@automigrate/cli 0.1.2

package/dist/index.js

@@ -0,0 +1,3231 @@
+#!/usr/bin/env node
+import {
+  Anthropic,
+  __commonJS,
+  __toESM
+} from "./chunk-ISRV2HNG.js";
+
+// ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path10, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path10);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path10, originalPath, doThrow) => {
+      if (!isString(path10)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path10) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path10)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path10 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path10,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path10, cache, checkUnignored, slices);
+      }
+      checkIgnore(path10) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path10)) {
+          return this.test(path10);
+        }
+        const slices = path10.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path10, false, MODE_CHECK_IGNORE);
+      }
+      _t(path10, cache, checkUnignored, slices) {
+        if (path10 in cache) {
+          return cache[path10];
+        }
+        if (!slices) {
+          slices = path10.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path10] = this._rules.test(path10, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path10] = parent.ignored ? parent : this._rules.test(path10, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path10) {
+        return this._test(path10, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path10) => !this.ignores(path10);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path10) {
+        return this._test(path10, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path10) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// src/index.ts
+import { readFile } from "fs/promises";
+import { Command } from "commander";
+
+// src/commands/config.ts
+import chalk from "chalk";
+
+// src/state.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+function stateDir() {
+  return process.env.AUTOMIGRATE_HOME ?? path.join(os.homedir(), ".automigrate");
+}
+function backupDir(jobId) {
+  return path.join(stateDir(), "backup", jobId);
+}
+function checkpointPath(jobId) {
+  return path.join(stateDir(), "checkpoints", `${jobId}.json`);
+}
+function newJobId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+async function readConfig() {
+  const parsed = await readJson(path.join(stateDir(), "config.json"));
+  return parsed ?? {};
+}
+async function writeConfig(config2) {
+  const filePath = path.join(stateDir(), "config.json");
+  await fs.mkdir(stateDir(), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(config2, null, 2), "utf8");
+  await fs.chmod(filePath, 384);
+}
+async function readJobs() {
+  const parsed = await readJson(path.join(stateDir(), "jobs.json"));
+  return Array.isArray(parsed) ? parsed : [];
+}
+async function saveJob(job) {
+  const jobs = await readJobs();
+  const index = jobs.findIndex((j) => j.id === job.id);
+  if (index === -1) jobs.push(job);
+  else jobs[index] = job;
+  await fs.mkdir(stateDir(), { recursive: true });
+  await fs.writeFile(path.join(stateDir(), "jobs.json"), JSON.stringify(jobs, null, 2), "utf8");
+}
+async function acquireLock(rootPath) {
+  const lockPath = path.join(rootPath, ".automigrate-lock");
+  try {
+    await fs.writeFile(lockPath, String(process.pid), { flag: "wx" });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(
+        `Another migration appears to be running in this directory (${lockPath} exists). Remove the lock file if that migration is no longer active.`
+      );
+    }
+    throw error;
+  }
+}
+async function releaseLock(rootPath) {
+  await fs.rm(path.join(rootPath, ".automigrate-lock"), { force: true });
+}
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/config.ts
+async function setKeyCommand(apiKey) {
+  const config2 = await readConfig();
+  await writeConfig({ ...config2, apiKey });
+  const masked = apiKey.length > 8 ? `${apiKey.slice(0, 4)}\u2026${apiKey.slice(-4)}` : "****";
+  console.log(`${chalk.green("Saved")} API key ${masked} to ${stateDir()}/config.json`);
+}
+
+// src/commands/init.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+
+// ../engine/dist/ingestion/index.js
+var import_ignore = __toESM(require_ignore(), 1);
+import fs2 from "fs/promises";
+import path2 from "path";
+var DEFAULT_IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "vendor",
+  "coverage",
+  // AutoMigrate's own artifacts — a re-run must never re-ingest prior output.
+  "automigrate.config.json",
+  ".automigrate-checkpoint.json",
+  ".automigrate-checkpoint.json.repair-*",
+  ".automigrate-lock",
+  ".automigrateignore",
+  "migrated",
+  "output.patch"
+];
+var IGNORE_FILES = [".gitignore", ".automigrateignore"];
+var DEFAULT_MAX_FILE_SIZE_MB = 5;
+var BINARY_CHECK_BYTES = 8e3;
+function estimateTokens(content) {
+  return Math.ceil(content.length / 4);
+}
+async function readCodebase(dirPath, options = {}) {
+  const rootPath = path2.resolve(dirPath);
+  const ig = (0, import_ignore.default)();
+  ig.add(DEFAULT_IGNORE_PATTERNS);
+  for (const name of IGNORE_FILES) {
+    const content = await readOptionalFile(path2.join(rootPath, name));
+    if (content !== null)
+      ig.add(content);
+  }
+  if (options.ignorePaths !== void 0)
+    ig.add(options.ignorePaths);
+  const files = await collectFiles(rootPath, ig, options);
+  return {
+    rootPath,
+    files,
+    totalLines: files.reduce((sum, f) => sum + f.lines, 0),
+    totalTokens: files.reduce((sum, f) => sum + f.tokens, 0),
+    detectedStack: detectStack(files),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function detectStack(manifest) {
+  const byPath = new Map(manifest.map((f) => [f.relativePath, f]));
+  const packageJson = byPath.get("package.json");
+  if (packageJson !== void 0)
+    return detectNodeStack(packageJson, byPath);
+  const pyproject = byPath.get("pyproject.toml");
+  if (pyproject !== void 0)
+    return detectPythonStack(pyproject, byPath);
+  const goMod = byPath.get("go.mod");
+  if (goMod !== void 0)
+    return detectGoStack(goMod);
+  const pubspec = byPath.get("pubspec.yaml");
+  if (pubspec !== void 0)
+    return detectDartStack(pubspec);
+  const cargo = byPath.get("Cargo.toml");
+  if (cargo !== void 0)
+    return detectRustStack(cargo);
+  const composer = byPath.get("composer.json");
+  if (composer !== void 0)
+    return detectPhpStack(composer);
+  return detectFromExtensions(manifest);
+}
+async function readOptionalFile(filePath) {
+  try {
+    return await fs2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function collectFiles(rootPath, ig, options) {
+  const maxBytes = (options.maxFileSizeMB ?? DEFAULT_MAX_FILE_SIZE_MB) * 1024 * 1024;
+  const includeExtensions = options.includeExtensions?.map(normalizeExtension);
+  const files = [];
+  async function walk(dir) {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const absPath = path2.join(dir, entry.name);
+      const relPath = path2.relative(rootPath, absPath).split(path2.sep).join("/");
+      if (entry.isSymbolicLink())
+        continue;
+      if (entry.isDirectory()) {
+        if (ig.ignores(relPath) || ig.ignores(`${relPath}/`))
+          continue;
+        await walk(absPath);
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (ig.ignores(relPath))
+        continue;
+      const extension = path2.extname(entry.name).toLowerCase();
+      if (includeExtensions !== void 0 && !includeExtensions.includes(extension))
+        continue;
+      const stat = await fs2.stat(absPath);
+      if (stat.size > maxBytes)
+        continue;
+      const buffer = Buffer.from(await fs2.readFile(absPath));
+      if (isBinary(buffer))
+        continue;
+      const content = buffer.toString("utf8");
+      files.push({
+        path: absPath,
+        relativePath: relPath,
+        extension,
+        content,
+        lines: countLines(content),
+        tokens: estimateTokens(content),
+        size: stat.size
+      });
+    }
+  }
+  await walk(rootPath);
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return files;
+}
+function normalizeExtension(ext) {
+  const lower = ext.toLowerCase();
+  return lower.startsWith(".") ? lower : `.${lower}`;
+}
+function countLines(content) {
+  if (content === "")
+    return 0;
+  const segments = content.split("\n").length;
+  return content.endsWith("\n") ? segments - 1 : segments;
+}
+function isBinary(buffer) {
+  return buffer.subarray(0, BINARY_CHECK_BYTES).includes(0);
+}
+var NODE_FRAMEWORK_DEPS = {
+  next: "next.js",
+  react: "react",
+  vue: "vue",
+  "@angular/core": "angular",
+  svelte: "svelte",
+  express: "express",
+  hono: "hono",
+  fastify: "fastify",
+  "@nestjs/core": "nestjs"
+};
+var NODE_BUILD_TOOLS = ["vite", "webpack", "rollup", "esbuild", "tsup", "parcel"];
+var NODE_TEST_FRAMEWORKS = ["vitest", "jest", "mocha", "ava", "jasmine"];
+function detectNodeStack(pkgEntry, byPath) {
+  let pkg2 = {};
+  try {
+    pkg2 = JSON.parse(pkgEntry.content);
+  } catch {
+  }
+  const deps = {
+    ...pkg2.dependencies,
+    ...pkg2.devDependencies
+  };
+  const has = (name) => name in deps;
+  const frameworks = Object.entries(NODE_FRAMEWORK_DEPS).filter(([dep]) => has(dep)).map(([, name]) => name);
+  let packageManager = null;
+  if (typeof pkg2.packageManager === "string") {
+    packageManager = pkg2.packageManager.split("@")[0] ?? null;
+  } else if (byPath.has("pnpm-lock.yaml")) {
+    packageManager = "pnpm";
+  } else if (byPath.has("yarn.lock")) {
+    packageManager = "yarn";
+  } else if (byPath.has("bun.lockb") || byPath.has("bun.lock")) {
+    packageManager = "bun";
+  } else if (byPath.has("package-lock.json")) {
+    packageManager = "npm";
+  }
+  return {
+    primaryLanguage: has("typescript") || byPath.has("tsconfig.json") ? "typescript" : "javascript",
+    frameworks,
+    buildTool: NODE_BUILD_TOOLS.find(has) ?? null,
+    testFramework: NODE_TEST_FRAMEWORKS.find(has) ?? null,
+    packageManager
+  };
+}
+function detectPythonStack(pyproject, byPath) {
+  const content = pyproject.content;
+  let packageManager = "pip";
+  if (content.includes("[tool.poetry]"))
+    packageManager = "poetry";
+  else if (byPath.has("uv.lock") || content.includes("[tool.uv]"))
+    packageManager = "uv";
+  return {
+    primaryLanguage: "python",
+    frameworks: ["django", "flask", "fastapi"].filter((f) => content.includes(f)),
+    buildTool: null,
+    testFramework: content.includes("pytest") ? "pytest" : null,
+    packageManager
+  };
+}
+var GO_FRAMEWORK_MODULES = {
+  "github.com/gin-gonic/gin": "gin",
+  "github.com/labstack/echo": "echo",
+  "github.com/gofiber/fiber": "fiber"
+};
+function detectGoStack(goMod) {
+  const frameworks = Object.entries(GO_FRAMEWORK_MODULES).filter(([module]) => goMod.content.includes(module)).map(([, name]) => name);
+  return {
+    primaryLanguage: "go",
+    frameworks,
+    buildTool: "go",
+    testFramework: "go test",
+    packageManager: "go modules"
+  };
+}
+function detectDartStack(pubspec) {
+  const isFlutter = /\bflutter\s*:/.test(pubspec.content);
+  return {
+    primaryLanguage: "dart",
+    frameworks: isFlutter ? ["flutter"] : [],
+    buildTool: null,
+    testFramework: isFlutter ? "flutter test" : "dart test",
+    packageManager: "pub"
+  };
+}
+var RUST_FRAMEWORK_CRATES = ["axum", "actix-web", "rocket"];
+function detectRustStack(cargo) {
+  return {
+    primaryLanguage: "rust",
+    frameworks: RUST_FRAMEWORK_CRATES.filter((c) => cargo.content.includes(c)),
+    buildTool: "cargo",
+    testFramework: "cargo test",
+    packageManager: "cargo"
+  };
+}
+function detectPhpStack(composer) {
+  let parsed = {};
+  try {
+    parsed = JSON.parse(composer.content);
+  } catch {
+  }
+  const deps = {
+    ...parsed.require,
+    ...parsed["require-dev"]
+  };
+  const depNames = Object.keys(deps);
+  const frameworks = [];
+  if (depNames.includes("laravel/framework"))
+    frameworks.push("laravel");
+  if (depNames.some((d) => d.startsWith("symfony/")))
+    frameworks.push("symfony");
+  return {
+    primaryLanguage: "php",
+    frameworks,
+    buildTool: null,
+    testFramework: depNames.includes("phpunit/phpunit") ? "phpunit" : null,
+    packageManager: "composer"
+  };
+}
+var EXTENSION_LANGUAGES = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".dart": "dart",
+  ".php": "php",
+  ".rb": "ruby",
+  ".java": "java",
+  ".cs": "csharp"
+};
+function detectFromExtensions(manifest) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of manifest) {
+    const language = EXTENSION_LANGUAGES[file.extension];
+    if (language !== void 0)
+      counts.set(language, (counts.get(language) ?? 0) + 1);
+  }
+  let primaryLanguage = "unknown";
+  let best = 0;
+  for (const [language, count] of counts) {
+    if (count > best) {
+      primaryLanguage = language;
+      best = count;
+    }
+  }
+  return {
+    primaryLanguage,
+    frameworks: [],
+    buildTool: null,
+    testFramework: null,
+    packageManager: null
+  };
+}
+
+// ../engine/dist/llm/index.js
+var OPUS_MODEL = "claude-opus-4-8";
+var AnthropicAdapter = class {
+  model;
+  client;
+  constructor(options) {
+    this.model = options.model ?? OPUS_MODEL;
+    this.client = new Anthropic({ apiKey: options.apiKey });
+  }
+  async complete(request) {
+    const stream = this.client.messages.stream({
+      model: this.model,
+      max_tokens: request.maxTokens,
+      system: request.systemPrompt,
+      messages: [{ role: "user", content: request.userPrompt }]
+    });
+    if (request.onText !== void 0)
+      stream.on("text", request.onText);
+    const message = await stream.finalMessage();
+    const text = message.content.map((block) => block.type === "text" ? block.text : "").join("");
+    return {
+      text,
+      inputTokens: message.usage.input_tokens,
+      outputTokens: message.usage.output_tokens,
+      model: message.model
+    };
+  }
+};
+
+// ../engine/dist/planning/index.js
+var PLANNING_MAX_OUTPUT_TOKENS = 8e3;
+var PLANNING_CONTEXT_LIMIT_TOKENS = 8e5;
+var PLANNING_BATCH_OVERLAP_TOKENS = 5e4;
+function planOutputPath(entry) {
+  return entry.outputPath ?? entry.path;
+}
+var PlanningError = class extends Error {
+  rawResponse;
+  constructor(message, rawResponse) {
+    super(message);
+    this.name = "PlanningError";
+    this.rawResponse = rawResponse;
+  }
+};
+async function planMigration(manifest, migrationTarget, apiKey, options = {}) {
+  const adapter = options.adapter ?? new AnthropicAdapter({ apiKey });
+  const limit = options.contextLimitTokens ?? PLANNING_CONTEXT_LIMIT_TOKENS;
+  const overlap = options.overlapTokens ?? PLANNING_BATCH_OVERLAP_TOKENS;
+  const batches = buildBatches(manifest.files, limit, overlap);
+  const systemPrompt = buildSystemPrompt(migrationTarget);
+  const plans = [];
+  for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+    const batch = batches[batchIndex];
+    let charsStreamed = 0;
+    options.onProgress?.({ batchIndex, batchCount: batches.length, charsStreamed });
+    const response = await adapter.complete({
+      systemPrompt,
+      userPrompt: buildUserPrompt(manifest, migrationTarget, batch, batchIndex, batches.length),
+      maxTokens: PLANNING_MAX_OUTPUT_TOKENS,
+      onText: (chunk2) => {
+        charsStreamed += chunk2.length;
+        options.onProgress?.({ batchIndex, batchCount: batches.length, charsStreamed });
+      }
+    });
+    plans.push(parsePlanResponse(response.text, migrationTarget));
+  }
+  return mergePlans(plans, migrationTarget);
+}
+function buildBatches(files, limitTokens, overlapTokens) {
+  const totalTokens = files.reduce((sum, f) => sum + f.tokens, 0);
+  if (totalTokens <= limitTokens || files.length === 0)
+    return [files];
+  const batches = [];
+  let current = [];
+  let currentTokens = 0;
+  let newInCurrent = 0;
+  for (const file of files) {
+    if (newInCurrent > 0 && currentTokens + file.tokens > limitTokens) {
+      batches.push(current);
+      const seed = [];
+      let seedTokens = 0;
+      for (let i = current.length - 1; i >= 0 && seedTokens < overlapTokens; i--) {
+        const overlapFile = current[i];
+        seed.unshift(overlapFile);
+        seedTokens += overlapFile.tokens;
+      }
+      current = seed;
+      currentTokens = seedTokens;
+      newInCurrent = 0;
+    }
+    current.push(file);
+    currentTokens += file.tokens;
+    newInCurrent++;
+  }
+  batches.push(current);
+  return batches;
+}
+function buildSystemPrompt(target) {
+  return [
+    `You are a senior software engineer producing a migration plan for a ${target.type} migration from "${target.from}" to "${target.to}".`,
+    "You will receive the full contents of a codebase. Read every file and trace cross-file dependencies before planning.",
+    "",
+    "Respond with a single raw JSON object and nothing else \u2014 no markdown fences, no preamble, no commentary.",
+    "The JSON object must have exactly these fields:",
+    '- "summary": string \u2014 one-paragraph description of the migration approach',
+    `- "migrationTarget": { "from": "${target.from}", "to": "${target.to}", "type": "${target.type}" }`,
+    '- "estimatedEffort": "hours" | "days" | "weeks"',
+    '- "riskLevel": "low" | "medium" | "high"',
+    '- "filesToModify": array of { "path": string, "outputPath": string, "complexity": "low" | "medium" | "high", "description": string }',
+    '- "filesToCreate": array of { "path": string, "complexity": "low" | "medium" | "high", "description": string } \u2014 new config files, type definition files, etc.',
+    '- "filesToDelete": array of string paths \u2014 obsolete configs, deprecated files',
+    "",
+    "Path rules for filesToModify:",
+    '- "path" is always the existing source file. "outputPath" is where the transformed file lands.',
+    '- A rename (e.g. converting src/app.js to src/app.ts) is ONE filesToModify entry with "path" set to the source and "outputPath" set to the new name. Do NOT also list the source in filesToDelete and do NOT list the new name in filesToCreate.',
+    '- For in-place modifications, set "outputPath" equal to "path" (or omit it).',
+    "- filesToDelete is only for files genuinely removed with no replacement.",
+    '- "dependencyChanges": array of { "name": string, "action": "add" | "remove" | "update", "currentVersion": string | null, "targetVersion": string | null }',
+    '- "breakingChanges": array of { "description": string, "severity": "low" | "medium" | "high", "affectedFiles": string[] }',
+    '- "tokenBudgetEstimate": number \u2014 estimated output tokens the execution phase will need',
+    "",
+    "Order filesToModify so that files others depend on come first. Flag every breaking change you can identify, including test coverage gaps."
+  ].join("\n");
+}
+function buildUserPrompt(manifest, target, batch, batchIndex, batchCount) {
+  const header = [
+    `Migration target: ${target.from} -> ${target.to} (${target.type})`,
+    `Detected stack: ${JSON.stringify(manifest.detectedStack)}`,
+    `Codebase: ${manifest.files.length} files, ${manifest.totalLines} lines, ~${manifest.totalTokens} tokens.`
+  ];
+  if (batchCount > 1) {
+    header.push(`NOTE: the codebase exceeds the context budget, so it is split into ${batchCount} overlapping batches. This is batch ${batchIndex + 1} of ${batchCount} (${batch.length} files). Plan only for the files in this batch; overlapping files from the previous batch are included for cross-file context.`);
+  }
+  const files = batch.map((f) => `<file path="${f.relativePath}">
+${f.content}
+</file>`);
+  return [...header, "", ...files].join("\n");
+}
+function parsePlanResponse(text, migrationTarget) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end <= start) {
+    throw new PlanningError("No JSON object found in planning response", text);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text.slice(start, end + 1));
+  } catch (error) {
+    throw new PlanningError(`Planning response is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, text);
+  }
+  return normalizePlan(raw, migrationTarget, text);
+}
+function normalizePlan(raw, migrationTarget, rawText) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new PlanningError("Planning response JSON is not an object", rawText);
+  }
+  const obj = raw;
+  const estimatedEffort = obj.estimatedEffort;
+  if (estimatedEffort !== "hours" && estimatedEffort !== "days" && estimatedEffort !== "weeks") {
+    throw new PlanningError(`Invalid estimatedEffort: ${JSON.stringify(estimatedEffort)}`, rawText);
+  }
+  const riskLevel = obj.riskLevel;
+  if (riskLevel !== "low" && riskLevel !== "medium" && riskLevel !== "high") {
+    throw new PlanningError(`Invalid riskLevel: ${JSON.stringify(riskLevel)}`, rawText);
+  }
+  return sanitizePlan({
+    summary: typeof obj.summary === "string" ? obj.summary : "",
+    migrationTarget,
+    estimatedEffort,
+    riskLevel,
+    filesToModify: normalizeFilePlanEntries(obj.filesToModify),
+    filesToCreate: normalizeFilePlanEntries(obj.filesToCreate),
+    filesToDelete: asStringArray(obj.filesToDelete),
+    dependencyChanges: normalizeDependencyChanges(obj.dependencyChanges),
+    breakingChanges: normalizeBreakingChanges(obj.breakingChanges),
+    tokenBudgetEstimate: typeof obj.tokenBudgetEstimate === "number" && Number.isFinite(obj.tokenBudgetEstimate) ? obj.tokenBudgetEstimate : 0
+  });
+}
+function sanitizePlan(plan) {
+  const modifySources = new Set(plan.filesToModify.map((e) => e.path));
+  const modifyOutputs = new Set(plan.filesToModify.map(planOutputPath));
+  return {
+    ...plan,
+    filesToCreate: plan.filesToCreate.filter((e) => !modifyOutputs.has(e.path) && !modifySources.has(e.path)),
+    filesToDelete: plan.filesToDelete.filter((p) => !modifySources.has(p) && !modifyOutputs.has(p))
+  };
+}
+function isComplexity(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function asStringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string");
+}
+function normalizeFilePlanEntries(value) {
+  if (!Array.isArray(value))
+    return [];
+  const entries = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const record = item;
+    if (typeof record.path !== "string" || record.path === "")
+      continue;
+    entries.push({
+      path: record.path,
+      outputPath: typeof record.outputPath === "string" && record.outputPath !== "" ? record.outputPath : record.path,
+      complexity: isComplexity(record.complexity) ? record.complexity : "medium",
+      description: typeof record.description === "string" ? record.description : ""
+    });
+  }
+  return entries;
+}
+function normalizeDependencyChanges(value) {
+  if (!Array.isArray(value))
+    return [];
+  const changes = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const record = item;
+    if (typeof record.name !== "string" || record.name === "")
+      continue;
+    const action = record.action;
+    if (action !== "add" && action !== "remove" && action !== "update")
+      continue;
+    changes.push({
+      name: record.name,
+      action,
+      currentVersion: typeof record.currentVersion === "string" ? record.currentVersion : null,
+      targetVersion: typeof record.targetVersion === "string" ? record.targetVersion : null
+    });
+  }
+  return changes;
+}
+function normalizeBreakingChanges(value) {
+  if (!Array.isArray(value))
+    return [];
+  const changes = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const record = item;
+    if (typeof record.description !== "string" || record.description === "")
+      continue;
+    changes.push({
+      description: record.description,
+      severity: isComplexity(record.severity) ? record.severity : "medium",
+      affectedFiles: asStringArray(record.affectedFiles)
+    });
+  }
+  return changes;
+}
+var COMPLEXITY_RANK = { low: 0, medium: 1, high: 2 };
+var EFFORT_RANK = {
+  hours: 0,
+  days: 1,
+  weeks: 2
+};
+function mergePlans(plans, migrationTarget) {
+  const first = plans[0];
+  if (first === void 0) {
+    throw new PlanningError("No plans produced", "");
+  }
+  if (plans.length === 1)
+    return first;
+  const modify = /* @__PURE__ */ new Map();
+  const create = /* @__PURE__ */ new Map();
+  const dependencyChanges = /* @__PURE__ */ new Map();
+  const breakingChanges = /* @__PURE__ */ new Map();
+  const filesToDelete = /* @__PURE__ */ new Set();
+  let estimatedEffort = "hours";
+  let riskLevel = "low";
+  let tokenBudgetEstimate = 0;
+  for (const plan of plans) {
+    for (const entry of plan.filesToModify) {
+      const existing = modify.get(entry.path);
+      if (existing === void 0 || COMPLEXITY_RANK[entry.complexity] > COMPLEXITY_RANK[existing.complexity]) {
+        modify.set(entry.path, entry);
+      }
+    }
+    for (const entry of plan.filesToCreate) {
+      if (!create.has(entry.path))
+        create.set(entry.path, entry);
+    }
+    for (const file of plan.filesToDelete)
+      filesToDelete.add(file);
+    for (const change of plan.dependencyChanges) {
+      dependencyChanges.set(`${change.name}:${change.action}`, change);
+    }
+    for (const change of plan.breakingChanges) {
+      breakingChanges.set(change.description, change);
+    }
+    if (EFFORT_RANK[plan.estimatedEffort] > EFFORT_RANK[estimatedEffort]) {
+      estimatedEffort = plan.estimatedEffort;
+    }
+    if (COMPLEXITY_RANK[plan.riskLevel] > COMPLEXITY_RANK[riskLevel]) {
+      riskLevel = plan.riskLevel;
+    }
+    tokenBudgetEstimate += plan.tokenBudgetEstimate;
+  }
+  return sanitizePlan({
+    summary: plans.map((p, i) => `[Batch ${i + 1}/${plans.length}] ${p.summary}`).join("\n"),
+    migrationTarget,
+    estimatedEffort,
+    riskLevel,
+    filesToModify: [...modify.values()],
+    filesToCreate: [...create.values()],
+    filesToDelete: [...filesToDelete],
+    dependencyChanges: [...dependencyChanges.values()],
+    breakingChanges: [...breakingChanges.values()],
+    tokenBudgetEstimate
+  });
+}
+
+// ../engine/dist/execution/index.js
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path10.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path10.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../node_modules/.pnpm/diff@9.0.0/node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// ../engine/dist/execution/index.js
+var EXECUTION_MAX_OUTPUT_TOKENS = 64e3;
+var MEDIUM_BATCH_SIZE = 5;
+var LOW_BATCH_SIZE = 10;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_BASE_DELAY_MS = 1e3;
+var ExecutionError = class extends Error {
+  checkpointPath;
+  constructor(message, checkpointPath2) {
+    super(message);
+    this.name = "ExecutionError";
+    this.checkpointPath = checkpointPath2;
+  }
+};
+async function executeMigration(manifest, plan, apiKey, onProgress, options = {}) {
+  const outputDir = options.outputDir ?? path3.join(manifest.rootPath, "migrated");
+  const checkpointPath2 = options.checkpointPath ?? path3.join(manifest.rootPath, ".automigrate-checkpoint.json");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const checkpoint = {
+    version: 1,
+    rootPath: manifest.rootPath,
+    outputDir,
+    plan,
+    batchStatus: buildExecutionBatches(plan).map(() => "pending"),
+    completedFiles: [],
+    failedFiles: [],
+    filesModified: 0,
+    filesCreated: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    tokensUsed: 0,
+    createdAt: now,
+    updatedAt: now
+  };
+  return runExecution(manifest, checkpoint, checkpointPath2, apiKey, onProgress, options);
+}
+async function resumeMigration(checkpointPath2, manifest, apiKey, onProgress, options = {}) {
+  const checkpoint = JSON.parse(await fs3.readFile(checkpointPath2, "utf8"));
+  return runExecution(manifest, checkpoint, checkpointPath2, apiKey, onProgress, options);
+}
+function buildExecutionBatches(plan) {
+  const entries = [
+    ...plan.filesToModify.map((entry) => ({ plan: entry, action: "modify" })),
+    ...plan.filesToCreate.map((entry) => ({ plan: entry, action: "create" }))
+  ];
+  const high = entries.filter((e) => e.plan.complexity === "high");
+  const medium = entries.filter((e) => e.plan.complexity === "medium");
+  const low = entries.filter((e) => e.plan.complexity === "low");
+  const batches = [];
+  for (const entry of high)
+    batches.push({ entries: [entry] });
+  for (const group of chunk(medium, MEDIUM_BATCH_SIZE))
+    batches.push({ entries: group });
+  for (const group of chunk(low, LOW_BATCH_SIZE))
+    batches.push({ entries: group });
+  return batches;
+}
+function chunk(items, size) {
+  const groups = [];
+  for (let i = 0; i < items.length; i += size)
+    groups.push(items.slice(i, i + size));
+  return groups;
+}
+function parseTransformedFiles(text) {
+  const blocks = /* @__PURE__ */ new Map();
+  const pattern = /<transformed_file path="([^"]+)">([\s\S]*?)<\/transformed_file>/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    let content = match[2];
+    if (content.startsWith("\n"))
+      content = content.slice(1);
+    blocks.set(match[1], content);
+  }
+  return blocks;
+}
+async function runExecution(manifest, checkpoint, checkpointPath2, apiKey, onProgress, options) {
+  const adapter = options.adapter ?? new AnthropicAdapter({ apiKey });
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const retryBaseDelayMs = options.retryBaseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS;
+  const maxOutputTokens = options.maxOutputTokens ?? EXECUTION_MAX_OUTPUT_TOKENS;
+  const batches = buildExecutionBatches(checkpoint.plan);
+  const filesTotal = batches.reduce((sum, b) => sum + b.entries.length, 0);
+  const originals = new Map(manifest.files.map((f) => [f.relativePath, f]));
+  const completedSet = new Set(checkpoint.completedFiles);
+  const systemPrompt = buildSystemPrompt2(checkpoint.plan);
+  const emit = (stage, currentFile) => {
+    onProgress({
+      stage,
+      currentFile,
+      filesComplete: checkpoint.completedFiles.length,
+      filesTotal,
+      tokensUsed: checkpoint.tokensUsed
+    });
+  };
+  emit("preparing", null);
+  try {
+    for (let i = 0; i < batches.length; i++) {
+      if (checkpoint.batchStatus[i] === "complete")
+        continue;
+      const batch = batches[i];
+      emit("transforming", batch.entries[0].plan.path);
+      const response = await completeWithRetry(adapter, {
+        systemPrompt,
+        userPrompt: buildBatchPrompt(checkpoint.plan, batch, originals),
+        maxTokens: maxOutputTokens
+      }, maxRetries, retryBaseDelayMs);
+      checkpoint.tokensUsed += response.inputTokens + response.outputTokens;
+      const blocks = parseTransformedFiles(response.text);
+      for (const entry of batch.entries) {
+        if (completedSet.has(entry.plan.path))
+          continue;
+        const outputPath = planOutputPath(entry.plan);
+        const content = blocks.get(outputPath) ?? blocks.get(entry.plan.path);
+        const targetPath = content === void 0 ? null : safeOutputPath(checkpoint.outputDir, outputPath);
+        if (content === void 0 || targetPath === null) {
+          if (!checkpoint.failedFiles.includes(entry.plan.path)) {
+            checkpoint.failedFiles.push(entry.plan.path);
+          }
+          continue;
+        }
+        await fs3.mkdir(path3.dirname(targetPath), { recursive: true });
+        await fs3.writeFile(targetPath, content, "utf8");
+        const original = originals.get(entry.plan.path);
+        const { added, removed } = countDiffLines(original?.content ?? "", content);
+        checkpoint.linesAdded += added;
+        checkpoint.linesRemoved += removed;
+        if (entry.action === "modify")
+          checkpoint.filesModified++;
+        else
+          checkpoint.filesCreated++;
+        checkpoint.completedFiles.push(entry.plan.path);
+        completedSet.add(entry.plan.path);
+        checkpoint.failedFiles = checkpoint.failedFiles.filter((p) => p !== entry.plan.path);
+        emit("writing", entry.plan.path);
+      }
+      checkpoint.batchStatus[i] = "complete";
+      await saveCheckpoint(checkpointPath2, checkpoint);
+    }
+  } catch (error) {
+    await saveCheckpoint(checkpointPath2, checkpoint);
+    emit("failed", null);
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ExecutionError(`Migration execution failed (progress saved to checkpoint): ${message}`, checkpointPath2);
+  }
+  emit("complete", null);
+  const deletedLines = checkpoint.plan.filesToDelete.reduce((sum, filePath) => sum + (originals.get(filePath)?.lines ?? 0), 0);
+  return {
+    filesModified: checkpoint.filesModified,
+    filesCreated: checkpoint.filesCreated,
+    filesDeleted: checkpoint.plan.filesToDelete.length,
+    linesAdded: checkpoint.linesAdded,
+    linesRemoved: checkpoint.linesRemoved + deletedLines,
+    tokensUsed: checkpoint.tokensUsed,
+    failedFiles: [...checkpoint.failedFiles],
+    checkpointPath: checkpointPath2,
+    outputDir: checkpoint.outputDir
+  };
+}
+function buildSystemPrompt2(plan) {
+  const { from, to, type } = plan.migrationTarget;
+  return [
+    `You are a senior software engineer executing an approved migration plan: a ${type} migration from "${from}" to "${to}".`,
+    "Transform each requested file completely and return EVERY requested file in this exact format:",
+    '<transformed_file path="exact/requested/OUTPUT/path">',
+    "...full transformed file content...",
+    "</transformed_file>",
+    "",
+    "Rules:",
+    '- Return every requested file exactly once. Each file request states "read from <source path>, return as <output path>" \u2014 always use the OUTPUT path in the transformed_file tag, even when the migration renames the file.',
+    '- Output the COMPLETE file content \u2014 no truncation, no placeholders, no "rest of file unchanged" comments.',
+    "- No markdown fences and no commentary outside the transformed_file tags.",
+    "- Preserve behavior unless the migration target requires changing it.",
+    "- Keep types, imports, and naming consistent across all files in this batch and with the migration plan."
+  ].join("\n");
+}
+function buildBatchPrompt(plan, batch, originals) {
+  const lines = [
+    `Migration plan summary:
+${plan.summary}`,
+    `Planned dependency changes: ${JSON.stringify(plan.dependencyChanges)}`,
+    "",
+    "Files to transform in this batch:"
+  ];
+  for (const entry of batch.entries) {
+    const outputPath = planOutputPath(entry.plan);
+    const action = entry.action === "create" ? "CREATE new file" : outputPath === entry.plan.path ? "MODIFY" : "MODIFY and RENAME";
+    lines.push(`- read from "${entry.plan.path}", return as "${outputPath}" [${action}, complexity: ${entry.plan.complexity}] ${entry.plan.description}`);
+  }
+  lines.push("", "Original file contents:");
+  for (const entry of batch.entries) {
+    if (entry.action === "create") {
+      lines.push(`<file path="${entry.plan.path}">
+(new file \u2014 no original content; create it per the plan description)
+</file>`);
+      continue;
+    }
+    const original = originals.get(entry.plan.path);
+    lines.push(`<file path="${entry.plan.path}">
+${original?.content ?? ""}
+</file>`);
+  }
+  return lines.join("\n");
+}
+async function completeWithRetry(adapter, request, maxRetries, baseDelayMs) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0)
+      await sleep(baseDelayMs * 2 ** (attempt - 1));
+    try {
+      return await adapter.complete(request);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeOutputPath(outputDir, relPath) {
+  const root = path3.resolve(outputDir);
+  const resolved = path3.resolve(root, relPath);
+  return resolved.startsWith(root + path3.sep) ? resolved : null;
+}
+function countDiffLines(oldContent, newContent) {
+  let added = 0;
+  let removed = 0;
+  for (const part of diffLines(oldContent, newContent)) {
+    if (part.added)
+      added += part.count ?? 0;
+    else if (part.removed)
+      removed += part.count ?? 0;
+  }
+  return { added, removed };
+}
+async function saveCheckpoint(checkpointPath2, checkpoint) {
+  checkpoint.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs3.mkdir(path3.dirname(checkpointPath2), { recursive: true });
+  await fs3.writeFile(checkpointPath2, JSON.stringify(checkpoint, null, 2), "utf8");
+}
+
+// ../engine/dist/verification/index.js
+import { spawn } from "child_process";
+import fs4 from "fs/promises";
+import path4 from "path";
+var VERIFICATION_MAX_OUTPUT_TOKENS = 4e3;
+var DEFAULT_SELF_REPAIR_THRESHOLD = 0.9;
+var DEFAULT_MAX_SELF_REPAIR_ATTEMPTS = 2;
+var DEFAULT_MAX_REVIEW_FILES = 20;
+var COMPILE_FAIL_CONFIDENCE_CAP = 0.3;
+var TEST_OUTPUT_EXCERPT_CHARS = 4e3;
+var COMMAND_OUTPUT_EXCERPT_CHARS = 600;
+async function verifyMigration(originalDir, migratedDir, plan, executionResult, apiKey, options = {}) {
+  const adapter = options.adapter ?? new AnthropicAdapter({ apiKey });
+  const runCommand2 = options.commandRunner ?? defaultCommandRunner(options.commandTimeoutMs);
+  const selfRepairEnabled = options.selfRepair ?? true;
+  const threshold = options.selfRepairThreshold ?? DEFAULT_SELF_REPAIR_THRESHOLD;
+  const maxAttempts = options.maxSelfRepairAttempts ?? DEFAULT_MAX_SELF_REPAIR_ATTEMPTS;
+  const setup = await detectTestSetup(migratedDir);
+  let testPassRate = null;
+  let testOutput = "";
+  let testCommand = null;
+  if (setup !== null) {
+    testCommand = [setup.testCommand[0], ...setup.testCommand[1]].join(" ");
+    if (setup.installCommand !== null && options.skipInstall !== true) {
+      await runCommand2(setup.installCommand[0], setup.installCommand[1], migratedDir);
+    }
+    ({ testPassRate, testOutput } = await runTests(setup, migratedDir, runCommand2));
+  }
+  let selfRepairAttempts = 0;
+  let failedFiles = executionResult.failedFiles;
+  while (selfRepairEnabled && options.manifest !== void 0 && failedFiles.length > 0 && testPassRate !== null && testPassRate < threshold && selfRepairAttempts < maxAttempts && setup !== null) {
+    selfRepairAttempts++;
+    const repairResult = await repairFailedFiles(options.manifest, plan, failedFiles, executionResult, apiKey, adapter, selfRepairAttempts);
+    failedFiles = repairResult.failedFiles;
+    ({ testPassRate, testOutput } = await runTests(setup, migratedDir, runCommand2));
+  }
+  const descriptor = staticCheckForTarget(plan.migrationTarget.to);
+  const installedForTests = setup?.installCommand !== null && setup !== null;
+  let compileCheck = descriptor === null ? {
+    ran: false,
+    ok: false,
+    errors: [],
+    skippedReason: `no static check registered for target "${plan.migrationTarget.to}"`
+  } : await runStaticCheck(migratedDir, descriptor, runCommand2, {
+    skipInstall: options.skipInstall === true || installedForTests
+  });
+  let compileRepairs = 0;
+  while (selfRepairEnabled && options.manifest !== void 0 && descriptor !== null && compileCheck.ran && !compileCheck.ok && selfRepairAttempts < maxAttempts) {
+    const repairTargets = mapCompileErrorsToEntries(compileCheck.errors, plan);
+    if (repairTargets.size === 0)
+      break;
+    selfRepairAttempts++;
+    compileRepairs++;
+    await repairCompileErrors(options.manifest, plan, repairTargets, executionResult, apiKey, adapter, selfRepairAttempts);
+    compileCheck = await runStaticCheck(migratedDir, descriptor, runCommand2, {
+      skipInstall: true
+    });
+  }
+  if (compileRepairs > 0 && setup !== null) {
+    ({ testPassRate, testOutput } = await runTests(setup, migratedDir, runCommand2));
+  }
+  const review = await selfReview(originalDir, migratedDir, plan, `${testOutput}
+
+${describeCompileCheck(compileCheck)}`.trim(), adapter, options.maxReviewFiles ?? DEFAULT_MAX_REVIEW_FILES);
+  const diffStats = await computeDiffStats(originalDir, migratedDir, plan);
+  let confidenceScore = review.confidenceScore;
+  const flaggedIssues = [...review.issues];
+  if (compileCheck.ran && !compileCheck.ok) {
+    confidenceScore = Math.min(confidenceScore, COMPILE_FAIL_CONFIDENCE_CAP);
+    const files = [...new Set(compileCheck.errors.map((e) => e.file).filter((f) => f !== ""))];
+    flaggedIssues.unshift({
+      description: `Output does not compile: ${compileCheck.errors.length} compiler error(s)` + (selfRepairAttempts > 0 ? ` remain after ${selfRepairAttempts} self-repair attempt(s)` : "") + `. ${compileCheck.errors.map(formatCompileError).join("; ")}`,
+      severity: "high",
+      category: "conversion",
+      affectedFiles: files
+    });
+  } else if (!compileCheck.ran) {
+    flaggedIssues.push({
+      description: `Objective compile check unavailable (${compileCheck.skippedReason ?? "unknown reason"}); confidence rests on model self-review only \u2014 manual verification recommended.`,
+      severity: "medium",
+      category: "environment",
+      affectedFiles: []
+    });
+  }
+  return {
+    testPassRate,
+    testOutput,
+    testCommand,
+    confidenceScore,
+    compileCheck,
+    flaggedIssues,
+    diffStats,
+    selfRepairAttempts,
+    reportGeneratedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function detectTestSetup(dir) {
+  const pkgContent = await readOptional(path4.join(dir, "package.json"));
+  if (pkgContent !== null) {
+    let pkg2 = {};
+    try {
+      pkg2 = JSON.parse(pkgContent);
+    } catch {
+      return null;
+    }
+    const scripts = pkg2.scripts ?? {};
+    const testScript = typeof scripts.test === "string" ? scripts.test : "";
+    if (testScript === "" || testScript.includes("no test specified"))
+      return null;
+    const pm = await detectNodePackageManager(dir);
+    return {
+      installCommand: [pm, ["install"]],
+      testCommand: [pm, ["test"]],
+      label: "node"
+    };
+  }
+  const pyproject = await readOptional(path4.join(dir, "pyproject.toml"));
+  const hasPytest = pyproject !== null && pyproject.includes("pytest") || await exists(path4.join(dir, "pytest.ini")) || await exists(path4.join(dir, "conftest.py"));
+  if (hasPytest) {
+    return { installCommand: null, testCommand: ["pytest", []], label: "python" };
+  }
+  if (await exists(path4.join(dir, "pubspec.yaml"))) {
+    return { installCommand: null, testCommand: ["flutter", ["test"]], label: "flutter" };
+  }
+  if (await exists(path4.join(dir, "go.mod"))) {
+    return { installCommand: null, testCommand: ["go", ["test", "./..."]], label: "go" };
+  }
+  if (await exists(path4.join(dir, "Cargo.toml"))) {
+    return { installCommand: null, testCommand: ["cargo", ["test"]], label: "rust" };
+  }
+  return null;
+}
+async function detectNodePackageManager(dir) {
+  if (await exists(path4.join(dir, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (await exists(path4.join(dir, "yarn.lock")))
+    return "yarn";
+  return "npm";
+}
+var STATIC_CHECKS = {
+  typescript: {
+    installCmd: ["npm", ["install"]],
+    checkCmd: ["npx", ["tsc", "--noEmit"]],
+    parse: parseTscOutput
+  }
+};
+function staticCheckForTarget(to) {
+  return STATIC_CHECKS[to.trim().toLowerCase()] ?? null;
+}
+function parseTscOutput(output) {
+  const located = /^(.+?)[(:](\d+)[,:](\d+)\)?\s*[-:]?\s*error\s+(TS\d+):\s*(.+)$/;
+  const bare = /^error\s+(TS\d+):\s*(.+)$/;
+  const errors = [];
+  for (const rawLine of output.split("\n")) {
+    const line = rawLine.trim();
+    const withLocation = located.exec(line);
+    if (withLocation !== null) {
+      errors.push({
+        file: withLocation[1].trim(),
+        line: Number(withLocation[2]),
+        col: Number(withLocation[3]),
+        code: withLocation[4],
+        message: withLocation[5].trim()
+      });
+      continue;
+    }
+    const withoutLocation = bare.exec(line);
+    if (withoutLocation !== null) {
+      errors.push({ file: "", code: withoutLocation[1], message: withoutLocation[2].trim() });
+    }
+  }
+  return errors;
+}
+function formatCompileError(error) {
+  const location = error.file === "" ? "" : `${error.file}${error.line === void 0 ? "" : `:${error.line}:${error.col ?? 0}`} `;
+  return `${location}${error.code === void 0 ? "" : `${error.code}: `}${error.message}`;
+}
+async function runStaticCheck(migratedDir, descriptor, runCommand2, options = {}) {
+  const skipped = (skippedReason) => ({
+    ran: false,
+    ok: false,
+    errors: [],
+    skippedReason
+  });
+  try {
+    if (descriptor.installCmd !== void 0 && options.skipInstall !== true && await exists(path4.join(migratedDir, "package.json"))) {
+      const pm = await detectNodePackageManager(migratedDir);
+      const install = await runCommand2(pm, descriptor.installCmd[1], migratedDir);
+      if (install.exitCode !== 0) {
+        return skipped(`dependency install failed (${pm} install exit ${install.exitCode}): ${excerpt(install.stderr || install.stdout)}`);
+      }
+    }
+    const result = await runCommand2(descriptor.checkCmd[0], descriptor.checkCmd[1], migratedDir);
+    if (result.exitCode === 0)
+      return { ran: true, ok: true, errors: [] };
+    const output = `${result.stdout}
+${result.stderr}`;
+    const errors = descriptor.parse(output);
+    if (errors.length === 0) {
+      return skipped(`check command could not run (${descriptor.checkCmd[0]} exit ${result.exitCode}): ${excerpt(result.stderr || result.stdout)}`);
+    }
+    return { ran: true, ok: false, errors };
+  } catch (error) {
+    return skipped(`toolchain unavailable: ${excerpt(String(error))}`);
+  }
+}
+function excerpt(text) {
+  const trimmed = text.trim();
+  return trimmed.length <= COMMAND_OUTPUT_EXCERPT_CHARS ? trimmed : `${trimmed.slice(0, COMMAND_OUTPUT_EXCERPT_CHARS)}\u2026`;
+}
+function describeCompileCheck(check) {
+  if (!check.ran)
+    return `Compile check skipped: ${check.skippedReason ?? "unavailable"}`;
+  if (check.ok)
+    return "Compile check: passed (output compiles cleanly).";
+  return `Compile check FAILED with ${check.errors.length} error(s):
+${check.errors.map(formatCompileError).join("\n")}`;
+}
+function mapCompileErrorsToEntries(errors, plan) {
+  const byOutputPath = /* @__PURE__ */ new Map();
+  for (const entry of [...plan.filesToModify, ...plan.filesToCreate]) {
+    byOutputPath.set(normalizeRelPath(planOutputPath(entry)), entry);
+  }
+  const targets = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    if (error.file === "")
+      continue;
+    const entry = byOutputPath.get(normalizeRelPath(error.file));
+    if (entry === void 0)
+      continue;
+    const existing = targets.get(entry.path);
+    if (existing === void 0)
+      targets.set(entry.path, { entry, errors: [error] });
+    else
+      existing.errors.push(error);
+  }
+  return targets;
+}
+function normalizeRelPath(relPath) {
+  return relPath.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+var REPAIR_CONTEXT_MAX_IMPORTS = 8;
+var REPAIR_CONTEXT_FILE_MAX_CHARS = 12e3;
+var RESOLVE_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+function parseImportSpecifiers(source) {
+  const patterns = [
+    /\b(?:import|export)\b[^'"`;()]*?\bfrom\s*['"]([^'"]+)['"]/g,
+    /\bimport\s*['"]([^'"]+)['"]/g,
+    /\b(?:require|import)\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+  ];
+  const specifiers = [];
+  for (const pattern of patterns) {
+    for (const match of source.matchAll(pattern)) {
+      if (!specifiers.includes(match[1]))
+        specifiers.push(match[1]);
+    }
+  }
+  return specifiers;
+}
+function resolveRelativeImport(fromRelPath, specifier, knownPaths) {
+  if (!specifier.startsWith("."))
+    return null;
+  const base = path4.posix.normalize(path4.posix.join(path4.posix.dirname(normalizeRelPath(fromRelPath)), specifier)).replace(/^\.\//, "");
+  for (const ext of RESOLVE_EXTENSIONS) {
+    if (knownPaths.has(base + ext))
+      return base + ext;
+  }
+  for (const ext of RESOLVE_EXTENSIONS.slice(1)) {
+    if (knownPaths.has(`${base}/index${ext}`))
+      return `${base}/index${ext}`;
+  }
+  const tsForJs = base.replace(/\.([mc]?)js$/, ".$1ts");
+  if (tsForJs !== base && knownPaths.has(tsForJs))
+    return tsForJs;
+  return null;
+}
+async function collectRepairContext(manifest, plan, targets, migratedDir) {
+  const bySourcePath = new Map(manifest.files.map((f) => [normalizeRelPath(f.relativePath), f]));
+  const knownPaths = new Set(bySourcePath.keys());
+  const entriesBySource = /* @__PURE__ */ new Map();
+  for (const entry of [...plan.filesToModify, ...plan.filesToCreate]) {
+    entriesBySource.set(normalizeRelPath(entry.path), entry);
+  }
+  const targetPaths = new Set([...targets.keys()].map(normalizeRelPath));
+  const blocks = [];
+  const included = /* @__PURE__ */ new Set();
+  for (const sourcePath of targets.keys()) {
+    const file = bySourcePath.get(normalizeRelPath(sourcePath));
+    if (file === void 0)
+      continue;
+    let count = 0;
+    for (const specifier of parseImportSpecifiers(file.content)) {
+      if (count >= REPAIR_CONTEXT_MAX_IMPORTS)
+        break;
+      const resolved = resolveRelativeImport(file.relativePath, specifier, knownPaths);
+      if (resolved === null || targetPaths.has(resolved) || included.has(resolved))
+        continue;
+      const importedEntry = entriesBySource.get(resolved);
+      const migratedRelPath = importedEntry === void 0 ? resolved : normalizeRelPath(planOutputPath(importedEntry));
+      const migrated = await readOptional(path4.join(migratedDir, migratedRelPath));
+      const content = migrated ?? bySourcePath.get(resolved).content;
+      const displayPath = migrated === null ? resolved : migratedRelPath;
+      included.add(resolved);
+      count++;
+      const body = content.length <= REPAIR_CONTEXT_FILE_MAX_CHARS ? content : `${content.slice(0, REPAIR_CONTEXT_FILE_MAX_CHARS)}
+\u2026 (truncated)`;
+      blocks.push(`<context_file path="${displayPath}" imported_by="${sourcePath}">
+${body}
+</context_file>`);
+    }
+  }
+  if (blocks.length === 0)
+    return "";
+  return [
+    "",
+    "",
+    "READ-ONLY CONTEXT \u2014 files directly imported by the file(s) being repaired, as they exist in the migrated output. Do NOT return these files; they are not part of this batch. Use them to match imported declarations and signatures EXACTLY. When a compiler error involves a symbol imported from one of these files, fix the CALL SITE in the file you are repairing so it satisfies the imported signature as shown (for example, narrow an unknown value with a typeof check before passing it).",
+    ...blocks
+  ].join("\n");
+}
+async function repairCompileErrors(manifest, plan, targets, executionResult, apiKey, adapter, attempt) {
+  const annotate = (entry) => {
+    const target = targets.get(entry.path);
+    if (target === void 0)
+      return entry;
+    return {
+      ...entry,
+      description: `${entry.description} \u2014 REPAIR: the previous transformation of this file does not compile. Fix these exact compiler errors: ${target.errors.map(formatCompileError).join("; ")}`
+    };
+  };
+  const crossFileContext = await collectRepairContext(manifest, plan, targets, executionResult.outputDir);
+  const repairPlan = {
+    ...plan,
+    summary: `${plan.summary}
+
+REPAIR PASS ${attempt}: a previous transformation produced code that fails to compile. Re-transform the listed files, fixing the compiler errors given per file.${crossFileContext}`,
+    filesToModify: plan.filesToModify.filter((f) => targets.has(f.path)).map(annotate),
+    filesToCreate: plan.filesToCreate.filter((f) => targets.has(f.path)).map(annotate),
+    filesToDelete: []
+  };
+  return executeMigration(manifest, repairPlan, apiKey, () => {
+  }, {
+    adapter,
+    outputDir: executionResult.outputDir,
+    checkpointPath: `${executionResult.checkpointPath}.compile-repair-${attempt}`
+  });
+}
+function parseTestOutput(output) {
+  const testsLine = output.split("\n").find((line) => /^\s*Tests[:\s]/.test(line));
+  const source = testsLine ?? output;
+  const passedMatch = /(\d+)\s+pass(?:ed|ing)?/i.exec(source);
+  const failedMatch = /(\d+)\s+fail(?:ed|ing)?/i.exec(source);
+  if (passedMatch === null && failedMatch === null)
+    return null;
+  return {
+    passed: passedMatch === null ? 0 : Number(passedMatch[1]),
+    failed: failedMatch === null ? 0 : Number(failedMatch[1])
+  };
+}
+function categorizeIssue(description) {
+  const environmentPattern = /cannot find module|module not found|TS2307|TS2591|not installed|missing dependenc|ERR_MODULE_NOT_FOUND|command not found|ENOENT|types? package/i;
+  return environmentPattern.test(description) ? "environment" : "conversion";
+}
+async function runTests(setup, migratedDir, runCommand2) {
+  const result = await runCommand2(setup.testCommand[0], setup.testCommand[1], migratedDir);
+  const testOutput = `${result.stdout}
+${result.stderr}`.trim();
+  const counts = parseTestOutput(testOutput);
+  if (counts === null || counts.passed + counts.failed === 0) {
+    return { testPassRate: result.exitCode === 0 ? 1 : 0, testOutput };
+  }
+  return { testPassRate: counts.passed / (counts.passed + counts.failed), testOutput };
+}
+async function repairFailedFiles(manifest, plan, failedFiles, executionResult, apiKey, adapter, attempt) {
+  const failedSet = new Set(failedFiles);
+  const repairPlan = {
+    ...plan,
+    filesToModify: plan.filesToModify.filter((f) => failedSet.has(f.path)),
+    filesToCreate: plan.filesToCreate.filter((f) => failedSet.has(f.path)),
+    filesToDelete: []
+  };
+  return executeMigration(manifest, repairPlan, apiKey, () => {
+  }, {
+    adapter,
+    outputDir: executionResult.outputDir,
+    checkpointPath: `${executionResult.checkpointPath}.repair-${attempt}`
+  });
+}
+async function selfReview(originalDir, migratedDir, plan, testOutput, adapter, maxReviewFiles) {
+  const samples = await readReviewSamples(originalDir, migratedDir, plan, maxReviewFiles);
+  const { from, to, type } = plan.migrationTarget;
+  const systemPrompt = [
+    `You are a senior software engineer reviewing a completed ${type} migration from "${from}" to "${to}".`,
+    "Review the migration for missed cases, type errors, and breaking changes. Rate your confidence that the migration is correct from 0.0 to 1.0.",
+    'Categorise every issue: "environment" for setup/dependency problems (missing packages, module resolution), "conversion" for real migration errors.',
+    "Respond with a single raw JSON object and nothing else:",
+    '{ "confidenceScore": number, "issues": [{ "description": string, "severity": "low" | "medium" | "high", "category": "environment" | "conversion", "affectedFiles": string[] }] }'
+  ].join("\n");
+  const userPrompt = [
+    `Migration plan summary:
+${plan.summary}`,
+    "",
+    `Test run output (excerpt):
+${testOutput.slice(-TEST_OUTPUT_EXCERPT_CHARS) || "(no test suite detected)"}`,
+    "",
+    `Sampled file pairs (${samples.length} of the migrated files):`,
+    ...samples.map((s) => `<original_file path="${s.path}">
+${s.original}
+</original_file>
+<migrated_file path="${s.outputPath}">
+${s.migrated}
+</migrated_file>`)
+  ].join("\n");
+  const response = await adapter.complete({
+    systemPrompt,
+    userPrompt,
+    maxTokens: VERIFICATION_MAX_OUTPUT_TOKENS
+  });
+  return parseReviewResponse(response.text);
+}
+function parseReviewResponse(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start === -1 || end <= start)
+    return unparseableReview();
+  let raw;
+  try {
+    raw = JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return unparseableReview();
+  }
+  if (typeof raw !== "object" || raw === null)
+    return unparseableReview();
+  const obj = raw;
+  const confidenceScore = typeof obj.confidenceScore === "number" && Number.isFinite(obj.confidenceScore) ? Math.min(1, Math.max(0, obj.confidenceScore)) : 0;
+  const issues = [];
+  if (Array.isArray(obj.issues)) {
+    for (const item of obj.issues) {
+      if (typeof item !== "object" || item === null)
+        continue;
+      const record = item;
+      if (typeof record.description !== "string" || record.description === "")
+        continue;
+      const severity = record.severity;
+      const category = record.category;
+      issues.push({
+        description: record.description,
+        severity: severity === "low" || severity === "medium" || severity === "high" ? severity : "medium",
+        category: category === "environment" || category === "conversion" ? category : categorizeIssue(record.description),
+        affectedFiles: Array.isArray(record.affectedFiles) ? record.affectedFiles.filter((f) => typeof f === "string") : []
+      });
+    }
+  }
+  return { confidenceScore, issues };
+}
+function unparseableReview() {
+  return {
+    confidenceScore: 0,
+    issues: [
+      {
+        description: "Self-review response could not be parsed; manual review recommended.",
+        severity: "medium",
+        category: "environment",
+        affectedFiles: []
+      }
+    ]
+  };
+}
+async function readReviewSamples(originalDir, migratedDir, plan, maxFiles) {
+  const rank = { high: 0, medium: 1, low: 2 };
+  const candidates = [...plan.filesToModify].sort((a, b) => rank[a.complexity] - rank[b.complexity]);
+  const samples = [];
+  for (const entry of candidates) {
+    if (samples.length >= maxFiles)
+      break;
+    const outputPath = planOutputPath(entry);
+    const migrated = await readOptional(path4.join(migratedDir, outputPath));
+    if (migrated === null)
+      continue;
+    const original = await readOptional(path4.join(originalDir, entry.path));
+    samples.push({ path: entry.path, outputPath, original: original ?? "(new file)", migrated });
+  }
+  return samples;
+}
+async function computeDiffStats(originalDir, migratedDir, plan) {
+  const pairs = [
+    ...plan.filesToModify.map((f) => ({ source: f.path, output: planOutputPath(f) })),
+    ...plan.filesToCreate.map((f) => ({ source: f.path, output: f.path }))
+  ];
+  const stats = [];
+  for (const pair of pairs) {
+    const migrated = await readOptional(path4.join(migratedDir, pair.output));
+    if (migrated === null)
+      continue;
+    const original = await readOptional(path4.join(originalDir, pair.source)) ?? "";
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const part of diffLines(original, migrated)) {
+      if (part.added)
+        linesAdded += part.count ?? 0;
+      else if (part.removed)
+        linesRemoved += part.count ?? 0;
+    }
+    if (linesAdded + linesRemoved > 0)
+      stats.push({ path: pair.output, linesAdded, linesRemoved });
+  }
+  return {
+    totalFilesChanged: stats.length,
+    linesAdded: stats.reduce((sum, s) => sum + s.linesAdded, 0),
+    linesRemoved: stats.reduce((sum, s) => sum + s.linesRemoved, 0),
+    largestDiffs: [...stats].sort((a, b) => b.linesAdded + b.linesRemoved - (a.linesAdded + a.linesRemoved)).slice(0, 5)
+  };
+}
+function defaultCommandRunner(timeoutMs = 10 * 60 * 1e3) {
+  return (command, args, cwd) => new Promise((resolve) => {
+    const child = spawn(command, args, { cwd, shell: false });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      stderr += `
+(command timed out after ${timeoutMs}ms)`;
+    }, timeoutMs);
+    child.stdout.on("data", (data) => stdout += data.toString());
+    child.stderr.on("data", (data) => stderr += data.toString());
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({ exitCode: 127, stdout, stderr: `${stderr}
+${String(error)}` });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ exitCode: code ?? 1, stdout, stderr });
+    });
+  });
+}
+async function readOptional(filePath) {
+  try {
+    return await fs4.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists(filePath) {
+  try {
+    await fs4.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../engine/dist/orchestrator/index.js
+var MODEL_PRICING = {
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-opus-4-8": { input: 15, output: 75 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-opus-4-8"];
+
+// src/targets.ts
+var KNOWN_TARGETS = {
+  "javascript-to-typescript": { from: "javascript", to: "typescript", type: "language" },
+  "flow-to-typescript": { from: "flow", to: "typescript", type: "language" },
+  "python-2-to-3": { from: "python 2", to: "python 3", type: "language" },
+  "react-17-to-19": { from: "react 17", to: "react 19", type: "framework" },
+  "express-to-hono": { from: "express", to: "hono", type: "framework" },
+  "vue-2-to-3": { from: "vue 2", to: "vue 3", type: "framework" }
+};
+var LANGUAGES = /* @__PURE__ */ new Set([
+  "javascript",
+  "typescript",
+  "flow",
+  "python",
+  "go",
+  "rust",
+  "dart",
+  "php",
+  "ruby",
+  "java"
+]);
+function parseTarget(value) {
+  const known = KNOWN_TARGETS[value];
+  if (known !== void 0) return known;
+  const separator = value.indexOf("-to-");
+  if (separator <= 0 || separator + 4 >= value.length) {
+    throw new Error(
+      `Invalid migration target "${value}". Use <from>-to-<to>, e.g. javascript-to-typescript.`
+    );
+  }
+  const from = value.slice(0, separator);
+  const to = value.slice(separator + 4);
+  return {
+    from,
+    to,
+    type: LANGUAGES.has(from) && LANGUAGES.has(to) ? "language" : "framework"
+  };
+}
+function suggestTargets(stack) {
+  const suggestions = [];
+  if (stack.primaryLanguage === "javascript") suggestions.push("javascript-to-typescript");
+  if (stack.frameworks.includes("react")) suggestions.push("react-17-to-19");
+  if (stack.frameworks.includes("express")) suggestions.push("express-to-hono");
+  if (stack.frameworks.includes("vue")) suggestions.push("vue-2-to-3");
+  return suggestions;
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  const rootPath = process.cwd();
+  const spinner = ora("Analyzing codebase\u2026").start();
+  const manifest = await readCodebase(rootPath, { ignorePaths: ["migrated"] });
+  spinner.succeed(
+    `Analyzed ${manifest.files.length} files (${manifest.totalLines.toLocaleString("en-US")} lines)`
+  );
+  const stack = manifest.detectedStack;
+  console.log(`
+${chalk2.bold("Detected stack")}`);
+  console.log(`  Language:        ${chalk2.cyan(stack.primaryLanguage)}`);
+  console.log(
+    `  Frameworks:      ${stack.frameworks.length > 0 ? stack.frameworks.join(", ") : chalk2.dim("none detected")}`
+  );
+  console.log(`  Build tool:      ${stack.buildTool ?? chalk2.dim("none detected")}`);
+  console.log(`  Test framework:  ${stack.testFramework ?? chalk2.dim("none detected")}`);
+  console.log(`  Package manager: ${stack.packageManager ?? chalk2.dim("none detected")}`);
+  const suggestions = suggestTargets(stack);
+  console.log(`
+${chalk2.bold("Suggested migration targets")}`);
+  if (suggestions.length === 0) {
+    console.log(chalk2.dim("  No specific suggestions \u2014 any <from>-to-<to> target works."));
+  } else {
+    for (const target of suggestions) console.log(`  ${chalk2.green("\u2192")} ${target}`);
+  }
+  const configPath = path5.join(rootPath, "automigrate.config.json");
+  try {
+    await fs5.readFile(configPath, "utf8");
+    console.log(chalk2.dim(`
+automigrate.config.json already exists \u2014 left unchanged.`));
+  } catch {
+    const config2 = { target: suggestions[0] ?? "", ignorePaths: [] };
+    await fs5.writeFile(configPath, `${JSON.stringify(config2, null, 2)}
+`, "utf8");
+    console.log(`
+Wrote ${chalk2.cyan("automigrate.config.json")}`);
+  }
+  console.log(
+    chalk2.dim("Next: automigrate run --dry-run (review the plan), then automigrate run.")
+  );
+}
+
+// src/commands/rollback.ts
+import fs7 from "fs/promises";
+import path7 from "path";
+import chalk3 from "chalk";
+
+// src/workspace.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+async function backupFiles(rootPath, relPaths, destDir) {
+  let count = 0;
+  for (const rel of relPaths) {
+    let content;
+    try {
+      content = Buffer.from(await fs6.readFile(path6.join(rootPath, rel)));
+    } catch {
+      continue;
+    }
+    const target = path6.join(destDir, rel);
+    await fs6.mkdir(path6.dirname(target), { recursive: true });
+    await fs6.writeFile(target, content);
+    count++;
+  }
+  return count;
+}
+async function restoreBackup(backupRoot, rootPath) {
+  let count = 0;
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs6.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const rel = path6.relative(backupRoot, abs);
+      const target = path6.join(rootPath, rel);
+      await fs6.mkdir(path6.dirname(target), { recursive: true });
+      await fs6.writeFile(target, Buffer.from(await fs6.readFile(abs)));
+      count++;
+    }
+  }
+  await walk(backupRoot);
+  return count;
+}
+function copyExclusions(plan) {
+  const exclude = new Set(plan.filesToDelete);
+  for (const entry of plan.filesToModify) {
+    if (planOutputPath(entry) !== entry.path) exclude.add(entry.path);
+  }
+  return exclude;
+}
+async function copyUnchangedFiles(manifest, outputDir, exclude) {
+  let count = 0;
+  for (const file of manifest.files) {
+    if (exclude.has(file.relativePath)) continue;
+    const target = path6.join(outputDir, file.relativePath);
+    if (await exists2(target)) continue;
+    await fs6.mkdir(path6.dirname(target), { recursive: true });
+    await fs6.writeFile(target, file.content, "utf8");
+    count++;
+  }
+  return count;
+}
+async function removeDir(dirPath) {
+  await fs6.rm(dirPath, { recursive: true, force: true });
+}
+async function exists2(filePath) {
+  try {
+    await fs6.stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/rollback.ts
+async function rollbackCommand(options) {
+  const jobs = await readJobs();
+  const job = options.job !== void 0 ? jobs.find((j) => j.id === options.job) : [...jobs].reverse().find((j) => j.status === "complete" || j.status === "failed");
+  if (job === void 0) {
+    console.error(
+      chalk3.red(
+        options.job !== void 0 ? `Job ${options.job} not found.` : "No job to roll back."
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const restored = await restoreBackup(backupDir(job.id), job.rootPath);
+  let removed = 0;
+  for (const created of job.createdFiles ?? []) {
+    try {
+      await fs7.rm(path7.join(job.rootPath, created));
+      removed++;
+    } catch {
+    }
+  }
+  await removeDir(path7.join(job.rootPath, "migrated"));
+  await fs7.rm(path7.join(job.rootPath, "output.patch"), { force: true });
+  job.status = "rolled_back";
+  await saveJob(job);
+  console.log(
+    `${chalk3.green("Rolled back")} job ${job.id}: restored ${restored} files${removed > 0 ? `, removed ${removed} created files` : ""}, removed ${path7.join(job.rootPath, "migrated")}`
+  );
+  if (restored === 0 && removed === 0) {
+    console.log(
+      chalk3.dim("No files needed restoring (the migration never modified originals in place).")
+    );
+  }
+}
+
+// src/commands/run.ts
+import fs9 from "fs/promises";
+import path9 from "path";
+import chalk4 from "chalk";
+import cliProgress from "cli-progress";
+import ora2 from "ora";
+
+// src/buildInfo.ts
+var CLI_VERSION = "0.1.2";
+var CLI_BUILD_ID = "2026-07-11T08:07:48.185Z";
+function buildIdentity() {
+  return `automigrate v${CLI_VERSION} (build ${CLI_BUILD_ID})`;
+}
+
+// src/patch.ts
+import fs8 from "fs/promises";
+import path8 from "path";
+
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/base.js
+var Diff2 = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path10.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path10.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/diff/line.js
+var LineDiff2 = class extends Diff2 {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize2;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff2 = new LineDiff2();
+function diffLines2(oldStr, newStr, options) {
+  return lineDiff2.diff(oldStr, newStr, options);
+}
+function tokenize2(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// ../../node_modules/.pnpm/diff@8.0.4/node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines2(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines2(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// src/patch.ts
+function buildPatch(entries) {
+  let output = "";
+  for (const entry of normalizeEntries(entries)) {
+    const oldName = entry.oldContent === null ? "/dev/null" : `a/${entry.path}`;
+    const newName = entry.newContent === null ? "/dev/null" : `b/${entry.path}`;
+    const patch = structuredPatch(
+      oldName,
+      newName,
+      entry.oldContent ?? "",
+      entry.newContent ?? "",
+      void 0,
+      void 0,
+      { context: 3 }
+    );
+    if (patch.hunks.length === 0) continue;
+    output += `diff --git a/${entry.path} b/${entry.path}
+`;
+    if (entry.oldContent === null) output += "new file mode 100644\n";
+    if (entry.newContent === null) output += "deleted file mode 100644\n";
+    output += `--- ${oldName}
++++ ${newName}
+`;
+    for (const hunk of patch.hunks) {
+      output += `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@
+`;
+      output += `${hunk.lines.join("\n")}
+`;
+    }
+  }
+  return output;
+}
+function normalizeEntries(entries) {
+  const normalized = [];
+  for (const entry of entries) {
+    if (entry.oldPath === void 0 || entry.oldPath === entry.path) {
+      normalized.push({
+        path: entry.path,
+        oldContent: entry.oldContent,
+        newContent: entry.newContent
+      });
+      continue;
+    }
+    if (entry.oldContent !== null) {
+      normalized.push({ path: entry.oldPath, oldContent: entry.oldContent, newContent: null });
+    }
+    if (entry.newContent !== null) {
+      normalized.push({ path: entry.path, oldContent: null, newContent: entry.newContent });
+    }
+  }
+  return normalized;
+}
+async function collectPatchEntries(manifest, plan, migratedDir) {
+  const originals = new Map(manifest.files.map((f) => [f.relativePath, f.content]));
+  const entries = [];
+  for (const file of plan.filesToModify) {
+    const outputPath = planOutputPath(file);
+    const newContent = await readOptional2(path8.join(migratedDir, outputPath));
+    if (newContent === null) continue;
+    entries.push({
+      path: outputPath,
+      ...outputPath !== file.path ? { oldPath: file.path } : {},
+      oldContent: originals.get(file.path) ?? null,
+      newContent
+    });
+  }
+  for (const file of plan.filesToCreate) {
+    const newContent = await readOptional2(path8.join(migratedDir, file.path));
+    if (newContent === null) continue;
+    entries.push({ path: file.path, oldContent: null, newContent });
+  }
+  for (const filePath of plan.filesToDelete) {
+    const oldContent = originals.get(filePath);
+    if (oldContent === void 0) continue;
+    entries.push({ path: filePath, oldContent, newContent: null });
+  }
+  return entries;
+}
+async function readOptional2(filePath) {
+  try {
+    return await fs8.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/run.ts
+async function runCommand(options) {
+  console.log(chalk4.dim(buildIdentity()));
+  const rootPath = process.cwd();
+  const config2 = await readConfig();
+  const apiKey = config2.apiKey ?? process.env.ANTHROPIC_API_KEY;
+  if (apiKey === void 0 || apiKey === "") {
+    console.error(
+      chalk4.red("No API key configured.") + " Run `automigrate config set-key <key>` or set ANTHROPIC_API_KEY."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const projectConfig = await readProjectConfig(rootPath);
+  const targetSpec = options.target ?? projectConfig?.target;
+  if (targetSpec === void 0 || targetSpec === "") {
+    console.error(
+      chalk4.red("No migration target.") + " Pass --target <from-to> or run `automigrate init` first."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const target = parseTarget(targetSpec);
+  const ingestSpinner = ora2("Reading codebase\u2026").start();
+  const manifest = await readCodebase(rootPath, {
+    ignorePaths: [...config2.ignorePaths ?? [], ...projectConfig?.ignorePaths ?? [], "migrated"]
+  });
+  ingestSpinner.succeed(
+    `Read ${manifest.files.length} files (${manifest.totalLines.toLocaleString("en-US")} lines, ~${manifest.totalTokens.toLocaleString("en-US")} tokens)`
+  );
+  if (options.resume === true) {
+    await resumeRun(rootPath, manifest, apiKey, targetSpec);
+    return;
+  }
+  const planSpinner = ora2("Planning migration (Pass 1)\u2026").start();
+  const plan = await planMigration(manifest, target, apiKey, {
+    onProgress: (p) => {
+      planSpinner.text = `Planning migration (Pass 1)\u2026 batch ${p.batchIndex + 1}/${p.batchCount}, ${p.charsStreamed.toLocaleString("en-US")} chars`;
+    }
+  });
+  planSpinner.succeed(
+    `Plan ready: ${plan.filesToModify.length} to modify, ${plan.filesToCreate.length} to create, ${plan.filesToDelete.length} to delete (risk: ${plan.riskLevel}, effort: ${plan.estimatedEffort})`
+  );
+  if (options.dryRun === true) {
+    printPlan(plan);
+    return;
+  }
+  const jobId = newJobId();
+  const job = {
+    id: jobId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    rootPath,
+    target: targetSpec,
+    status: "executing",
+    filesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    tokensUsed: 0,
+    testPassRate: null,
+    confidenceScore: null
+  };
+  await acquireLock(rootPath);
+  try {
+    const affected = [...plan.filesToModify.map((f) => f.path), ...plan.filesToDelete];
+    const backed = await backupFiles(rootPath, affected, backupDir(jobId));
+    console.log(chalk4.dim(`Backed up ${backed} files to ${backupDir(jobId)}`));
+    await saveJob(job);
+    const result = await runExecutionWithProgress(
+      () => executeMigration(manifest, plan, apiKey, progressBarCallback(), {
+        outputDir: path9.join(rootPath, "migrated"),
+        checkpointPath: checkpointPath(jobId)
+      })
+    );
+    await finishRun(rootPath, manifest, plan, result, apiKey, job);
+  } catch (error) {
+    job.status = "failed";
+    job.error = error instanceof Error ? error.message : String(error);
+    await saveJob(job);
+    if (error instanceof ExecutionError) {
+      console.error(chalk4.red(`
+${error.message}`));
+      console.error(chalk4.yellow("Resume with: automigrate run --resume"));
+    } else {
+      console.error(chalk4.red(`
+Migration failed: ${job.error}`));
+    }
+    process.exitCode = 1;
+  } finally {
+    await releaseLock(rootPath);
+  }
+}
+async function resumeRun(rootPath, manifest, apiKey, targetSpec) {
+  const jobs = await readJobs();
+  const job = [...jobs].reverse().find((j) => j.rootPath === rootPath && j.status === "failed");
+  if (job === void 0) {
+    console.error(chalk4.red("No failed migration found for this directory to resume."));
+    process.exitCode = 1;
+    return;
+  }
+  const ckptPath = checkpointPath(job.id);
+  let checkpoint;
+  try {
+    checkpoint = JSON.parse(await fs9.readFile(ckptPath, "utf8"));
+  } catch {
+    console.error(chalk4.red(`Checkpoint for job ${job.id} not found or unreadable (${ckptPath}).`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(chalk4.dim(`Resuming job ${job.id} (${job.target || targetSpec})`));
+  job.status = "executing";
+  await acquireLock(rootPath);
+  try {
+    await saveJob(job);
+    const result = await runExecutionWithProgress(
+      () => resumeMigration(ckptPath, manifest, apiKey, progressBarCallback())
+    );
+    await finishRun(rootPath, manifest, checkpoint.plan, result, apiKey, job);
+  } catch (error) {
+    job.status = "failed";
+    job.error = error instanceof Error ? error.message : String(error);
+    await saveJob(job);
+    console.error(chalk4.red(`
+Resume failed: ${job.error}`));
+    if (error instanceof ExecutionError) {
+      console.error(chalk4.yellow("You can resume again with: automigrate run --resume"));
+    }
+    process.exitCode = 1;
+  } finally {
+    await releaseLock(rootPath);
+  }
+}
+async function finishRun(rootPath, manifest, plan, result, apiKey, job) {
+  const migratedDir = result.outputDir;
+  const copied = await copyUnchangedFiles(manifest, migratedDir, copyExclusions(plan));
+  console.log(chalk4.dim(`Copied ${copied} unchanged files into ${migratedDir}`));
+  const verifySpinner = ora2("Verifying migration (Pass 3)\u2026").start();
+  const report = await verifyMigration(rootPath, migratedDir, plan, result, apiKey, { manifest });
+  verifySpinner.succeed("Verification complete");
+  const patchEntries = await collectPatchEntries(manifest, plan, migratedDir);
+  const patchPath = path9.join(rootPath, "output.patch");
+  await fs9.writeFile(patchPath, buildPatch(patchEntries), "utf8");
+  job.status = "complete";
+  job.createdFiles = [
+    ...plan.filesToModify.filter((f) => planOutputPath(f) !== f.path).map(planOutputPath),
+    ...plan.filesToCreate.map((f) => f.path)
+  ];
+  job.filesChanged = result.filesModified + result.filesCreated + result.filesDeleted;
+  job.linesAdded = report.diffStats.linesAdded;
+  job.linesRemoved = report.diffStats.linesRemoved;
+  job.tokensUsed = result.tokensUsed;
+  job.testPassRate = report.testPassRate;
+  job.confidenceScore = report.confidenceScore;
+  await saveJob(job);
+  printSummary(report, result, patchPath, migratedDir, job.id);
+}
+function progressBarCallback() {
+  const bar = new cliProgress.SingleBar(
+    {
+      format: `Transforming (Pass 2) ${chalk4.cyan("{bar}")} {value}/{total} files \xB7 {tokens} tokens \xB7 {file}`,
+      hideCursor: true
+    },
+    cliProgress.Presets.shades_classic
+  );
+  let started = false;
+  return (progress) => {
+    if (!started && progress.filesTotal > 0) {
+      bar.start(progress.filesTotal, 0, { tokens: 0, file: "" });
+      started = true;
+    }
+    bar.update(progress.filesComplete, {
+      tokens: progress.tokensUsed.toLocaleString("en-US"),
+      file: progress.currentFile ?? ""
+    });
+    if (progress.stage === "complete" || progress.stage === "failed") bar.stop();
+  };
+}
+async function runExecutionWithProgress(run) {
+  const result = await run();
+  console.log(
+    chalk4.green(
+      `Transformed ${result.filesModified + result.filesCreated} files (${result.tokensUsed.toLocaleString("en-US")} tokens)`
+    )
+  );
+  return result;
+}
+function printPlan(plan) {
+  console.log(`
+${chalk4.bold("Migration plan (dry run)")}`);
+  console.log(plan.summary);
+  console.log(
+    `
+Risk: ${riskColor(plan.riskLevel)}  Effort: ${chalk4.bold(plan.estimatedEffort)}  Est. tokens: ${plan.tokenBudgetEstimate.toLocaleString("en-US")}`
+  );
+  if (plan.filesToModify.length > 0) {
+    console.log(`
+${chalk4.bold("Files to modify:")}`);
+    for (const f of plan.filesToModify) {
+      const rename = planOutputPath(f) !== f.path ? chalk4.cyan(` \u2192 ${planOutputPath(f)}`) : "";
+      console.log(
+        `  ${complexityBadge(f.complexity)} ${f.path}${rename}  ${chalk4.dim(f.description)}`
+      );
+    }
+  }
+  if (plan.filesToCreate.length > 0) {
+    console.log(`
+${chalk4.bold("Files to create:")}`);
+    for (const f of plan.filesToCreate) console.log(`  ${chalk4.green("+")} ${f.path}`);
+  }
+  if (plan.filesToDelete.length > 0) {
+    console.log(`
+${chalk4.bold("Files to delete:")}`);
+    for (const f of plan.filesToDelete) console.log(`  ${chalk4.red("-")} ${f}`);
+  }
+  if (plan.dependencyChanges.length > 0) {
+    console.log(`
+${chalk4.bold("Dependency changes:")}`);
+    for (const d of plan.dependencyChanges) {
+      console.log(
+        `  ${d.action} ${d.name} ${chalk4.dim(`${d.currentVersion ?? ""} \u2192 ${d.targetVersion ?? ""}`)}`
+      );
+    }
+  }
+  if (plan.breakingChanges.length > 0) {
+    console.log(`
+${chalk4.bold("Breaking changes flagged:")}`);
+    for (const b of plan.breakingChanges) {
+      console.log(`  ${complexityBadge(b.severity)} ${b.description}`);
+    }
+  }
+  console.log(chalk4.dim("\nRun without --dry-run to execute this plan."));
+}
+function printSummary(report, result, patchPath, migratedDir, jobId) {
+  const passRate = report.testPassRate === null ? chalk4.dim("no tests found") : report.testPassRate >= 0.9 ? chalk4.green(`${Math.round(report.testPassRate * 100)}%`) : chalk4.red(`${Math.round(report.testPassRate * 100)}%`);
+  const conversionIssues = report.flaggedIssues.filter((i) => i.category === "conversion");
+  const environmentIssues = report.flaggedIssues.filter((i) => i.category === "environment");
+  const compile = report.compileCheck;
+  const compileLine = compile === void 0 || !compile.ran ? chalk4.yellow(`skipped (${compile?.skippedReason ?? "not available"})`) : compile.ok ? chalk4.green("\u2713 passed") : chalk4.red(
+    `\u2717 ${compile.errors.length} error(s) (${[...new Set(compile.errors.map((e) => e.file).filter((f) => f !== ""))].join(", ")})`
+  );
+  console.log(`
+${chalk4.bold("Migration complete")} ${chalk4.dim(`(job ${jobId})`)}`);
+  console.log(
+    `  Files changed: ${chalk4.bold(String(result.filesModified + result.filesCreated + result.filesDeleted))}  ${chalk4.green(`+${report.diffStats.linesAdded}`)} ${chalk4.red(`-${report.diffStats.linesRemoved}`)}`
+  );
+  console.log(`  Compile check: ${compileLine}`);
+  console.log(
+    `  Test pass rate: ${passRate}   Confidence: ${Math.round(report.confidenceScore * 100)}%`
+  );
+  if (compile !== void 0 && compile.ran && !compile.ok) {
+    console.log(
+      chalk4.red.bold("\n  \u26A0 The migrated output does NOT compile.") + chalk4.red(" Review the errors above before applying output.patch.")
+    );
+  }
+  if (report.selfRepairAttempts > 0) {
+    console.log(`  Self-repair attempts: ${report.selfRepairAttempts}`);
+  }
+  if (result.failedFiles.length > 0) {
+    console.log(
+      chalk4.red(`  Failed files (${result.failedFiles.length}): ${result.failedFiles.join(", ")}`)
+    );
+  }
+  if (conversionIssues.length > 0) {
+    console.log(`
+  ${chalk4.bold("Conversion issues:")}`);
+    for (const issue of conversionIssues) {
+      console.log(`    ${complexityBadge(issue.severity)} ${issue.description}`);
+    }
+  }
+  if (environmentIssues.length > 0) {
+    console.log(chalk4.dim(`  Environment setup items: ${environmentIssues.length} (see report)`));
+  }
+  console.log(`
+  Review:   ${chalk4.cyan(patchPath)}  (apply with: git apply output.patch)`);
+  console.log(`  Output:   ${chalk4.cyan(migratedDir)}`);
+  console.log(`  Rollback: ${chalk4.cyan(`automigrate rollback --job ${jobId}`)}
+`);
+}
+function riskColor(risk) {
+  if (risk === "low") return chalk4.green(risk);
+  if (risk === "medium") return chalk4.yellow(risk);
+  return chalk4.red(risk);
+}
+function complexityBadge(level) {
+  if (level === "low") return chalk4.green("\u25CF");
+  if (level === "medium") return chalk4.yellow("\u25CF");
+  return chalk4.red("\u25CF");
+}
+async function readProjectConfig(rootPath) {
+  try {
+    return JSON.parse(
+      await fs9.readFile(path9.join(rootPath, "automigrate.config.json"), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/status.ts
+import chalk5 from "chalk";
+async function statusCommand() {
+  const jobs = await readJobs();
+  if (jobs.length === 0) {
+    console.log(chalk5.dim("No migrations recorded yet. Run `automigrate run` to start one."));
+    return;
+  }
+  console.log(chalk5.bold(`Last ${Math.min(jobs.length, 5)} migration jobs:
+`));
+  for (const job of jobs.slice(-5).reverse()) {
+    const date = job.createdAt.slice(0, 16).replace("T", " ");
+    const stats = job.status === "complete" ? `${job.filesChanged} files  ${chalk5.green(`+${job.linesAdded}`)} ${chalk5.red(`-${job.linesRemoved}`)}` + (job.testPassRate === null ? "" : `  tests ${Math.round(job.testPassRate * 100)}%`) : job.error ?? "";
+    console.log(`  ${statusBadge(job.status)} ${chalk5.bold(job.id)}  ${date}  ${job.target}`);
+    console.log(`     ${chalk5.dim(job.rootPath)}  ${stats}
+`);
+  }
+}
+function statusBadge(status) {
+  switch (status) {
+    case "complete":
+      return chalk5.green("\u2714");
+    case "failed":
+      return chalk5.red("\u2716");
+    case "rolled_back":
+      return chalk5.yellow("\u21A9");
+    default:
+      return chalk5.cyan("\u2026");
+  }
+}
+
+// src/index.ts
+var pkg = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+var program = new Command();
+program.name("automigrate").description("Autonomous codebase migration agent \u2014 plan, transform, verify").version(pkg.version);
+program.command("init").description("Detect the stack in the current directory and suggest migration targets").action(initCommand);
+program.command("run").description("Run a full migration: plan, execute, verify").option("--target <from-to>", "migration target, e.g. javascript-to-typescript").option("--dry-run", "plan only, print the plan, do not execute").option("--resume", "resume the last failed migration from its checkpoint").action(runCommand);
+program.command("rollback").description("Restore original files from the pre-migration backup and remove /migrated").option("--job <id>", "job id to roll back (defaults to the most recent)").action(rollbackCommand);
+program.command("status").description("Show the last 5 migration jobs").action(statusCommand);
+var config = program.command("config").description("Manage AutoMigrate configuration");
+config.command("set-key <apiKey>").description("Save the Anthropic API key to ~/.automigrate/config.json").action(setKeyCommand);
+await program.parseAsync();
+//# sourceMappingURL=index.js.map