outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-qsrx7m4w.js

@@ -0,0 +1,72 @@
+// @bun
+import {
+  renderOperationPlan
+} from "./outfitter-ttjr95y9.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/scaffold-output.ts
+import { output } from "@outfitter/cli";
+async function printScaffoldResults(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (result.dryRunPlan) {
+    if (structuredMode) {
+      await output({
+        target: result.target,
+        rootDir: result.rootDir,
+        targetDir: result.targetDir,
+        converted: result.converted,
+        movedExisting: result.movedExisting ?? null,
+        ...result.dryRunPlan
+      }, { mode: structuredMode });
+      return;
+    }
+    const collector = new OperationCollector;
+    for (const op of result.dryRunPlan.operations) {
+      collector.add(op);
+    }
+    await renderOperationPlan(collector, { rootDir: result.rootDir });
+    return;
+  }
+  if (structuredMode) {
+    await output({
+      target: result.target,
+      rootDir: result.rootDir,
+      targetDir: result.targetDir,
+      converted: result.converted,
+      movedExisting: result.movedExisting ?? null,
+      workspacePatternsUpdated: result.workspacePatternsUpdated,
+      blocksAdded: result.blocksAdded ?? null,
+      postScaffold: result.postScaffold,
+      nextSteps: result.postScaffold.nextSteps
+    }, { mode: structuredMode });
+    return;
+  }
+  const lines = [];
+  if (result.converted) {
+    lines.push("Converted to workspace structure:");
+    if (result.movedExisting) {
+      lines.push(`  Moved existing package -> ${result.movedExisting.to}`);
+    }
+    lines.push("  Created workspace root package.json");
+    lines.push("");
+  }
+  lines.push(`Scaffolded ${result.targetDir}`);
+  if (result.blocksAdded && result.blocksAdded.created.length > 0) {
+    lines.push(`Added ${result.blocksAdded.created.length} tooling file(s):`);
+    for (const created of result.blocksAdded.created) {
+      lines.push(`  + ${created}`);
+    }
+  }
+  lines.push("", "Next steps:");
+  for (const step of result.postScaffold.nextSteps) {
+    lines.push(`  ${step}`);
+  }
+  await output(lines, { mode: "human" });
+}
+
+export { printScaffoldResults };

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

@@ -0,0 +1,52 @@
+import { InitPresetId } from "./outfitter-5d9wbzhh.js";
+import { TargetDefinition } from "./outfitter-58rn1sj1.js";
+import { PostScaffoldResult } from "./outfitter-hcexcvxe.js";
+import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
+/** Whether the project is a standalone package or a workspace with nested packages. */
+type InitStructure = "single" | "workspace";
+/** Fully resolved inputs for the init execution pipeline, after interactive/non-interactive resolution. */
+interface ResolvedInitExecutionInput {
+	readonly binName?: string | undefined;
+	readonly blocksOverride?: readonly string[];
+	readonly includeTooling: boolean;
+	readonly local: boolean;
+	readonly packageName: string;
+	readonly preset: InitPresetId;
+	readonly rootDir: string;
+	readonly structure: InitStructure;
+	readonly workspaceName?: string | undefined;
+}
+/** Behavioral flags controlling how the init pipeline executes (dry-run, force, skip steps). */
+interface InitExecutionOptions {
+	readonly dryRun: boolean;
+	readonly force: boolean;
+	readonly installTimeout: number;
+	readonly skipCommit: boolean;
+	readonly skipGit: boolean;
+	readonly skipInstall: boolean;
+}
+/** Output of a successful init pipeline run, including scaffold results and post-scaffold status. */
+interface InitExecutionResult {
+	readonly blocksAdded?: AddBlockResult | undefined;
+	readonly dryRunPlan?: {
+		readonly operations: readonly unknown[];
+		readonly summary: Record<string, number>;
+	} | undefined;
+	readonly packageName: string;
+	readonly postScaffold: PostScaffoldResult;
+	readonly preset: InitPresetId;
+	readonly projectDir: string;
+	readonly rootDir: string;
+	readonly structure: InitStructure;
+}
+/**
+* Runs the full init pipeline: validates inputs, scaffolds the project structure,
+* executes the preset plan, and performs post-scaffold steps (install, git init).
+* @param input - Resolved user inputs (preset, structure, package name, etc.)
+* @param target - Target definition from the preset registry
+* @param options - Execution flags (dry-run, force, skip steps)
+* @returns The init result on success, or an error message string on failure
+*/
+declare function executeInitPipeline(input: ResolvedInitExecutionInput, target: TargetDefinition, options: InitExecutionOptions): Promise<Result<InitExecutionResult, string>>;
+export { InitStructure, ResolvedInitExecutionInput, InitExecutionOptions, InitExecutionResult, executeInitPipeline };

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

