outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-2z61gp5w.js

@@ -0,0 +1,29 @@
+// @bun
+// apps/outfitter/src/commands/init-option-resolution.ts
+import { Result } from "@outfitter/contracts";
+function parseBlocks(withFlag) {
+  if (!withFlag) {
+    return;
+  }
+  const blocks = withFlag.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  return blocks.length > 0 ? blocks : undefined;
+}
+function isBinaryPreset(preset) {
+  return preset === "cli" || preset === "daemon";
+}
+function isValidInitPreset(value) {
+  return value === "minimal" || value === "cli" || value === "mcp" || value === "daemon" || value === "library" || value === "full-stack";
+}
+function resolvePresetFromFlags(presetFromFlag, availablePresetIds) {
+  if (!presetFromFlag) {
+    return Result.ok(undefined);
+  }
+  const knownAvailablePresetIds = availablePresetIds.filter(isValidInitPreset);
+  const isKnownAndAvailable = isValidInitPreset(presetFromFlag) && knownAvailablePresetIds.includes(presetFromFlag);
+  if (!isKnownAndAvailable) {
+    return Result.err(`Unknown preset '${presetFromFlag}'. Available presets: ${knownAvailablePresetIds.join(", ")}`);
+  }
+  return Result.ok(presetFromFlag);
+}
+
+export { parseBlocks, isBinaryPreset, isValidInitPreset, resolvePresetFromFlags };

package/dist/shared/outfitter-34vg353f.d.ts

@@ -0,0 +1,82 @@
+import { PostScaffoldResult } from "./outfitter-hcexcvxe.js";
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+import { Command } from "commander";
+/** Options for the scaffold command, corresponding to CLI flags and positional arguments. */
+interface ScaffoldOptions {
+	/** Working directory to scaffold in. */
+	readonly cwd: string;
+	/** Preview changes without writing to disk. */
+	readonly dryRun: boolean;
+	/** Overwrite existing files without prompting. */
+	readonly force: boolean;
+	/** Timeout in milliseconds for `bun install`. */
+	readonly installTimeout?: number | undefined;
+	/** Use `workspace:*` protocol for `@outfitter` dependencies. */
+	readonly local?: boolean | undefined;
+	/** Override the default target directory name. */
+	readonly name?: string | undefined;
+	/** Skip adding default tooling blocks. */
+	readonly noTooling?: boolean | undefined;
+	/** Skip running `bun install` after scaffolding. */
+	readonly skipInstall: boolean;
+	/** Target preset ID to scaffold (e.g. "cli", "mcp"). */
+	readonly target: string;
+	/** Comma-separated tooling block names to include. */
+	readonly with?: string | undefined;
+}
+/** Result of a successful `outfitter scaffold` run. */
+interface ScaffoldCommandResult {
+	/** Tooling blocks that were added, if any. */
+	readonly blocksAdded?: AddBlockResult | undefined;
+	/** Whether the project was converted from single-package to workspace. */
+	readonly converted: boolean;
+	/** Present only for dry-run invocations; contains the planned operations and summary counts. */
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+	/** Details of the existing package that was relocated during workspace conversion. */
+	readonly movedExisting?: {
+		readonly from: string;
+		readonly to: string;
+		readonly name: string;
+	} | undefined;
+	/** Results from post-scaffold steps (install, next-step hints). */
+	readonly postScaffold: PostScaffoldResult;
+	/** Absolute path to the workspace root. */
+	readonly rootDir: string;
+	/** The target preset ID that was scaffolded. */
+	readonly target: string;
+	/** Absolute path to the scaffolded target directory. */
+	readonly targetDir: string;
+	/** Whether a new workspace pattern was added to the root package.json. */
+	readonly workspacePatternsUpdated: boolean;
+}
+/** Error returned when scaffolding fails. */
+declare class ScaffoldCommandError extends Error {
+	readonly _tag: "ScaffoldCommandError";
+	/** @param message - Human-readable description of the scaffold failure. */
+	constructor(message: string);
+}
+/**
+* Runs the full scaffold flow: detects project structure, converts to workspace
+* if needed, executes the preset plan, and performs post-scaffold steps.
+*/
+declare function runScaffold(options: ScaffoldOptions): Promise<Result<ScaffoldCommandResult, ScaffoldCommandError>>;
+/**
+* Registers the `scaffold` command on a Commander program.
+* @deprecated Use action-registry CLI wiring via `buildCliCommands(outfitterActions, ...)`.
+*/
+declare function scaffoldCommand(program: Command): void;
+/** Options controlling how scaffold results are rendered (human-readable, JSON, or JSONL). */
+interface PrintScaffoldResultsOptions {
+	readonly mode?: OutputMode;
+}
+/**
+* Renders scaffold results to stdout. Handles dry-run plans, structured output modes,
+* and human-readable summaries including workspace conversion details and next steps.
+*/
+declare function printScaffoldResults(result: ScaffoldCommandResult, options?: PrintScaffoldResultsOptions): Promise<void>;
+export { PrintScaffoldResultsOptions, printScaffoldResults, ScaffoldOptions, ScaffoldCommandResult, ScaffoldCommandError, runScaffold, scaffoldCommand };

