outfitter 0.3.2 → 0.3.4

package/dist/shared/outfitter-x4cc5xsq.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  findMigrationDocsDir,
+  readMigrationDocs
+} from "./outfitter-fx1m251y.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/upgrade-output.ts
+import { output } from "@outfitter/cli";
+import { createTheme } from "@outfitter/tui/render";
+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)
+    ].toSorted();
+    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" });
+}
+
+export { printUpgradeResults };

package/dist/shared/outfitter-x8w5sjnd.d.ts

@@ -0,0 +1,39 @@
+import { CliOutputMode } from "./outfitter-a79xrm12.js";
+import { DocsExportTarget, loadDocsModule } from "./outfitter-1tfa9hke.js";
+import { InternalError, Result } from "@outfitter/contracts";
+/** Validated input for the docs.action handler. */
+interface DocsExportInput {
+	readonly cwd: string;
+	readonly outputMode: CliOutputMode;
+	readonly target: DocsExportTarget;
+}
+/** Output shape for the docs.action. */
+interface DocsExportOutput {
+	readonly exitCode: number;
+	readonly messages: string[];
+	readonly target: string;
+	readonly warnings: string[];
+}
+interface DocsExportDependencies {
+	readonly loadDocsModule?: typeof loadDocsModule;
+}
+/**
+* Export documentation to the specified target format.
+*
+* Delegates to `executeExportCommand` from "@outfitter/docs" via the
+* dynamic module loader.
+*
+* @param input - Validated action input
+* @returns Result containing the output or an error
+*/
+declare function runDocsExport(input: DocsExportInput, dependencies?: DocsExportDependencies): Promise<Result<DocsExportOutput, InternalError>>;
+/**
+* Print docs results in the appropriate output format.
+*
+* @param result - The docs output
+* @param options - Output formatting options
+*/
+declare function printDocsExportResults(result: DocsExportOutput, options?: {
+	mode?: CliOutputMode;
+}): Promise<void>;
+export { DocsExportInput, DocsExportOutput, runDocsExport, printDocsExportResults };

package/dist/shared/outfitter-xr6g13nz.d.ts

@@ -0,0 +1,50 @@
+type Operation = {
+	readonly type: "file-create";
+	readonly path: string;
+	readonly source: "preset" | "block" | "generated";
+} | {
+	readonly type: "file-overwrite";
+	readonly path: string;
+	readonly source: "preset" | "block" | "generated";
+} | {
+	readonly type: "file-skip";
+	readonly path: string;
+	readonly reason: string;
+} | {
+	readonly type: "dir-create";
+	readonly path: string;
+} | {
+	readonly type: "dependency-add";
+	readonly name: string;
+	readonly version: string;
+	readonly section: "dependencies" | "devDependencies" | "peerDependencies";
+} | {
+	readonly type: "block-add";
+	readonly name: string;
+	readonly files: readonly string[];
+} | {
+	readonly type: "config-inject";
+	readonly target: string;
+	readonly description: string;
+} | {
+	readonly type: "git";
+	readonly action: "init" | "add-all" | "commit";
+	readonly cwd: string;
+	readonly message?: string | undefined;
+} | {
+	readonly type: "install";
+	readonly command: string;
+	readonly cwd: string;
+};
+declare class OperationCollector {
+	private readonly operations;
+	add(op: Operation): void;
+	getOperations(): readonly Operation[];
+	countByType(): Record<string, number>;
+	isEmpty(): boolean;
+	toJSON(): {
+		operations: readonly Operation[];
+		summary: Record<string, number>;
+	};
+}
+export { Operation, OperationCollector };

package/dist/shared/outfitter-xs94pkfe.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveBooleanFlagAlias,
+  resolveInstallTimeoutFlag,
+  resolveLocalFlag,
+  resolveNoToolingFlag,
+  resolveStringFlag
+} from "./outfitter-7n7vsz95.js";
+import {
+  runScaffold
+} from "./outfitter-6ddf91vh.js";
+import {
+  printScaffoldResults
+} from "./outfitter-qsrx7m4w.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/scaffold.ts
+import { actionCliPresets } from "@outfitter/cli/actions";
+import { dryRunPreset, forcePreset } from "@outfitter/cli/flags";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var scaffoldInputSchema = z.object({
+  target: z.string(),
+  name: z.string().optional(),
+  force: z.boolean(),
+  skipInstall: z.boolean(),
+  dryRun: z.boolean(),
+  with: z.string().optional(),
+  noTooling: z.boolean().optional(),
+  local: z.boolean().optional(),
+  installTimeout: z.number().optional(),
+  cwd: z.string(),
+  outputMode: outputModeSchema
+});
+var scaffoldSharedFlags = actionCliPresets(forcePreset(), dryRunPreset());
+function resolveScaffoldOptions(context) {
+  const flags = context.flags;
+  const { force, dryRun } = scaffoldSharedFlags.resolve(context);
+  const outputMode = resolveOutputModeFromContext(context.flags);
+  const noTooling = resolveNoToolingFlag(flags);
+  const local = resolveLocalFlag(flags);
+  const installTimeout = resolveInstallTimeoutFlag(flags.installTimeout);
+  return {
+    target: String(context.args[0] ?? ""),
+    name: resolveStringFlag(context.args[1]),
+    force,
+    skipInstall: resolveBooleanFlagAlias(context.flags, "skipInstall", "skip-install"),
+    dryRun,
+    ...local !== undefined ? { local } : {},
+    with: resolveStringFlag(flags.with),
+    ...noTooling !== undefined ? { noTooling } : {},
+    ...installTimeout !== undefined ? { installTimeout } : {},
+    cwd: process.cwd(),
+    outputMode
+  };
+}
+var scaffoldAction = defineAction({
+  id: "scaffold",
+  description: "Add a capability to an existing project",
+  surfaces: ["cli"],
+  input: scaffoldInputSchema,
+  cli: {
+    command: "scaffold <target> [name]",
+    description: "Add a capability (cli, mcp, daemon, lib, ...) to an existing project",
+    options: [
+      ...scaffoldSharedFlags.options,
+      {
+        flags: "--skip-install",
+        description: "Skip bun install",
+        defaultValue: false
+      },
+      {
+        flags: "--with <blocks>",
+        description: "Comma-separated tooling blocks to add"
+      },
+      {
+        flags: "--no-tooling",
+        description: "Skip default tooling blocks"
+      },
+      {
+        flags: "--local",
+        description: "Use workspace:* for @outfitter dependencies"
+      },
+      {
+        flags: "--install-timeout <ms>",
+        description: "bun install timeout in milliseconds"
+      }
+    ],
+    mapInput: resolveScaffoldOptions
+  },
+  handler: async (input) => {
+    const { outputMode, ...scaffoldInput } = input;
+    const result = await runScaffold(scaffoldInput);
+    if (result.isErr()) {
+      return actionInternalErr("scaffold", result.error);
+    }
+    await printScaffoldResults(result.value, { mode: outputMode });
+    return Result.ok(result.value);
+  }
+});
+
+export { scaffoldAction };