@@ -0,0 +1,77 @@
+import { OutputMode } from "@outfitter/cli/types";
+import { Result } from "@outfitter/contracts";
+/** Check bundle mode controlling which steps are included and whether a clean tree is enforced. */
+type CheckOrchestratorMode = "all" | "ci" | "pre-commit" | "pre-push";
+interface CheckOrchestratorStep {
+	readonly command: readonly string[];
+	readonly id: string;
+	readonly label: string;
+}
+/** Options controlling which checks the orchestrator runs. */
+interface CheckOrchestratorOptions {
+	/** Workspace root for resolving commands and tree-clean detection. */
+	readonly cwd: string;
+	readonly mode: CheckOrchestratorMode;
+	/** Staged file paths for pre-commit scoping. Ignored by other modes. */
+	readonly stagedFiles?: readonly string[];
+}
+interface CheckOrchestratorStepResult {
+	readonly command: readonly string[];
+	readonly durationMs: number;
+	readonly exitCode: number;
+	readonly id: string;
+	readonly label: string;
+	readonly stderr: string;
+	readonly stdout: string;
+}
+/** Aggregate outcome of an orchestrator run including tree-clean status. */
+interface CheckOrchestratorResult {
+	/** Step IDs that exited non-zero. */
+	readonly failedStepIds: readonly string[];
+	readonly mode: CheckOrchestratorMode;
+	/** Paths added or modified in the working tree during the run. */
+	readonly mutatedPaths: readonly string[];
+	/** True when all steps passed and tree-clean enforcement (if applicable) succeeded. */
+	readonly ok: boolean;
+	readonly steps: readonly CheckOrchestratorStepResult[];
+	/** Whether the working tree was unchanged after the run completed. */
+	readonly treeClean: boolean;
+}
+/** Error raised when the check orchestrator cannot complete its run. */
+declare class CheckOrchestratorError extends Error {
+	readonly _tag: "CheckOrchestratorError";
+	constructor(message: string);
+}
+/**
+* Build the ordered list of check steps for the given mode.
+*
+* Pre-commit mode scopes lint/typecheck to staged files and conditionally
+* includes agent-scaffolding sync. All other modes run the full suite.
+*/
+declare function buildCheckOrchestratorPlan(options: CheckOrchestratorOptions): readonly CheckOrchestratorStep[];
+/**
+* Parse `git status --porcelain` output into sorted file paths.
+*
+* Handles rename entries by extracting the destination path.
+*/
+declare function parseTreePaths(statusOutput: string): string[];
+/**
+* Execute the check plan sequentially, stopping on the first failure.
+*
+* Captures working-tree state before and after to detect mutations.
+* For modes other than pre-commit, a dirty tree causes an overall failure.
+*/
+declare function runCheckOrchestrator(options: CheckOrchestratorOptions): Promise<Result<CheckOrchestratorResult, CheckOrchestratorError>>;
+interface PrintCheckOrchestratorResultsOptions {
+	readonly compact?: boolean;
+	readonly mode?: OutputMode;
+}
+/**
+* Render orchestrator results to stdout.
+*
+* Structured modes emit JSON/JSONL (optionally compact). Human mode
+* prints a step-by-step summary with pass/fail icons, timing, advisory
+* warnings, and mutation traceability.
+*/
+declare function printCheckOrchestratorResults(result: CheckOrchestratorResult, options?: PrintCheckOrchestratorResultsOptions): Promise<void>;
+export { CheckOrchestratorMode, CheckOrchestratorOptions, CheckOrchestratorResult, CheckOrchestratorError, buildCheckOrchestratorPlan, parseTreePaths, runCheckOrchestrator, printCheckOrchestratorResults };

package/dist/shared/outfitter-rp89dafm.js