package/dist/shared/{outfitter-5yjr404v.d.ts → outfitter-3dq4r10s.d.ts}

@@ -1,5 +1,7 @@
-import { ExecuteCheckCommandOptions, ExecuteExportCommandOptions, ExecuteSyncCommandOptions } from "./outfitter-6fgk6adm.js";
+import { ExecuteCheckCommandOptions, ExecuteExportCommandOptions, ExecuteSyncCommandOptions } from "./outfitter-1tfa9hke.js";
 import { Command } from "commander";
+declare const DOCS_COMMON_OPTION_FLAGS: readonly ["--cwd <path>", "--packages-dir <path>", "--output-dir <path>", "--mdx-mode <mode>"];
+declare const DOCS_EXPORT_OPTION_FLAGS: readonly ["--llms-file <path>", "--llms-full-file <path>", "--target <target>"];
 type RepoCheckSubject = "docs" | "exports" | "readme" | "registry" | "changeset" | "tree" | "boundary-invocations";
 interface RepoCommandIo {
 	readonly err?: (line: string) => void;
@@ -7,7 +9,7 @@ interface RepoCommandIo {
 }
 interface RepoToolingInvocation {
 	readonly args: readonly string[];
-	readonly command: "check-exports" | "check-readme-imports" | "check-bunup-registry" | "check-changeset" | "check-clean-tree" | "check-boundary-invocations";
+	readonly command: "check-exports" | "check-readme-imports" | "check-bunup-registry" | "check-changeset" | "check-clean-tree" | "check-boundary-invocations" | "check-markdown-links";
 	readonly cwd: string;
 }
 interface CreateRepoCommandOptions {
@@ -19,4 +21,4 @@ interface CreateRepoCommandOptions {
 	readonly runToolingCommand?: (input: RepoToolingInvocation) => Promise<number>;
 }
 declare function createRepoCommand(options?: CreateRepoCommandOptions): Command;
-export { RepoCheckSubject, RepoCommandIo, RepoToolingInvocation, CreateRepoCommandOptions, createRepoCommand };
+export { DOCS_COMMON_OPTION_FLAGS, DOCS_EXPORT_OPTION_FLAGS, RepoCheckSubject, RepoCommandIo, RepoToolingInvocation, CreateRepoCommandOptions, createRepoCommand };

package/dist/shared/outfitter-3rcrvva8.js

@@ -0,0 +1,103 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveCwdFromPreset
+} from "./outfitter-7n7vsz95.js";
+import {
+  listBlocks,
+  printAddResults,
+  runAdd
+} from "./outfitter-3tx3adgj.js";
+import {
+  resolveOutputModeFromContext,
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/add.ts
+import { output } from "@outfitter/cli";
+import { actionCliPresets } from "@outfitter/cli/actions";
+import { cwdPreset, dryRunPreset, forcePreset } from "@outfitter/cli/flags";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var addInputSchema = z.object({
+  block: z.string(),
+  force: z.boolean(),
+  dryRun: z.boolean(),
+  cwd: z.string().optional(),
+  outputMode: outputModeSchema
+});
+var addSharedFlags = actionCliPresets(forcePreset(), dryRunPreset());
+var addCwd = cwdPreset();
+var addAction = defineAction({
+  id: "add",
+  description: "Add a block from the registry to your project",
+  surfaces: ["cli"],
+  input: addInputSchema,
+  cli: {
+    group: "add",
+    command: "<block>",
+    description: "Add a block from the registry (claude, linter, lefthook, bootstrap, scaffolding)",
+    options: [...addSharedFlags.options, ...addCwd.options],
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      const { force, dryRun } = addSharedFlags.resolve(context);
+      return {
+        block: context.args[0],
+        force,
+        dryRun,
+        cwd: resolveCwdFromPreset(context.flags, addCwd),
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, cwd, ...addInput } = input;
+    const result = await runAdd({
+      ...addInput,
+      ...cwd !== undefined ? { cwd } : {}
+    });
+    if (result.isErr()) {
+      return actionInternalErr("add", result.error);
+    }
+    await printAddResults(result.value, addInput.dryRun, { mode: outputMode });
+    return Result.ok(result.value);
+  }
+});
+var listBlocksInputSchema = z.object({ outputMode: outputModeSchema });
+var listBlocksAction = defineAction({
+  id: "add.list",
+  description: "List available blocks",
+  surfaces: ["cli"],
+  input: listBlocksInputSchema,
+  cli: {
+    group: "add",
+    command: "list",
+    description: "List available blocks",
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      return {
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const result = listBlocks();
+    if (result.isErr()) {
+      return actionInternalErr("add.list", result.error);
+    }
+    const structuredMode = resolveStructuredOutputMode(input.outputMode);
+    if (structuredMode) {
+      await output({ blocks: result.value }, { mode: structuredMode });
+    } else {
+      const lines = [
+        "Available blocks:",
+        ...result.value.map((block) => `  - ${block}`)
+      ];
+      await output(lines, { mode: "human" });
+    }
+    return Result.ok({ blocks: result.value });
+  }
+});
+
+export { addAction, listBlocksAction };

package/dist/shared/{outfitter-79vfxt6y.js → outfitter-3tx3adgj.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   stampBlock
-} from "./outfitter-mtbpabf3.js";
+} from "./outfitter-ypcvwg1s.js";
 import {
   resolveStructuredOutputMode
 } from "./outfitter-7r12fj7f.js";
@@ -18,7 +18,6 @@ import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
 import { output } from "@outfitter/cli";
 import { Result } from "@outfitter/contracts";
-import { RegistrySchema } from "@outfitter/tooling";
 class AddError extends Error {
   _tag = "AddError";
   constructor(message) {
@@ -52,12 +51,22 @@ function readToolingVersion(registryPath) {
     return "unknown";
   }
 }
+function isRegistryLike(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return !!record["blocks"] && typeof record["blocks"] === "object";
+}
 function loadRegistry() {
   try {
     const registryPath = getRegistryPath();
     const content = readFileSync(registryPath, "utf-8");
     const parsed = JSON.parse(content);
-    const registry = RegistrySchema.parse(parsed);
+    if (!isRegistryLike(parsed)) {
+      return Result.err(new AddError("Failed to load registry: invalid registry shape"));
+    }
+    const registry = parsed;
     const toolingVersion = readToolingVersion(registryPath);
     return Result.ok({ registry, toolingVersion });
   } catch (error) {

package/dist/shared/{outfitter-63gse8fv.js → outfitter-507ra35w.js}

@@ -1,4 +1,8 @@
 // @bun
+import {
+  applyJq
+} from "./outfitter-5vx1bp7h.js";
+
 // apps/outfitter/src/commands/check-tsdoc.ts
 import { existsSync, readFileSync } from "fs";
 import { createRequire } from "module";
@@ -106,7 +110,7 @@ function discoverPathsFromEntrypoints(cwd, entrypoints) {
       paths.add(derivePackagePathFromEntrypoint(match));
     }
   }
-  return [...paths].sort();
+  return [...paths].toSorted();
 }
 function formatDiscoveryMessage(entrypoints, source) {
   const patterns = entrypoints.join(", ");
@@ -154,7 +158,7 @@ function emitJsonlLines(result, summary) {
   const lines = [];
   lines.push({ type: "meta", version: "1.0.0", ok: result.ok });
   lines.push({ type: "summary", ...result.summary });
-  const sortedPackages = [...result.packages].sort((a, b) => a.name.localeCompare(b.name));
+  const sortedPackages = [...result.packages].toSorted((a, b) => a.name.localeCompare(b.name));
   for (const pkg of sortedPackages) {
     lines.push({
       type: "package",
@@ -190,43 +194,6 @@ function normalizeJsonlRecord(text) {
     return JSON.stringify(text);
   }
 }
-async function applyJq(data, expr, options) {
-  try {
-    const json = JSON.stringify(data);
-    const args = ["jq", ...options?.compact ? ["-c"] : [], expr];
-    const proc = Bun.spawn(args, {
-      stdin: new Response(json),
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    if (exitCode !== 0) {
-      process.stderr.write(`jq error: ${stderr.trim()}
-`);
-      return options?.compact ? `${JSON.stringify(data)}
-` : `${JSON.stringify(data, null, 2)}
-`;
-    }
-    return stdout;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "unknown jq execution error";
-    const missingBinary = /enoent|not found/i.test(message);
-    if (missingBinary) {
-      process.stderr.write(`jq is not installed. Install jq or omit --jq to continue.
-`);
-    } else {
-      process.stderr.write(`jq execution error: ${message}
-`);
-    }
-    return options?.compact ? `${JSON.stringify(data)}
-` : `${JSON.stringify(data, null, 2)}
-`;
-  }
-}
 var toolingCheckTsdocModule;
 function resolveToolingEntrypoint() {
   const packageJsonPath = require2.resolve("@outfitter/tooling/package.json");
@@ -274,37 +241,39 @@ async function runCheckTsdoc(input) {
       minCoverage: input.minCoverage
     }) : rawResult;
     const outputData = input.summary ? summarizeResult(filteredResult) : filteredResult;
-    if (input.outputMode === "jsonl") {
-      const lines = emitJsonlLines(filteredResult, input.summary);
-      if (input.jq) {
-        for (const line of lines) {
-          const filtered = await applyJq(line, input.jq, { compact: true });
-          for (const rawLine of filtered.split(/\r?\n/)) {
-            const trimmed = rawLine.trim();
-            if (!trimmed) {
-              continue;
+    if (input.emitOutput !== false) {
+      if (input.outputMode === "jsonl") {
+        const lines = emitJsonlLines(filteredResult, input.summary);
+        if (input.jq) {
+          for (const line of lines) {
+            const filtered = await applyJq(line, input.jq, { compact: true });
+            for (const rawLine of filtered.split(/\r?\n/)) {
+              const trimmed = rawLine.trim();
+              if (!trimmed) {
+                continue;
+              }
+              process.stdout.write(`${normalizeJsonlRecord(trimmed)}
+`);
             }
-            process.stdout.write(`${normalizeJsonlRecord(trimmed)}
+          }
+        } else {
+          for (const line of lines) {
+            process.stdout.write(`${JSON.stringify(line)}
 `);
           }
         }
-      } else {
-        for (const line of lines) {
-          process.stdout.write(`${JSON.stringify(line)}
+      } else if (input.jq) {
+        const filtered = await applyJq(outputData, input.jq);
+        process.stdout.write(filtered);
+      } else if (input.outputMode === "json") {
+        process.stdout.write(`${JSON.stringify(outputData, null, 2)}
 `);
-        }
+      } else {
+        tooling.printCheckTsdocHuman(outputData, {
+          strict: input.strict,
+          minCoverage: input.minCoverage
+        });
       }
-    } else if (input.jq) {
-      const filtered = await applyJq(outputData, input.jq);
-      process.stdout.write(filtered);
-    } else if (input.outputMode === "json") {
-      process.stdout.write(`${JSON.stringify(outputData, null, 2)}
-`);
-    } else {
-      tooling.printCheckTsdocHuman(outputData, {
-        strict: input.strict,
-        minCoverage: input.minCoverage
-      });
     }
     return Result.ok(outputData);
   } catch (error) {

package/dist/shared/outfitter-56jq0rh2.d.ts

@@ -0,0 +1,42 @@
+import { MigrationFrontmatter } from "./outfitter-y37yfehn.js";
+/** A migration doc with parsed frontmatter and body content. */
+interface MigrationDocWithMetadata {
+	readonly body: string;
+	readonly frontmatter: MigrationFrontmatter;
+	readonly version: string;
+}
+/**
+* Find migration docs directory, checking known locations.
+*
+* Searches:
+* 1. Relative to the target cwd
+* 2. Walking up parent directories from cwd (monorepo root detection)
+* 3. Relative to the outfitter binary itself (development mode)
+*/
+declare function findMigrationDocsDir(cwd: string, binaryDir?: string): string | null;
+/**
+* Read all migration docs for a package between two versions.
+*
+* Scans the migrations directory for docs matching the package name,
+* filters to versions greater than `fromVersion` and at most `toVersion`,
+* and returns their contents sorted by version ascending.
+*/
+declare function readMigrationDocs(migrationsDir: string, shortName: string, fromVersion: string, toVersion: string): string[];
+/**
+* Read the `breaking` flag for an exact migration doc version, if present.
+*
+* Returns:
+* - `true` or `false` when the frontmatter contains `breaking: ...`
+* - `undefined` when the doc is missing, unreadable, or has no valid flag
+*/
+declare function readMigrationBreakingFlag(migrationsDir: string, shortName: string, version: string): boolean | undefined;
+/**
+* Read all migration docs for a package between two versions,
+* returning parsed frontmatter alongside the body content.
+*
+* Like `readMigrationDocs` but returns structured metadata instead of
+* plain strings. Used by the codemod infrastructure to discover
+* machine-actionable changes.
+*/
+declare function readMigrationDocsWithMetadata(migrationsDir: string, shortName: string, fromVersion: string, toVersion: string): MigrationDocWithMetadata[];
+export { MigrationDocWithMetadata, findMigrationDocsDir, readMigrationDocs, readMigrationBreakingFlag, readMigrationDocsWithMetadata };

package/dist/shared/{outfitter-r419zfgs.d.ts → outfitter-58rn1sj1.d.ts}

@@ -23,8 +23,8 @@ interface TargetDefinition {
 	readonly description: string;
 	readonly id: TargetId;
 	readonly placement: "apps" | "packages";
+	readonly presetDir: string;
 	readonly scope: TargetScope;
 	readonly status: TargetStatus;
-	readonly templateDir: string;
 }
 export { TargetId, TargetCategory, TargetStatus, TargetScope, TargetDefinition };

package/dist/shared/outfitter-5d9wbzhh.d.ts

@@ -0,0 +1,19 @@
+import { TargetId } from "./outfitter-58rn1sj1.js";
+import { Result } from "@outfitter/contracts";
+/** Subset of target IDs that are valid presets for `outfitter init`. */
+type InitPresetId = Extract<TargetId, "minimal" | "cli" | "mcp" | "daemon" | "library" | "full-stack">;
+/**
+* Parses a comma-separated `--with` flag value into an array of block names.
+* @returns The parsed block names, or `undefined` if the flag is empty/absent.
+*/
+declare function parseBlocks(withFlag: string | undefined): readonly string[] | undefined;
+/** Returns `true` if the preset produces a project with a binary entry point. */
+declare function isBinaryPreset(preset: InitPresetId): boolean;
+/** Type guard that narrows a string to {@link InitPresetId}. */
+declare function isValidInitPreset(value: string): value is InitPresetId;
+/**
+* Validates and resolves a `--preset` flag value against the available preset list.
+* @returns The validated preset ID, `undefined` if no flag was provided, or an error for unknown presets.
+*/
+declare function resolvePresetFromFlags(presetFromFlag: string | undefined, availablePresetIds: readonly string[]): Result<InitPresetId | undefined, string>;
+export { InitPresetId, parseBlocks, isBinaryPreset, isValidInitPreset, resolvePresetFromFlags };

package/dist/shared/outfitter-5j7zee11.d.ts

@@ -0,0 +1,180 @@
+import { VersionConflict } from "./outfitter-109s75x0.js";
+import { MigrationChange } from "./outfitter-y37yfehn.js";
+import { OutputMode as OutputMode3 } from "@outfitter/cli/types";
+import { OutfitterError as OutfitterError2 } from "@outfitter/contracts";
+import { Result } from "@outfitter/contracts";
+import { OutputMode } from "@outfitter/cli/types";
+/** Options controlling how upgrade results are rendered. */
+interface PrintUpgradeResultsOptions {
+	readonly all?: boolean;
+	readonly cwd?: string;
+	readonly dryRun?: boolean;
+	readonly guide?: boolean;
+	readonly mode?: OutputMode;
+}
+/**
+* Format and output upgrade results.
+*
+* @param result - Upgrade scan/apply result to render
+* @param options - Display options (output mode, guide, dry-run hints)
+*/
+declare function printUpgradeResults(result: UpgradeResult, options?: PrintUpgradeResultsOptions): Promise<void>;
+import { OutputMode as OutputMode2 } from "@outfitter/cli/types";
+import { OutfitterError } from "@outfitter/contracts";
+/** Terminal disposition of an upgrade run (written into the report). */
+type UpgradeReportStatus = "dry_run" | "no_updates" | "cancelled" | "skipped_non_interactive" | "applied" | "failed";
+/** Snapshot of effective flags for this upgrade run. */
+interface UpgradeReportFlags {
+	readonly all: boolean;
+	readonly dryRun: boolean;
+	readonly interactive: boolean;
+	readonly noCodemods: boolean;
+	readonly outputMode: OutputMode2 | null;
+	readonly yes: boolean;
+}
+/** Machine-readable upgrade report written to `.outfitter/reports/upgrade.json`. */
+interface UpgradeReport {
+	readonly $schema: "https://outfitter.dev/reports/upgrade/v1";
+	readonly applied: boolean;
+	readonly checkedAt: string;
+	readonly codemods?: CodemodSummary;
+	readonly conflicts?: readonly VersionConflict[];
+	readonly cwd: string;
+	readonly error?: {
+		readonly message: string;
+		readonly category: string;
+		readonly context?: Record<string, unknown>;
+	};
+	readonly excluded: {
+		readonly breaking: readonly string[];
+	};
+	readonly finishedAt: string;
+	readonly flags: UpgradeReportFlags;
+	readonly packages: readonly PackageVersionInfo[];
+	readonly startedAt: string;
+	readonly status: UpgradeReportStatus;
+	readonly summary: {
+		readonly total: number;
+		readonly available: number;
+		readonly breaking: number;
+		readonly applied: number;
+	};
+	readonly unknownPackages?: readonly string[];
+	readonly workspaceRoot: string | null;
+}
+/** Contextual metadata passed alongside the result when writing a report. */
+interface WriteUpgradeReportMeta {
+	readonly error?: OutfitterError;
+	readonly options: UpgradeOptions;
+	readonly startedAt: Date;
+	readonly status: UpgradeReportStatus;
+	readonly workspaceRoot: string | null;
+}
+/**
+* Best-effort report writer.
+*
+* Report I/O failures should not change the primary command result.
+*/
+declare function writeUpgradeReportSafely(cwd: string, result: UpgradeResult, meta: WriteUpgradeReportMeta): void;
+/** Input options for `runUpgrade`. */
+interface UpgradeOptions {
+	/** Include breaking changes in the upgrade */
+	readonly all?: boolean;
+	/** Working directory (defaults to cwd) */
+	readonly cwd: string;
+	/** Preview only — no mutations, no prompt */
+	readonly dryRun?: boolean;
+	/** Show migration guide */
+	readonly guide?: boolean;
+	/** Filter to specific package names (scan + guides) */
+	readonly guidePackages?: readonly string[];
+	/** Whether interactive prompts are enabled (false in CI) */
+	readonly interactive?: boolean;
+	/** Skip automatic codemod execution during upgrade */
+	readonly noCodemods?: boolean;
+	/** Output mode */
+	readonly outputMode?: OutputMode3;
+	/** Auto-confirm without prompting */
+	readonly yes?: boolean;
+}
+/** Version metadata for a single installed @outfitter/* package. */
+interface PackageVersionInfo {
+	/** Whether the update contains breaking changes (major bump) */
+	readonly breaking: boolean;
+	/** Currently installed version */
+	readonly current: string;
+	/** Latest available version from npm (null if query failed) */
+	readonly latest: string | null;
+	/** Full package name */
+	readonly name: string;
+	/** Whether an update is available */
+	readonly updateAvailable: boolean;
+}
+/** Summary of codemods executed during --apply. */
+interface CodemodSummary {
+	/** Total files changed across all codemods */
+	readonly changedFiles: readonly string[];
+	/** Number of codemods executed */
+	readonly codemodCount: number;
+	/** Errors encountered during codemod execution */
+	readonly errors: readonly string[];
+}
+/** Complete output of a single upgrade run. */
+interface UpgradeResult {
+	/** Whether mutations were made (--apply was used and changes were written) */
+	readonly applied: boolean;
+	/** Package names that were updated in package.json */
+	readonly appliedPackages: string[];
+	/** Codemod execution summary (populated when --apply runs codemods) */
+	readonly codemods?: CodemodSummary;
+	/** Version conflicts found across workspace manifests */
+	readonly conflicts?: readonly VersionConflict[];
+	/** Structured migration guides (populated when --guide is used) */
+	readonly guides?: readonly MigrationGuide[];
+	/** Whether any update is a breaking change */
+	readonly hasBreaking: boolean;
+	/** Package version info */
+	readonly packages: PackageVersionInfo[];
+	/** Package names skipped because they contain breaking changes */
+	readonly skippedBreaking: string[];
+	/** Total packages checked */
+	readonly total: number;
+	/** Package names that were requested but not found in the workspace */
+	readonly unknownPackages?: readonly string[];
+	/** Number of packages with updates available */
+	readonly updatesAvailable: number;
+}
+/**
+* Run the upgrade command — detect installed versions and query npm for latest.
+*
+* Default flow: scan → classify → prompt → apply.
+* `--dry-run` returns a report without mutation.
+* `--all` includes breaking changes.
+* `--yes` or `--non-interactive` bypasses the prompt.
+*/
+declare function runUpgrade(options: UpgradeOptions): Promise<Result<UpgradeResult, OutfitterError2>>;
+type GuidePackageVersionInfo = PackageVersionInfo;
+/** Structured migration guide for a single package upgrade. */
+interface MigrationGuide {
+	/** Whether this is a breaking change */
+	readonly breaking: boolean;
+	/** Structured changes from migration frontmatter, if available */
+	readonly changes?: readonly MigrationChange[];
+	/** Currently installed version */
+	readonly fromVersion: string;
+	/** The @outfitter/* package name */
+	readonly packageName: string;
+	/** Migration step strings (empty if no guide exists) */
+	readonly steps: readonly string[];
+	/** Latest available version */
+	readonly toVersion: string;
+}
+/**
+* Build structured migration guides for packages with available updates.
+*
+* For each package with an update, produces a `MigrationGuide` with steps
+* extracted from migration docs (if a migrations directory is available).
+* Packages without updates or without a resolved latest version are skipped.
+*/
+declare function buildMigrationGuides(packages: readonly GuidePackageVersionInfo[], migrationsDir: string | null): MigrationGuide[];
+export { MigrationGuide, buildMigrationGuides, PrintUpgradeResultsOptions, printUpgradeResults, UpgradeOptions, PackageVersionInfo, CodemodSummary, UpgradeResult, runUpgrade, UpgradeReportStatus, UpgradeReportFlags, UpgradeReport, WriteUpgradeReportMeta, writeUpgradeReportSafely };

package/dist/shared/{outfitter-s7jetkge.d.ts → outfitter-5r6q2749.d.ts}

@@ -1,4 +1,4 @@
-import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "./outfitter-r419zfgs.js";
+import { TargetCategory, TargetDefinition, TargetId, TargetScope, TargetStatus } from "./outfitter-58rn1sj1.js";
 import { NotFoundError, Result, ValidationError } from "@outfitter/contracts";
 declare const TARGET_REGISTRY: ReadonlyMap<TargetId, TargetDefinition>;
 declare const TARGET_IDS: readonly TargetId[];