outfitter 0.2.5 → 0.2.7

package/dist/shared/outfitter-pcj9gg2g.js

@@ -0,0 +1,909 @@
+// @bun
+import {
+  analyzeUpgrades
+} from "./outfitter-bpr28y54.js";
+import {
+  applyUpdatesToWorkspace,
+  getInstalledPackagesFromWorkspace,
+  runInstall
+} from "./outfitter-yvksv5qb.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+import {
+  __require
+} from "./outfitter-mdt37hqm.js";
+
+// apps/outfitter/src/commands/upgrade-codemods.ts
+import { existsSync as existsSync2 } from "fs";
+import { isAbsolute, join as join2, relative, resolve as resolve2 } from "path";
+import { InternalError as InternalError2, Result as Result2 } from "@outfitter/contracts";
+
+// apps/outfitter/src/commands/upgrade.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+import { output } from "@outfitter/cli";
+import { InternalError, Result } from "@outfitter/contracts";
+import { createTheme } from "@outfitter/tui/render";
+var FRONTMATTER_BLOCK_REGEX = /^---\r?\n[\s\S]*?\r?\n---\r?\n*/;
+async function getLatestVersion(name) {
+  try {
+    const proc = Bun.spawn(["npm", "view", name, "version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+    if (exitCode !== 0)
+      return null;
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var MIGRATION_DOC_PATHS = ["plugins/outfitter/shared/migrations"];
+function findMigrationDocsDir(cwd, binaryDir) {
+  for (const relative of MIGRATION_DOC_PATHS) {
+    const dir = join(cwd, relative);
+    if (existsSync(dir))
+      return dir;
+  }
+  let current = resolve(cwd);
+  const root = resolve("/");
+  while (current !== root) {
+    const parent = resolve(current, "..");
+    if (parent === current)
+      break;
+    current = parent;
+    for (const relative of MIGRATION_DOC_PATHS) {
+      const dir = join(current, relative);
+      if (existsSync(dir))
+        return dir;
+    }
+  }
+  const resolvedBinaryDir = binaryDir ?? resolve(import.meta.dir, "../../../..");
+  for (const relative of MIGRATION_DOC_PATHS) {
+    const dir = join(resolvedBinaryDir, relative);
+    if (existsSync(dir))
+      return dir;
+  }
+  return null;
+}
+function readMigrationDocs(migrationsDir, shortName, fromVersion, toVersion) {
+  const glob = new Bun.Glob(`outfitter-${shortName}-*.md`);
+  const versionPattern = new RegExp(`^outfitter-${shortName}-(\\d+\\.\\d+\\.\\d+)\\.md$`);
+  const docs = [];
+  for (const entry of glob.scanSync({ cwd: migrationsDir })) {
+    const match = entry.match(versionPattern);
+    if (!match?.[1])
+      continue;
+    const docVersion = match[1];
+    if (Bun.semver.order(docVersion, fromVersion) <= 0)
+      continue;
+    if (Bun.semver.order(docVersion, toVersion) > 0)
+      continue;
+    const filePath = join(migrationsDir, entry);
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const body = content.replace(FRONTMATTER_BLOCK_REGEX, "").trim();
+    if (body) {
+      docs.push({ version: docVersion, content: body });
+    }
+  }
+  docs.sort((a, b) => Bun.semver.order(a.version, b.version));
+  return docs.map((d) => d.content);
+}
+function readMigrationBreakingFlag(migrationsDir, shortName, version) {
+  const filePath = join(migrationsDir, `outfitter-${shortName}-${version}.md`);
+  if (!existsSync(filePath)) {
+    return;
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!frontmatter?.[1]) {
+    return;
+  }
+  const breakingLine = frontmatter[1].split(/\r?\n/).find((line) => line.trimStart().startsWith("breaking:"));
+  if (breakingLine === undefined) {
+    return;
+  }
+  const rawValue = breakingLine.split(":").slice(1).join(":").trim();
+  if (rawValue === "true")
+    return true;
+  if (rawValue === "false")
+    return false;
+  return;
+}
+var VALID_CHANGE_TYPES = new Set([
+  "renamed",
+  "removed",
+  "signature-changed",
+  "moved",
+  "deprecated",
+  "added"
+]);
+function parseYamlValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseMigrationFrontmatter(content) {
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch?.[1])
+    return null;
+  const fmBlock = fmMatch[1];
+  const lines = fmBlock.split(/\r?\n/);
+  let pkg;
+  let version;
+  let breaking;
+  let changesStartIdx = -1;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined)
+      continue;
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("package:")) {
+      pkg = parseYamlValue(trimmed.slice("package:".length));
+    } else if (trimmed.startsWith("version:")) {
+      version = parseYamlValue(trimmed.slice("version:".length));
+    } else if (trimmed.startsWith("breaking:")) {
+      const val = parseYamlValue(trimmed.slice("breaking:".length));
+      if (val === "true")
+        breaking = true;
+      else if (val === "false")
+        breaking = false;
+    } else if (trimmed.startsWith("changes:")) {
+      changesStartIdx = i + 1;
+    }
+  }
+  if (pkg === undefined || version === undefined || breaking === undefined) {
+    return null;
+  }
+  let changes;
+  if (changesStartIdx >= 0) {
+    changes = parseChangesArray(lines, changesStartIdx);
+  }
+  return {
+    package: pkg,
+    version,
+    breaking,
+    ...changes !== undefined ? { changes } : {}
+  };
+}
+function parseChangesArray(lines, startIdx) {
+  const changes = [];
+  let current = null;
+  for (let i = startIdx;i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined)
+      continue;
+    if (/^\s+-\s+/.test(line)) {
+      if (current !== null) {
+        const change = buildChange(current);
+        if (change)
+          changes.push(change);
+      }
+      current = {};
+      const afterDash = line.replace(/^\s+-\s+/, "");
+      const colonIdx = afterDash.indexOf(":");
+      if (colonIdx >= 0) {
+        const key = afterDash.slice(0, colonIdx).trim();
+        const val = parseYamlValue(afterDash.slice(colonIdx + 1));
+        current[key] = val;
+      }
+    } else if (current !== null && /^\s{4,}\S/.test(line)) {
+      const trimmed = line.trim();
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx >= 0) {
+        const key = trimmed.slice(0, colonIdx).trim();
+        const val = parseYamlValue(trimmed.slice(colonIdx + 1));
+        current[key] = val;
+      }
+    } else if (/^\S/.test(line)) {
+      break;
+    }
+  }
+  if (current !== null) {
+    const change = buildChange(current);
+    if (change)
+      changes.push(change);
+  }
+  return changes;
+}
+function buildChange(raw) {
+  const type = raw["type"];
+  if (!(type && VALID_CHANGE_TYPES.has(type))) {
+    return null;
+  }
+  return {
+    type,
+    ...raw["from"] ? { from: raw["from"] } : {},
+    ...raw["to"] ? { to: raw["to"] } : {},
+    ...raw["path"] ? { path: raw["path"] } : {},
+    ...raw["export"] ? { export: raw["export"] } : {},
+    ...raw["detail"] ? { detail: raw["detail"] } : {},
+    ...raw["codemod"] ? { codemod: raw["codemod"] } : {}
+  };
+}
+function readMigrationDocsWithMetadata(migrationsDir, shortName, fromVersion, toVersion) {
+  const glob = new Bun.Glob(`outfitter-${shortName}-*.md`);
+  const versionPattern = new RegExp(`^outfitter-${shortName}-(\\d+\\.\\d+\\.\\d+)\\.md$`);
+  const docs = [];
+  for (const entry of glob.scanSync({ cwd: migrationsDir })) {
+    const match = entry.match(versionPattern);
+    if (!match?.[1])
+      continue;
+    const docVersion = match[1];
+    if (Bun.semver.order(docVersion, fromVersion) <= 0)
+      continue;
+    if (Bun.semver.order(docVersion, toVersion) > 0)
+      continue;
+    const filePath = join(migrationsDir, entry);
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const frontmatter = parseMigrationFrontmatter(content);
+    if (!frontmatter)
+      continue;
+    const body = content.replace(FRONTMATTER_BLOCK_REGEX, "").trim();
+    docs.push({ frontmatter, body, version: docVersion });
+  }
+  docs.sort((a, b) => Bun.semver.order(a.version, b.version));
+  return docs;
+}
+function buildMigrationGuides(packages, migrationsDir) {
+  const guides = [];
+  for (const pkg of packages) {
+    if (!pkg.updateAvailable || pkg.latest === null)
+      continue;
+    let steps = [];
+    let allChanges;
+    if (migrationsDir !== null) {
+      const shortName = pkg.name.replace("@outfitter/", "");
+      const metaDocs = readMigrationDocsWithMetadata(migrationsDir, shortName, pkg.current, pkg.latest);
+      steps = metaDocs.map((doc) => doc.body);
+      const changes = [];
+      for (const doc of metaDocs) {
+        if (doc.frontmatter.changes) {
+          changes.push(...doc.frontmatter.changes);
+        }
+      }
+      if (changes.length > 0) {
+        allChanges = changes;
+      }
+    }
+    guides.push({
+      packageName: pkg.name,
+      fromVersion: pkg.current,
+      toVersion: pkg.latest,
+      breaking: pkg.breaking,
+      steps,
+      ...allChanges !== undefined ? { changes: allChanges } : {}
+    });
+  }
+  return guides;
+}
+function getVersionPrefix(specifier) {
+  if (specifier.startsWith("workspace:")) {
+    const inner = specifier.slice("workspace:".length);
+    return `workspace:${getVersionPrefix(inner)}`;
+  }
+  const match = specifier.match(/^([\^~>=<]+)/);
+  return match?.[1] ?? "";
+}
+async function applyUpdates(cwd, updates) {
+  const pkgPath = join(cwd, "package.json");
+  let raw;
+  try {
+    raw = readFileSync(pkgPath, "utf-8");
+  } catch {
+    return Result.err(InternalError.create("Failed to read package.json for apply", { cwd }));
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return Result.err(InternalError.create("Invalid JSON in package.json", { cwd }));
+  }
+  const updateMap = new Map;
+  for (const u of updates) {
+    updateMap.set(u.name, u.latestVersion);
+  }
+  for (const section of ["dependencies", "devDependencies"]) {
+    const deps = pkg[section];
+    if (!deps)
+      continue;
+    for (const name of Object.keys(deps)) {
+      const newVersion = updateMap.get(name);
+      if (newVersion === undefined)
+        continue;
+      const currentSpecifier = deps[name];
+      if (currentSpecifier === undefined)
+        continue;
+      const prefix = getVersionPrefix(currentSpecifier);
+      deps[name] = `${prefix}${newVersion}`;
+    }
+  }
+  try {
+    const updated = `${JSON.stringify(pkg, null, 2)}
+`;
+    await Bun.write(pkgPath, updated);
+  } catch {
+    return Result.err(InternalError.create("Failed to write updated package.json", { cwd }));
+  }
+  try {
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      return Result.err(InternalError.create("bun install failed", {
+        cwd,
+        exitCode,
+        stderr: stderr.trim()
+      }));
+    }
+  } catch {
+    return Result.err(InternalError.create("Failed to run bun install", { cwd }));
+  }
+  return Result.ok(undefined);
+}
+async function runUpgrade(options) {
+  const cwd = resolve(options.cwd);
+  const startedAt = new Date;
+  let workspaceRoot = null;
+  const emptyResult = {
+    packages: [],
+    total: 0,
+    updatesAvailable: 0,
+    hasBreaking: false,
+    applied: false,
+    appliedPackages: [],
+    skippedBreaking: []
+  };
+  const writeReport = (status, result, error) => {
+    writeUpgradeReportSafely(cwd, result, {
+      status,
+      startedAt,
+      workspaceRoot,
+      options,
+      ...error !== undefined ? { error } : {}
+    });
+  };
+  try {
+    const migrationsDir = findMigrationDocsDir(cwd);
+    const migrationFlagsDir = findMigrationDocsDir(cwd, cwd);
+    const scanResult = getInstalledPackagesFromWorkspace(cwd);
+    if (scanResult.isErr()) {
+      writeReport("failed", emptyResult, scanResult.error);
+      return scanResult;
+    }
+    const scan = scanResult.value;
+    workspaceRoot = scan.workspaceRoot;
+    const requestedPackages = options.guidePackages;
+    let installed = scan.packages;
+    let unknownPackages;
+    if (requestedPackages && requestedPackages.length > 0) {
+      const filterSet = new Set(requestedPackages.map((p) => p.startsWith("@") ? p : `@outfitter/${p}`));
+      const found = new Set;
+      installed = scan.packages.filter((pkg) => {
+        if (filterSet.has(pkg.name)) {
+          found.add(pkg.name);
+          return true;
+        }
+        return false;
+      });
+      const notFound = [...filterSet].filter((name) => !found.has(name));
+      if (notFound.length > 0) {
+        unknownPackages = notFound;
+      }
+    }
+    const installRoot = scan.workspaceRoot ?? cwd;
+    const codemodTargetDir = scan.workspaceRoot ?? cwd;
+    if (installed.length === 0 && !unknownPackages?.length) {
+      const result = {
+        ...emptyResult,
+        ...scan.conflicts.length > 0 ? { conflicts: scan.conflicts } : {}
+      };
+      writeReport("no_updates", result);
+      return Result.ok(result);
+    }
+    if (installed.length === 0 && unknownPackages?.length) {
+      const result = {
+        ...emptyResult,
+        unknownPackages,
+        ...scan.conflicts.length > 0 ? { conflicts: scan.conflicts } : {}
+      };
+      writeReport("no_updates", result);
+      return Result.ok(result);
+    }
+    const latestVersions = new Map;
+    const installedMap = new Map;
+    const npmFailures = new Set;
+    await Promise.all(installed.map(async (pkg) => {
+      installedMap.set(pkg.name, pkg.version);
+      const latest = await getLatestVersion(pkg.name);
+      if (latest !== null) {
+        const shortName = pkg.name.replace("@outfitter/", "");
+        const docBreaking = migrationFlagsDir !== null ? readMigrationBreakingFlag(migrationFlagsDir, shortName, latest) : undefined;
+        latestVersions.set(pkg.name, {
+          version: latest,
+          ...docBreaking !== undefined ? { breaking: docBreaking } : {}
+        });
+      } else {
+        npmFailures.add(pkg.name);
+      }
+    }));
+    const plan = analyzeUpgrades(installedMap, latestVersions);
+    const packages = plan.packages.map((action) => ({
+      name: action.name,
+      current: action.currentVersion,
+      latest: npmFailures.has(action.name) ? null : action.latestVersion,
+      updateAvailable: action.classification === "upgradableNonBreaking" || action.classification === "upgradableBreaking",
+      breaking: action.breaking
+    }));
+    const updatesAvailable = packages.filter((p) => p.updateAvailable).length;
+    const hasBreaking = packages.some((p) => p.breaking);
+    const nonBreakingUpgradable = plan.packages.filter((a) => a.classification === "upgradableNonBreaking");
+    const breakingUpgradable = plan.packages.filter((a) => a.classification === "upgradableBreaking");
+    const includeBreaking = options.all === true;
+    const packagesToApply = includeBreaking ? [...nonBreakingUpgradable, ...breakingUpgradable] : nonBreakingUpgradable;
+    const skippedBreaking = includeBreaking ? [] : breakingUpgradable.map((a) => a.name);
+    const guidesData = options.guide === true ? buildMigrationGuides(packages, migrationsDir) : undefined;
+    const buildResult = (overrides = {}) => ({
+      packages,
+      total: packages.length,
+      updatesAvailable,
+      hasBreaking,
+      applied: false,
+      appliedPackages: [],
+      skippedBreaking,
+      ...guidesData !== undefined ? { guides: guidesData } : {},
+      ...unknownPackages !== undefined ? { unknownPackages } : {},
+      ...scan.conflicts.length > 0 ? { conflicts: scan.conflicts } : {},
+      ...overrides
+    });
+    if (options.dryRun) {
+      const result = buildResult();
+      writeReport("dry_run", result);
+      return Result.ok(result);
+    }
+    if (packagesToApply.length === 0) {
+      const result = buildResult();
+      writeReport("no_updates", result);
+      return Result.ok(result);
+    }
+    if (options.yes !== true && options.interactive !== false) {
+      const { confirmDestructive } = await import("@outfitter/tui/confirm");
+      const confirmed = await confirmDestructive({
+        message: `Apply ${packagesToApply.length} upgrade(s)?`,
+        itemCount: packagesToApply.length,
+        bypassFlag: false
+      });
+      if (confirmed.isErr()) {
+        const result = buildResult();
+        writeReport("cancelled", result);
+        return Result.ok(result);
+      }
+    } else if (options.interactive === false && options.yes !== true) {
+      const result = buildResult();
+      writeReport("skipped_non_interactive", result);
+      return Result.ok(result);
+    }
+    let applied = false;
+    const appliedPackages = [];
+    if (packagesToApply.length > 0) {
+      if (scan.workspaceRoot !== null) {
+        const applyResult = await applyUpdatesToWorkspace(scan.manifestPaths, scan.manifestsByPackage, packagesToApply);
+        if (applyResult.isErr()) {
+          const failureResult = buildResult();
+          writeReport("failed", failureResult, applyResult.error);
+          return applyResult;
+        }
+        const installResult = await runInstall(installRoot);
+        if (installResult.isErr()) {
+          const failureResult = buildResult();
+          writeReport("failed", failureResult, installResult.error);
+          return installResult;
+        }
+      } else {
+        const applyResult = await applyUpdates(cwd, packagesToApply);
+        if (applyResult.isErr()) {
+          const failureResult = buildResult();
+          writeReport("failed", failureResult, applyResult.error);
+          return applyResult;
+        }
+      }
+      applied = true;
+      appliedPackages.push(...packagesToApply.map((a) => a.name));
+    }
+    let codemodSummary;
+    if (applied && options.noCodemods !== true && migrationsDir !== null) {
+      const codemodsDir = findCodemodsDir(cwd);
+      if (codemodsDir !== null) {
+        const allChangedFiles = [];
+        const allErrors = [];
+        let codemodCount = 0;
+        for (const pkg of packagesToApply) {
+          const shortName = pkg.name.replace("@outfitter/", "");
+          const codemods = discoverCodemods(migrationsDir, codemodsDir, shortName, installedMap.get(pkg.name) ?? "0.0.0", pkg.latestVersion);
+          for (const codemod of codemods) {
+            const codemodResult = await runCodemod(codemod.absolutePath, codemodTargetDir, false);
+            codemodCount++;
+            if (codemodResult.isOk()) {
+              allChangedFiles.push(...codemodResult.value.changedFiles);
+              allErrors.push(...codemodResult.value.errors);
+            } else {
+              allErrors.push(codemodResult.error.message);
+            }
+          }
+        }
+        if (codemodCount > 0) {
+          codemodSummary = {
+            codemodCount,
+            changedFiles: allChangedFiles,
+            errors: allErrors
+          };
+        }
+      }
+    }
+    const finalResult = buildResult({
+      applied,
+      appliedPackages,
+      ...codemodSummary !== undefined ? { codemods: codemodSummary } : {}
+    });
+    writeReport("applied", finalResult);
+    return Result.ok(finalResult);
+  } catch (error) {
+    const normalizedError = error && typeof error === "object" && "category" in error && "message" in error ? error : InternalError.create("Unexpected error in outfitter upgrade", {
+      cwd,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    writeReport("failed", emptyResult, normalizedError);
+    return Result.err(normalizedError);
+  }
+}
+async function printUpgradeResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    await output(result, { mode: structuredMode });
+    return;
+  }
+  const theme = createTheme();
+  const lines = ["", "Outfitter Upgrade", "", "=".repeat(60)];
+  if (result.packages.length === 0) {
+    lines.push("No @outfitter/* packages found in package.json.");
+    if (!result.unknownPackages || result.unknownPackages.length === 0) {
+      await output(lines, { mode: "human" });
+      return;
+    }
+    lines.push("");
+  } else {
+    lines.push(`  ${"Package".padEnd(28)} ${"Current".padEnd(10)} ${"Available".padEnd(10)} Migration`);
+    lines.push(`  ${"\u2500".repeat(28)} ${"\u2500".repeat(10)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`);
+    for (const pkg of result.packages) {
+      const name = pkg.name.padEnd(28);
+      const current = pkg.current.padEnd(10);
+      const available = (pkg.latest ?? "unknown").padEnd(10);
+      let migration;
+      if (pkg.latest === null) {
+        migration = theme.muted("lookup failed");
+      } else if (!pkg.updateAvailable) {
+        migration = theme.muted("up to date");
+      } else if (pkg.breaking) {
+        migration = theme.error("breaking");
+      } else {
+        migration = theme.success("non-breaking");
+      }
+      lines.push(`  ${name} ${current} ${available} ${migration}`);
+    }
+    lines.push("");
+  }
+  if (result.applied && result.appliedPackages.length > 0) {
+    const breakingApplied = result.appliedPackages.filter((name) => result.packages.some((p) => p.name === name && p.breaking));
+    const nonBreakingApplied = result.appliedPackages.filter((name) => !result.packages.some((p) => p.name === name && p.breaking));
+    if (nonBreakingApplied.length > 0) {
+      lines.push(theme.success(`Applied ${nonBreakingApplied.length} non-breaking upgrade(s):`));
+      for (const name of nonBreakingApplied) {
+        lines.push(`  - ${name}`);
+      }
+      lines.push("");
+    }
+    if (breakingApplied.length > 0) {
+      lines.push(theme.error(`Applied ${breakingApplied.length} breaking upgrade(s):`));
+      for (const name of breakingApplied) {
+        const pkg = result.packages.find((p) => p.name === name);
+        lines.push(`  - ${name} (${pkg?.current} -> ${pkg?.latest})`);
+      }
+      lines.push("", theme.muted("Review migration guides: 'outfitter upgrade --guide'"));
+      lines.push("");
+    }
+  }
+  if (result.skippedBreaking.length > 0 && options?.all !== true) {
+    if (result.applied) {
+      lines.push(theme.error(`Skipped ${result.skippedBreaking.length} breaking upgrade(s):`));
+    } else {
+      lines.push("  Excluded (breaking):");
+    }
+    for (const name of result.skippedBreaking) {
+      const pkg = result.packages.find((p) => p.name === name);
+      const codemodHint = pkg?.breaking ? "(migration guide)" : "";
+      lines.push(`    ${name.padEnd(24)} ${(pkg?.current ?? "").padEnd(8)} -> ${(pkg?.latest ?? "").padEnd(8)} ${codemodHint}`.trimEnd());
+    }
+    lines.push("", theme.muted("  Use --all to include breaking changes"));
+    lines.push("");
+  }
+  if (result.codemods !== undefined) {
+    const uniqueChangedFiles = [
+      ...new Set(result.codemods.changedFiles)
+    ].sort();
+    lines.push(theme.info(`Ran ${result.codemods.codemodCount} codemod(s).`));
+    if (uniqueChangedFiles.length > 0) {
+      lines.push(theme.success(`Codemods changed ${uniqueChangedFiles.length} file(s):`));
+      for (const file of uniqueChangedFiles) {
+        lines.push(`  - ${file}`);
+      }
+    }
+    if (result.codemods.errors.length > 0) {
+      lines.push(theme.error(`Codemod errors (${result.codemods.errors.length}):`));
+      for (const error of result.codemods.errors) {
+        lines.push(`  - ${error}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.conflicts && result.conflicts.length > 0) {
+    lines.push(theme.warning(`Version conflict(s) across workspace (${result.conflicts.length}):`));
+    for (const conflict of result.conflicts) {
+      lines.push(`  ${conflict.name}`);
+      for (const entry of conflict.versions) {
+        const manifests = entry.manifests.map((m) => {
+          const dir = m.replace(/\/package\.json$/, "");
+          const parts = dir.split("/");
+          return parts.slice(-2).join("/");
+        }).join(", ");
+        lines.push(`    ${entry.version.padEnd(10)} ${theme.muted(manifests)}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.unknownPackages && result.unknownPackages.length > 0) {
+    lines.push(theme.error("Unknown package(s) not found in workspace:"));
+    for (const name of result.unknownPackages) {
+      lines.push(`  - ${name}`);
+    }
+    lines.push("");
+  }
+  if (!result.applied) {
+    if (options?.dryRun) {
+      lines.push(theme.muted("Dry run \u2014 no changes applied."));
+    } else if (result.updatesAvailable > 0) {
+      lines.push(theme.muted("Run 'outfitter upgrade --guide' for migration instructions."));
+    } else {
+      lines.push(theme.success("All packages are up to date."));
+    }
+  }
+  if (options?.guide && result.guides && result.guides.length > 0) {
+    lines.push("", "=".repeat(60), "", "Migration Guide", "");
+    for (const guide of result.guides) {
+      const label = guide.breaking ? theme.error("BREAKING") : theme.success("non-breaking");
+      lines.push(`${theme.info(guide.packageName)} ${guide.fromVersion} -> ${guide.toVersion} [${label}]`);
+      if (guide.steps.length > 0) {
+        for (const step of guide.steps) {
+          lines.push(`  ${step}`);
+        }
+      } else {
+        lines.push(`  ${theme.muted("No migration steps available. Check release notes.")}`);
+      }
+      lines.push("");
+    }
+  } else if (options?.guide && result.updatesAvailable > 0 && !result.guides) {
+    const cwd = options.cwd ?? process.cwd();
+    const migrationsDir = findMigrationDocsDir(cwd);
+    if (migrationsDir) {
+      lines.push("", "=".repeat(60), "", "Migration Guide", "");
+      for (const pkg of result.packages) {
+        if (!(pkg.updateAvailable && pkg.latest))
+          continue;
+        const shortName = pkg.name.replace("@outfitter/", "");
+        const docs = readMigrationDocs(migrationsDir, shortName, pkg.current, pkg.latest);
+        for (const doc of docs) {
+          lines.push(doc, "", "---", "");
+        }
+      }
+    } else {
+      lines.push("", theme.muted("Migration docs not found locally. See https://github.com/outfitter-dev/outfitter for migration guides."));
+    }
+  }
+  await output(lines, { mode: "human" });
+}
+function writeUpgradeReport(cwd, result, meta) {
+  const reportsDir = join(cwd, ".outfitter", "reports");
+  mkdirSync(reportsDir, { recursive: true });
+  const finishedAtIso = new Date().toISOString();
+  const errorContext = meta.error !== undefined && "context" in meta.error && meta.error.context !== undefined && typeof meta.error.context === "object" ? meta.error.context : undefined;
+  const report = {
+    $schema: "https://outfitter.dev/reports/upgrade/v1",
+    status: meta.status,
+    checkedAt: finishedAtIso,
+    startedAt: meta.startedAt.toISOString(),
+    finishedAt: finishedAtIso,
+    cwd,
+    workspaceRoot: meta.workspaceRoot,
+    flags: {
+      dryRun: meta.options.dryRun === true,
+      yes: meta.options.yes === true,
+      interactive: meta.options.interactive !== false,
+      all: meta.options.all === true,
+      noCodemods: meta.options.noCodemods === true,
+      outputMode: meta.options.outputMode ?? null
+    },
+    applied: result.applied,
+    summary: {
+      total: result.total,
+      available: result.updatesAvailable,
+      breaking: result.packages.filter((p) => p.breaking).length,
+      applied: result.appliedPackages.length
+    },
+    packages: result.packages,
+    excluded: {
+      breaking: result.skippedBreaking
+    },
+    ...result.unknownPackages !== undefined && result.unknownPackages.length > 0 ? { unknownPackages: result.unknownPackages } : {},
+    ...result.conflicts !== undefined && result.conflicts.length > 0 ? { conflicts: result.conflicts } : {},
+    ...result.codemods !== undefined ? { codemods: result.codemods } : {},
+    ...meta.error !== undefined ? {
+      error: {
+        message: meta.error.message,
+        category: meta.error.category,
+        ...errorContext !== undefined ? { context: errorContext } : {}
+      }
+    } : {}
+  };
+  writeFileSync(join(reportsDir, "upgrade.json"), JSON.stringify(report, null, 2));
+}
+function writeUpgradeReportSafely(cwd, result, meta) {
+  try {
+    writeUpgradeReport(cwd, result, meta);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[outfitter upgrade] Failed to write report: ${reason}
+`);
+  }
+}
+
+// apps/outfitter/src/commands/upgrade-codemods.ts
+var CODEMOD_PATHS = ["plugins/outfitter/shared/codemods"];
+function findCodemodsDir(cwd, binaryDir) {
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join2(cwd, relativePath);
+    if (existsSync2(dir))
+      return dir;
+  }
+  let current = resolve2(cwd);
+  const root = resolve2("/");
+  while (current !== root) {
+    const parent = resolve2(current, "..");
+    if (parent === current)
+      break;
+    current = parent;
+    for (const relativePath of CODEMOD_PATHS) {
+      const dir = join2(current, relativePath);
+      if (existsSync2(dir))
+        return dir;
+    }
+  }
+  const resolvedBinaryDir = binaryDir ?? resolve2(import.meta.dir, "../../../..");
+  for (const relativePath of CODEMOD_PATHS) {
+    const dir = join2(resolvedBinaryDir, relativePath);
+    if (existsSync2(dir))
+      return dir;
+  }
+  return null;
+}
+function discoverCodemods(migrationsDir, codemodsDir, shortName, fromVersion, toVersion) {
+  const resolvedCodemodsDir = resolve2(codemodsDir);
+  const docs = (() => {
+    try {
+      return readMigrationDocsWithMetadata(migrationsDir, shortName, fromVersion, toVersion);
+    } catch {
+      return [];
+    }
+  })();
+  const seen = new Set;
+  const codemods = [];
+  for (const doc of docs) {
+    if (!doc.frontmatter.changes)
+      continue;
+    for (const change of doc.frontmatter.changes) {
+      if (!change.codemod)
+        continue;
+      if (seen.has(change.codemod))
+        continue;
+      seen.add(change.codemod);
+      const absolutePath = resolveCodemodPath(resolvedCodemodsDir, change.codemod);
+      if (absolutePath === null)
+        continue;
+      if (!existsSync2(absolutePath))
+        continue;
+      codemods.push({
+        relativePath: change.codemod,
+        absolutePath
+      });
+    }
+  }
+  return codemods;
+}
+function resolveCodemodPath(codemodsDir, relativePath) {
+  if (relativePath.trim().length === 0) {
+    return null;
+  }
+  if (isAbsolute(relativePath)) {
+    return null;
+  }
+  const resolvedPath = resolve2(codemodsDir, relativePath);
+  const relPath = relative(codemodsDir, resolvedPath);
+  if (relPath === "" || relPath.startsWith("..") || isAbsolute(relPath)) {
+    return null;
+  }
+  return resolvedPath;
+}
+async function runCodemod(codemodPath, targetDir, dryRun) {
+  let mod;
+  try {
+    mod = await import(codemodPath);
+  } catch (error) {
+    return Result2.err(InternalError2.create("Failed to load codemod", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+  if (typeof mod["transform"] !== "function") {
+    return Result2.err(InternalError2.create(`Codemod has no transform export: ${codemodPath}`, {
+      codemodPath
+    }));
+  }
+  const transform = mod["transform"];
+  try {
+    const result = await transform({ targetDir, dryRun });
+    if (!isCodemodResult(result)) {
+      return Result2.err(InternalError2.create("Codemod returned invalid result shape", {
+        codemodPath
+      }));
+    }
+    return Result2.ok(result);
+  } catch (error) {
+    return Result2.err(InternalError2.create("Codemod execution failed", {
+      codemodPath,
+      error: error instanceof Error ? error.message : String(error)
+    }));
+  }
+}
+function isCodemodResult(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return isStringArray(candidate["changedFiles"]) && isStringArray(candidate["skippedFiles"]) && isStringArray(candidate["errors"]);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+export { findCodemodsDir, discoverCodemods, runCodemod, findMigrationDocsDir, readMigrationDocs, readMigrationBreakingFlag, parseMigrationFrontmatter, readMigrationDocsWithMetadata, buildMigrationGuides, runUpgrade, printUpgradeResults };