@@ -0,0 +1,109 @@
+// @bun
+import {
+  actionInternalErr,
+  outputModeSchema,
+  resolveCwdFromPreset
+} from "./outfitter-7n7vsz95.js";
+import {
+  runUpgrade
+} from "./outfitter-fxry5n58.js";
+import {
+  printUpgradeResults
+} from "./outfitter-x4cc5xsq.js";
+import {
+  resolveOutputModeFromContext
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/actions/upgrade.ts
+import { actionCliPresets } from "@outfitter/cli/actions";
+import {
+  booleanFlagPreset,
+  cwdPreset,
+  dryRunPreset,
+  interactionPreset
+} from "@outfitter/cli/flags";
+import { defineAction, Result } from "@outfitter/contracts";
+import { z } from "zod";
+var upgradeInputSchema = z.object({
+  cwd: z.string(),
+  guide: z.boolean(),
+  guidePackages: z.array(z.string()).optional(),
+  dryRun: z.boolean(),
+  yes: z.boolean(),
+  interactive: z.boolean(),
+  all: z.boolean(),
+  noCodemods: z.boolean(),
+  outputMode: outputModeSchema
+});
+var upgradeCwd = cwdPreset();
+var upgradeDryRun = dryRunPreset();
+var upgradeInteraction = interactionPreset();
+var upgradeAll = booleanFlagPreset({
+  id: "upgradeAll",
+  key: "all",
+  flags: "--all",
+  description: "Include breaking changes in the upgrade"
+});
+var upgradeNoCodemods = booleanFlagPreset({
+  id: "upgradeNoCodemods",
+  key: "noCodemods",
+  flags: "--no-codemods",
+  description: "Skip automatic codemod execution during upgrade",
+  sources: ["noCodemods", "no-codemods"],
+  negatedSources: ["codemods"]
+});
+var upgradeGuide = booleanFlagPreset({
+  id: "upgradeGuide",
+  key: "guide",
+  flags: "--guide",
+  description: "Show migration instructions for available updates. Pass package names to filter."
+});
+var upgradeFlags = actionCliPresets(upgradeCwd, upgradeDryRun, upgradeInteraction, upgradeAll, upgradeNoCodemods, upgradeGuide);
+var upgradeAction = defineAction({
+  id: "upgrade",
+  description: "Check for @outfitter/* package updates and migration guidance",
+  surfaces: ["cli"],
+  input: upgradeInputSchema,
+  cli: {
+    command: "upgrade [packages...]",
+    description: "Check for @outfitter/* package updates and migration guidance",
+    options: [...upgradeFlags.options],
+    mapInput: (context) => {
+      const outputMode = resolveOutputModeFromContext(context.flags);
+      const { dryRun, interactive, yes, all, noCodemods, guide } = upgradeFlags.resolve(context);
+      const guidePackages = context.args.length > 0 ? context.args : undefined;
+      return {
+        cwd: resolveCwdFromPreset(context.flags, upgradeCwd),
+        guide,
+        ...guidePackages !== undefined ? { guidePackages } : {},
+        dryRun,
+        yes,
+        interactive,
+        all,
+        noCodemods,
+        outputMode
+      };
+    }
+  },
+  handler: async (input) => {
+    const { outputMode, guidePackages, ...upgradeInput } = input;
+    const result = await runUpgrade({
+      ...upgradeInput,
+      outputMode,
+      ...guidePackages !== undefined ? { guidePackages } : {}
+    });
+    if (result.isErr()) {
+      return actionInternalErr("upgrade", result.error);
+    }
+    await printUpgradeResults(result.value, {
+      mode: outputMode,
+      guide: upgradeInput.guide,
+      cwd: upgradeInput.cwd,
+      dryRun: upgradeInput.dryRun,
+      all: upgradeInput.all
+    });
+    return Result.ok(result.value);
+  }
+});
+
+export { upgradeAction };

package/dist/shared/outfitter-s1c0whzj.js

@@ -0,0 +1,121 @@
+// @bun
+// apps/outfitter/src/commands/upgrade-migration-frontmatter.ts
+var FRONTMATTER_BLOCK_REGEX = /^---\r?\n[\s\S]*?\r?\n---\r?\n*/;
+var VALID_CHANGE_TYPES = new Set([
+  "renamed",
+  "removed",
+  "signature-changed",
+  "moved",
+  "deprecated",
+  "added"
+]);
+function stripMigrationFrontmatter(content) {
+  return content.replace(FRONTMATTER_BLOCK_REGEX, "").trim();
+}
+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"] } : {}
+  };
+}
+
+export { stripMigrationFrontmatter, parseMigrationFrontmatter };