outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-fj2v5ffz.js

@@ -0,0 +1,165 @@
+// @bun
+import {
+  loadDocsModule
+} from "./outfitter-svts4wk2.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-docs-sentinel.ts
+import { readFile } from "fs/promises";
+import { join, resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var SECTION_ID = "PACKAGE_LIST";
+var BEGIN_TAG = `<!-- BEGIN:GENERATED:${SECTION_ID} -->`;
+var END_TAG = `<!-- END:GENERATED:${SECTION_ID} -->`;
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function replaceSentinelSectionFallback(input, sentinelId, replacement) {
+  const beginTag = `<!-- BEGIN:GENERATED:${sentinelId} -->`;
+  const endTag = `<!-- END:GENERATED:${sentinelId} -->`;
+  const pattern = new RegExp(`${escapeRegExpLiteral(beginTag)}[\\s\\S]*?${escapeRegExpLiteral(endTag)}`);
+  if (!pattern.test(input)) {
+    return input;
+  }
+  return input.replace(pattern, `${beginTag}
+${replacement}
+${endTag}`);
+}
+function extractSentinelBodies(input, sentinelId) {
+  const beginTag = `<!-- BEGIN:GENERATED:${sentinelId} -->`;
+  const endTag = `<!-- END:GENERATED:${sentinelId} -->`;
+  const pattern = new RegExp(`${escapeRegExpLiteral(beginTag)}[\\s\\n\\r]*([\\s\\S]*?)[\\s\\n\\r]*${escapeRegExpLiteral(endTag)}`, "g");
+  const bodies = [];
+  for (const match of input.matchAll(pattern)) {
+    const body = match[1];
+    if (typeof body === "string") {
+      bodies.push(body);
+    }
+  }
+  return bodies;
+}
+
+class CheckDocsSentinelError extends Error {
+  _tag = "CheckDocsSentinelError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckDocsSentinelError";
+  }
+}
+function checkDocsReadmeSentinelContent(readmeContent, packageListContent, replaceSentinelSection = replaceSentinelSectionFallback) {
+  if (!(readmeContent.includes(BEGIN_TAG) && readmeContent.includes(END_TAG))) {
+    return { reason: "missing-markers", updatedContent: readmeContent };
+  }
+  const currentBodies = extractSentinelBodies(readmeContent, SECTION_ID);
+  const expectedBody = packageListContent.trim();
+  if (currentBodies.length > 0 && currentBodies.every((body) => body.trim() === expectedBody)) {
+    return { reason: "up-to-date", updatedContent: readmeContent };
+  }
+  const updatedContent = replaceSentinelSection(readmeContent, SECTION_ID, packageListContent);
+  if (updatedContent !== readmeContent) {
+    return { reason: "out-of-date", updatedContent };
+  }
+  return { reason: "up-to-date", updatedContent };
+}
+async function runCheckDocsSentinel(options) {
+  try {
+    const workspaceRoot = resolve(options.cwd);
+    const readmePath = join(workspaceRoot, "docs", "README.md");
+    const docsModule = await loadDocsModule();
+    const [readmeContent, packageListContent] = await Promise.all([
+      readFile(readmePath, "utf8"),
+      docsModule.generatePackageListSection(workspaceRoot)
+    ]);
+    const result = checkDocsReadmeSentinelContent(readmeContent, packageListContent, docsModule.replaceSentinelSection);
+    return Result.ok({
+      readmePath,
+      reason: result.reason,
+      updatedContent: result.updatedContent,
+      ok: result.reason === "up-to-date"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check docs README sentinel";
+    return Result.err(new CheckDocsSentinelError(message));
+  }
+}
+async function printCheckDocsSentinelResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  if (result.reason === "up-to-date") {
+    process.stdout.write(`docs/README.md PACKAGE_LIST sentinel is up to date.
+`);
+    return;
+  }
+  if (result.reason === "missing-markers") {
+    process.stderr.write(`docs/README.md is missing PACKAGE_LIST sentinel markers.
+Run 'bun run docs:sync:readme' to regenerate sentinel sections.
+`);
+    return;
+  }
+  process.stderr.write(`docs/README.md PACKAGE_LIST sentinel is stale.
+Run 'bun run docs:sync:readme' to regenerate sentinel sections.
+`);
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckDocsSentinelError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckDocsSentinelFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckDocsSentinel({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckDocsSentinelResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckDocsSentinelFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckDocsSentinelError, checkDocsReadmeSentinelContent, runCheckDocsSentinel, printCheckDocsSentinelResult, runCheckDocsSentinelFromArgv };

package/dist/shared/outfitter-fx1m251y.js

@@ -0,0 +1,122 @@
+// @bun
+import {
+  parseMigrationFrontmatter,
+  stripMigrationFrontmatter
+} from "./outfitter-s1c0whzj.js";
+
+// apps/outfitter/src/commands/upgrade-migration-docs.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+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 = stripMigrationFrontmatter(content);
+    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;
+}
+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 = stripMigrationFrontmatter(content);
+    docs.push({ frontmatter, body, version: docVersion });
+  }
+  docs.sort((a, b) => Bun.semver.order(a.version, b.version));
+  return docs;
+}
+
+export { findMigrationDocsDir, readMigrationDocs, readMigrationBreakingFlag, readMigrationDocsWithMetadata };

package/dist/shared/outfitter-fxry5n58.js

@@ -0,0 +1,254 @@
+// @bun
+import {
+  applyUpdatesToWorkspace,
+  getInstalledPackagesFromWorkspace,
+  runInstall
+} from "./outfitter-76k25svs.js";
+import {
+  buildMigrationGuides
+} from "./outfitter-jwxggvz4.js";
+import {
+  applyUpdates
+} from "./outfitter-f3a70135.js";
+import {
+  analyzeUpgrades
+} from "./outfitter-bpr28y54.js";
+import {
+  getLatestVersion
+} from "./outfitter-n13pqaft.js";
+import {
+  discoverCodemods,
+  findCodemodsDir,
+  runCodemod
+} from "./outfitter-x0vpb7tj.js";
+import {
+  findMigrationDocsDir,
+  readMigrationBreakingFlag
+} from "./outfitter-fx1m251y.js";
+import {
+  writeUpgradeReportSafely
+} from "./outfitter-7q9fnbwa.js";
+import {
+  __require
+} from "./outfitter-eepj7rf7.js";
+
+// apps/outfitter/src/commands/upgrade.ts
+import { resolve } from "path";
+import { InternalError, Result } from "@outfitter/contracts";
+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);
+  }
+}
+
+export { runUpgrade };

package/dist/shared/outfitter-g3hvjshg.js

@@ -0,0 +1 @@
+export { getInitTarget, getReadyTarget, getScaffoldTarget, getTarget, INIT_TARGET_IDS, listTargets, READY_TARGET_IDS, resolvePlacement, SCAFFOLD_TARGET_IDS, TARGET_IDS, TARGET_REGISTRY } from "./registry.js";

package/dist/shared/{outfitter-f9znfhkn.d.ts → outfitter-gdc7b7de.d.ts}

@@ -1,4 +1,4 @@
-import { ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { ScaffoldError } from "./outfitter-cyvr4r8d.js";
 import { Result } from "@outfitter/contracts";
 declare function injectSharedConfig(targetDir: string): Result<void, ScaffoldError>;
 declare function rewriteLocalDependencies(targetDir: string): Result<void, ScaffoldError>;