outfitter 0.2.7 → 0.3.2

package/dist/shared/outfitter-7ch26yq8.js

@@ -1,885 +0,0 @@
-// @bun
-import {
-  printScaffoldResults,
-  runScaffold
-} from "./outfitter-pj9vp00r.js";
-import {
-  printInitResults,
-  runInit
-} from "./outfitter-mt7d1ek2.js";
-import {
-  runDemo
-} from "./outfitter-ksyvwmb5.js";
-import {
-  printCheckResults,
-  runCheck
-} from "./outfitter-w1j80j1r.js";
-import {
-  printDoctorResults,
-  runDoctor
-} from "./outfitter-5y646xzk.js";
-import {
-  runCheckTsdoc
-} from "./outfitter-63gse8fv.js";
-import {
-  printUpgradeResults,
-  runUpgrade
-} from "./outfitter-pcj9gg2g.js";
-import {
-  listBlocks,
-  printAddResults,
-  runAdd
-} from "./outfitter-79vfxt6y.js";
-import {
-  resolveOutputModeFromContext,
-  resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
-
-// apps/outfitter/src/actions.ts
-import { resolve } from "path";
-import { output } from "@outfitter/cli";
-import { actionCliPresets } from "@outfitter/cli/actions";
-import {
-  booleanFlagPreset,
-  cwdPreset,
-  dryRunPreset,
-  forcePreset,
-  interactionPreset,
-  verbosePreset
-} from "@outfitter/cli/flags";
-import { jqPreset, outputModePreset } from "@outfitter/cli/query";
-import {
-  createActionRegistry,
-  defineAction,
-  InternalError,
-  Result,
-  ValidationError
-} from "@outfitter/contracts";
-import { z } from "zod";
-var outputModeSchema = z.enum(["human", "json", "jsonl"]).default("human");
-var initPresetValues = [
-  "minimal",
-  "cli",
-  "mcp",
-  "daemon",
-  "library",
-  "full-stack",
-  "lib"
-];
-function normalizeInitPreset(preset) {
-  if (preset === undefined) {
-    return;
-  }
-  return preset === "lib" ? "library" : preset;
-}
-var initInputSchema = z.object({
-  targetDir: z.string(),
-  name: z.string().optional(),
-  bin: z.string().optional(),
-  preset: z.enum(initPresetValues).optional(),
-  template: z.string().optional(),
-  structure: z.enum(["single", "workspace"]).optional(),
-  workspaceName: z.string().optional(),
-  local: z.boolean().optional(),
-  force: z.boolean(),
-  with: z.string().optional(),
-  noTooling: z.boolean().optional(),
-  yes: z.boolean().optional(),
-  dryRun: z.boolean().optional(),
-  skipInstall: z.boolean().optional(),
-  skipGit: z.boolean().optional(),
-  skipCommit: z.boolean().optional(),
-  installTimeout: z.number().optional(),
-  outputMode: outputModeSchema
-});
-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 doctorInputSchema = z.object({
-  cwd: z.string(),
-  outputMode: outputModeSchema
-});
-function resolveStringFlag(value) {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function resolveNoToolingFlag(flags) {
-  if (typeof flags.noTooling === "boolean") {
-    return !flags.noTooling;
-  }
-  if (typeof flags.tooling === "boolean") {
-    if (!flags.tooling) {
-      return true;
-    }
-    return process.argv.includes("--tooling") ? false : undefined;
-  }
-  return;
-}
-function resolveLocalFlag(flags) {
-  if (flags.local === true || flags.workspace === true) {
-    return true;
-  }
-  return;
-}
-function resolveInitOptions(context, presetOverride) {
-  const flags = context.flags;
-  const { force, dryRun, yes } = initSharedFlags.resolve(context);
-  const targetDir = context.args[0] ?? process.cwd();
-  const name = resolveStringFlag(flags.name);
-  const bin = resolveStringFlag(flags.bin);
-  const preset = normalizeInitPreset(presetOverride ?? resolveStringFlag(flags.preset));
-  const template = resolveStringFlag(flags.template);
-  const structure = resolveStringFlag(flags.structure);
-  const workspaceName = resolveStringFlag(flags.workspaceName);
-  const local = resolveLocalFlag(flags);
-  const withBlocks = resolveStringFlag(flags.with);
-  const noTooling = resolveNoToolingFlag(flags);
-  const skipInstall = Boolean(flags.skipInstall ?? context.flags["skip-install"]);
-  const skipGit = Boolean(flags.skipGit ?? context.flags["skip-git"]);
-  const skipCommit = Boolean(flags.skipCommit ?? context.flags["skip-commit"]);
-  const installTimeoutValue = flags.installTimeout;
-  let installTimeout;
-  if (typeof installTimeoutValue === "string") {
-    installTimeout = Number.parseInt(installTimeoutValue, 10);
-  } else if (typeof installTimeoutValue === "number") {
-    installTimeout = installTimeoutValue;
-  }
-  const outputMode = resolveOutputModeFromContext(context.flags);
-  return {
-    targetDir,
-    name,
-    ...preset ? { preset } : {},
-    ...template ? { template } : {},
-    ...structure ? { structure } : {},
-    ...workspaceName ? { workspaceName } : {},
-    force,
-    ...local !== undefined ? { local } : {},
-    ...withBlocks ? { with: withBlocks } : {},
-    ...noTooling !== undefined ? { noTooling } : {},
-    ...bin ? { bin } : {},
-    ...yes ? { yes } : {},
-    ...dryRun ? { dryRun } : {},
-    ...skipInstall ? { skipInstall } : {},
-    ...skipGit ? { skipGit } : {},
-    ...skipCommit ? { skipCommit } : {},
-    ...installTimeout !== undefined ? { installTimeout } : {},
-    outputMode
-  };
-}
-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 installTimeoutValue = flags.installTimeout;
-  let installTimeout;
-  if (typeof installTimeoutValue === "string") {
-    installTimeout = Number.parseInt(installTimeoutValue, 10);
-  } else if (typeof installTimeoutValue === "number") {
-    installTimeout = installTimeoutValue;
-  }
-  return {
-    target: String(context.args[0] ?? ""),
-    name: resolveStringFlag(context.args[1]),
-    force,
-    skipInstall: Boolean(flags.skipInstall ?? context.flags["skip-install"]),
-    dryRun,
-    ...local !== undefined ? { local } : {},
-    with: resolveStringFlag(flags.with),
-    ...noTooling !== undefined ? { noTooling } : {},
-    ...installTimeout !== undefined ? { installTimeout } : {},
-    cwd: process.cwd(),
-    outputMode
-  };
-}
-var commonInitOptions = [
-  {
-    flags: "-n, --name <name>",
-    description: "Package name (defaults to directory name)"
-  },
-  {
-    flags: "-b, --bin <name>",
-    description: "Binary name (defaults to project name)"
-  },
-  {
-    flags: "--local",
-    description: "Use workspace:* for @outfitter dependencies"
-  },
-  {
-    flags: "--workspace",
-    description: "Alias for --local"
-  },
-  {
-    flags: "--with <blocks>",
-    description: "Tooling to add (comma-separated: scaffolding, claude, biome, lefthook, bootstrap)"
-  },
-  {
-    flags: "--no-tooling",
-    description: "Skip tooling setup"
-  }
-];
-var templateOption = {
-  flags: "-t, --template <template>",
-  description: "Template to use (deprecated, use --preset)"
-};
-var initSharedFlags = actionCliPresets(forcePreset(), dryRunPreset(), booleanFlagPreset({
-  id: "initYes",
-  key: "yes",
-  flags: "-y, --yes",
-  description: "Skip prompts and use defaults for missing values"
-}));
-function createInitAction(options) {
-  const presetOption = {
-    flags: "-p, --preset <preset>",
-    description: "Preset to use (minimal, cli, mcp, daemon, library, full-stack, lib)"
-  };
-  const initOptions = [...commonInitOptions];
-  initOptions.push(...initSharedFlags.options);
-  initOptions.push({
-    flags: "-s, --structure <mode>",
-    description: "Project structure (single|workspace)"
-  });
-  initOptions.push({
-    flags: "--workspace-name <name>",
-    description: "Workspace root package name"
-  });
-  initOptions.push({
-    flags: "--skip-install",
-    description: "Skip bun install",
-    defaultValue: false
-  });
-  initOptions.push({
-    flags: "--skip-git",
-    description: "Skip git init and initial commit",
-    defaultValue: false
-  });
-  initOptions.push({
-    flags: "--skip-commit",
-    description: "Skip initial commit only",
-    defaultValue: false
-  });
-  initOptions.push({
-    flags: "--install-timeout <ms>",
-    description: "bun install timeout in milliseconds"
-  });
-  if (options.includePresetOption) {
-    initOptions.push(presetOption);
-  }
-  if (options.includeTemplateOption) {
-    initOptions.push(templateOption);
-  }
-  return defineAction({
-    id: options.id,
-    description: options.description,
-    surfaces: ["cli"],
-    input: initInputSchema,
-    cli: {
-      group: "init",
-      command: options.command,
-      description: options.description,
-      options: initOptions,
-      mapInput: (context) => resolveInitOptions(context, options.presetOverride)
-    },
-    handler: async (input) => {
-      const { outputMode, ...initInput } = input;
-      const result = await runInit(initInput);
-      if (result.isErr()) {
-        return Result.err(new InternalError({
-          message: result.error.message,
-          context: { action: options.id }
-        }));
-      }
-      await printInitResults(result.value, { mode: outputMode });
-      return Result.ok(result.value);
-    }
-  });
-}
-var scaffoldSharedFlags = actionCliPresets(forcePreset(), dryRunPreset());
-var addSharedFlags = actionCliPresets(forcePreset(), dryRunPreset());
-var createAction = defineAction({
-  id: "create",
-  description: "Removed - use 'outfitter init' instead",
-  surfaces: ["cli"],
-  input: z.object({}).passthrough(),
-  cli: {
-    command: "create [directory]",
-    description: "Removed - use 'outfitter init' instead",
-    options: [],
-    mapInput: () => ({})
-  },
-  handler: async () => Result.err(new InternalError({
-    message: [
-      "The 'create' command has been removed.",
-      "",
-      "Use 'outfitter init' instead. It supports everything 'create' did:",
-      "",
-      "  Interactive mode:    outfitter init my-project",
-      "  With preset:         outfitter init my-project --preset cli",
-      "  Skip prompts:        outfitter init my-project --preset cli --yes",
-      "  Workspace:           outfitter init my-project --preset cli --structure workspace",
-      "",
-      "See 'outfitter init --help' for full options."
-    ].join("\\n"),
-    context: { action: "create" }
-  }))
-});
-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 Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "scaffold" }
-      }));
-    }
-    await printScaffoldResults(result.value, { mode: outputMode });
-    return Result.ok(result.value);
-  }
-});
-var demoInputSchema = z.object({
-  section: z.string().optional(),
-  list: z.boolean().optional(),
-  animate: z.boolean().optional(),
-  outputMode: outputModeSchema
-});
-var demoAction = defineAction({
-  id: "demo",
-  description: "Run the CLI demo app",
-  surfaces: ["cli"],
-  input: demoInputSchema,
-  cli: {
-    command: "demo [section]",
-    description: "Run the CLI demo app",
-    options: [
-      {
-        flags: "-l, --list",
-        description: "List available demo sections",
-        defaultValue: false
-      },
-      {
-        flags: "-a, --animate",
-        description: "Run animated demo (spinners only)",
-        defaultValue: false
-      }
-    ],
-    mapInput: (context) => {
-      const outputMode = resolveOutputModeFromContext(context.flags);
-      return {
-        section: context.args[0],
-        list: Boolean(context.flags["list"]),
-        animate: Boolean(context.flags["animate"]),
-        outputMode
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...demoInput } = input;
-    try {
-      const result = await runDemo({ ...demoInput, outputMode });
-      if (result.exitCode !== 0) {
-        process.exit(result.exitCode);
-      }
-      return Result.ok(result);
-    } catch (error) {
-      return Result.err(new InternalError({
-        message: error instanceof Error ? error.message : "Failed to run demo",
-        context: { action: "demo" }
-      }));
-    }
-  }
-});
-var doctorCwd = cwdPreset();
-var doctorAction = defineAction({
-  id: "doctor",
-  description: "Validate environment and dependencies",
-  surfaces: ["cli"],
-  input: doctorInputSchema,
-  cli: {
-    command: "doctor",
-    description: "Validate environment and dependencies",
-    options: [...doctorCwd.options],
-    mapInput: (context) => {
-      const outputMode = resolveOutputModeFromContext(context.flags);
-      const { cwd: rawCwd } = doctorCwd.resolve(context.flags);
-      const cwd = resolve(process.cwd(), rawCwd);
-      return {
-        cwd,
-        outputMode
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...doctorInput } = input;
-    const result = await runDoctor(doctorInput);
-    await printDoctorResults(result, { mode: outputMode });
-    if (result.exitCode !== 0) {
-      process.exit(result.exitCode);
-    }
-    return Result.ok(result);
-  }
-});
-var addInputSchema = z.object({
-  block: z.string(),
-  force: z.boolean(),
-  dryRun: z.boolean(),
-  cwd: z.string().optional(),
-  outputMode: outputModeSchema
-});
-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, biome, lefthook, bootstrap, scaffolding)",
-    options: [...addSharedFlags.options, ...addCwd.options],
-    mapInput: (context) => {
-      const outputMode = resolveOutputModeFromContext(context.flags);
-      const { force, dryRun } = addSharedFlags.resolve(context);
-      const { cwd: rawCwd } = addCwd.resolve(context.flags);
-      const cwd = resolve(process.cwd(), rawCwd);
-      return {
-        block: context.args[0],
-        force,
-        dryRun,
-        cwd,
-        outputMode
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...addInput } = input;
-    const result = await runAdd(addInput);
-    if (result.isErr()) {
-      return Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "add" }
-      }));
-    }
-    await printAddResults(result.value, addInput.dryRun, { mode: outputMode });
-    return Result.ok(result.value);
-  }
-});
-var listBlocksAction = defineAction({
-  id: "add.list",
-  description: "List available blocks",
-  surfaces: ["cli"],
-  input: z.object({ outputMode: outputModeSchema }),
-  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 Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "add.list" }
-      }));
-    }
-    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 });
-  }
-});
-var checkInputSchema = z.object({
-  cwd: z.string(),
-  verbose: z.boolean(),
-  block: z.string().optional(),
-  outputMode: outputModeSchema
-});
-var checkVerbose = verbosePreset();
-var checkCwd = cwdPreset();
-var checkOutputMode = outputModePreset();
-var checkVerboseOptions = checkVerbose.options.map((option) => option.flags === "-v, --verbose" ? { ...option, description: "Show diffs for drifted files" } : option);
-var checkAction = defineAction({
-  id: "check",
-  description: "Compare local config blocks against the registry for drift detection",
-  surfaces: ["cli"],
-  input: checkInputSchema,
-  cli: {
-    group: "check",
-    description: "Compare local config blocks against the registry for drift detection",
-    options: [
-      ...checkVerboseOptions,
-      {
-        flags: "-b, --block <name>",
-        description: "Check a specific block only"
-      },
-      {
-        flags: "--ci",
-        description: "Deprecated: use --output json instead",
-        defaultValue: false
-      },
-      ...checkOutputMode.options,
-      ...checkCwd.options
-    ],
-    mapInput: (context) => {
-      const { outputMode: presetOutputMode } = checkOutputMode.resolve(context.flags);
-      const explicitOutput = typeof context.flags["output"] === "string";
-      let outputMode;
-      if (explicitOutput) {
-        outputMode = resolveStructuredOutputMode(presetOutputMode) ?? "human";
-      } else if (context.flags["ci"]) {
-        outputMode = "json";
-      } else if (process.env["OUTFITTER_JSONL"] === "1") {
-        outputMode = "jsonl";
-      } else if (process.env["OUTFITTER_JSON"] === "1") {
-        outputMode = "json";
-      } else {
-        outputMode = "human";
-      }
-      const { verbose } = checkVerbose.resolve(context.flags);
-      const { cwd: rawCwd } = checkCwd.resolve(context.flags);
-      const cwd = resolve(process.cwd(), rawCwd);
-      const block = resolveStringFlag(context.flags["block"]);
-      return {
-        cwd,
-        verbose,
-        ...block !== undefined ? { block } : {},
-        outputMode
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...checkInput } = input;
-    const result = await runCheck(checkInput);
-    if (result.isErr()) {
-      return Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "check" }
-      }));
-    }
-    await printCheckResults(result.value, {
-      mode: outputMode,
-      verbose: checkInput.verbose
-    });
-    if (result.value.driftedCount > 0 || result.value.missingCount > 0) {
-      process.exit(1);
-    }
-    return Result.ok(result.value);
-  }
-});
-var checkTsdocInputSchema = z.object({
-  strict: z.boolean(),
-  minCoverage: z.number(),
-  cwd: z.string(),
-  outputMode: outputModeSchema,
-  jq: z.string().optional(),
-  summary: z.boolean(),
-  level: z.enum(["documented", "partial", "undocumented"]).optional(),
-  packages: z.array(z.string())
-});
-var checkTsdocOutputSchema = z.object({
-  ok: z.boolean(),
-  packages: z.array(z.object({
-    name: z.string(),
-    path: z.string(),
-    declarations: z.array(z.object({
-      name: z.string(),
-      kind: z.string(),
-      level: z.enum(["documented", "partial", "undocumented"]),
-      file: z.string(),
-      line: z.number()
-    })),
-    documented: z.number(),
-    partial: z.number(),
-    undocumented: z.number(),
-    total: z.number(),
-    percentage: z.number()
-  })),
-  summary: z.object({
-    documented: z.number(),
-    partial: z.number(),
-    undocumented: z.number(),
-    total: z.number(),
-    percentage: z.number()
-  })
-});
-var checkTsdocOutputMode = outputModePreset({ includeJsonl: true });
-var checkTsdocJq = jqPreset();
-var checkTsdocAction = defineAction({
-  id: "check.tsdoc",
-  description: "Check TSDoc coverage on exported declarations",
-  surfaces: ["cli"],
-  input: checkTsdocInputSchema,
-  output: checkTsdocOutputSchema,
-  cli: {
-    group: "check",
-    command: "tsdoc",
-    description: "Check TSDoc coverage on exported declarations",
-    options: [
-      {
-        flags: "--strict",
-        description: "Fail if coverage is below the minimum threshold",
-        defaultValue: false
-      },
-      {
-        flags: "--min-coverage <percent>",
-        description: "Minimum coverage percentage (used with --strict)"
-      },
-      {
-        flags: "--summary",
-        description: "Omit per-declaration detail for compact output (~2KB vs ~64KB)",
-        defaultValue: false
-      },
-      {
-        flags: "--level <level>",
-        description: "Filter declarations by coverage level (undocumented, partial, documented)"
-      },
-      {
-        flags: "--package <name>",
-        description: "Filter to specific package(s) by name (repeatable)"
-      },
-      ...checkTsdocOutputMode.options,
-      ...checkTsdocJq.options
-    ],
-    mapInput: (context) => {
-      const { outputMode: presetOutputMode } = checkTsdocOutputMode.resolve(context.flags);
-      const { jq } = checkTsdocJq.resolve(context.flags);
-      const explicitOutput = typeof context.flags["output"] === "string";
-      let outputMode;
-      if (explicitOutput) {
-        outputMode = resolveStructuredOutputMode(presetOutputMode) ?? "human";
-      } else if (process.env["OUTFITTER_JSONL"] === "1") {
-        outputMode = "jsonl";
-      } else if (process.env["OUTFITTER_JSON"] === "1") {
-        outputMode = "json";
-      } else {
-        outputMode = "human";
-      }
-      const minCoverageRaw = context.flags["minCoverage"] ?? context.flags["min-coverage"];
-      let minCoverage = 0;
-      if (typeof minCoverageRaw === "string") {
-        minCoverage = Number.parseInt(minCoverageRaw, 10);
-      } else if (typeof minCoverageRaw === "number") {
-        minCoverage = minCoverageRaw;
-      }
-      const levelRaw = context.flags["level"];
-      const validLevels = new Set(["documented", "partial", "undocumented"]);
-      const level = typeof levelRaw === "string" && validLevels.has(levelRaw) ? levelRaw : undefined;
-      const pkgRaw = context.flags["package"];
-      let packages = [];
-      if (Array.isArray(pkgRaw)) {
-        packages = pkgRaw.filter((v) => typeof v === "string");
-      } else if (typeof pkgRaw === "string") {
-        packages = [pkgRaw];
-      }
-      return {
-        strict: Boolean(context.flags["strict"]),
-        minCoverage,
-        cwd: process.cwd(),
-        outputMode,
-        jq,
-        summary: Boolean(context.flags["summary"]),
-        level,
-        packages
-      };
-    }
-  },
-  handler: async (input) => {
-    const result = await runCheckTsdoc(input);
-    if (result.isErr()) {
-      if (result.error instanceof ValidationError) {
-        return Result.err(result.error);
-      }
-      return Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "check.tsdoc" }
-      }));
-    }
-    if (!result.value.ok) {
-      process.exitCode = 1;
-    }
-    return Result.ok(result.value);
-  }
-});
-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 {
-        cwd: rawCwd,
-        dryRun,
-        interactive,
-        yes,
-        all,
-        noCodemods,
-        guide
-      } = upgradeFlags.resolve(context);
-      const cwd = resolve(process.cwd(), rawCwd);
-      const guidePackages = context.args.length > 0 ? context.args : undefined;
-      return {
-        cwd,
-        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 Result.err(new InternalError({
-        message: result.error.message,
-        context: { action: "upgrade" }
-      }));
-    }
-    await printUpgradeResults(result.value, {
-      mode: outputMode,
-      guide: upgradeInput.guide,
-      cwd: upgradeInput.cwd,
-      dryRun: upgradeInput.dryRun,
-      all: upgradeInput.all
-    });
-    return Result.ok(result.value);
-  }
-});
-var outfitterActions = createActionRegistry().add(createAction).add(scaffoldAction).add(createInitAction({
-  id: "init",
-  description: "Create a new Outfitter project",
-  command: "[directory]",
-  includePresetOption: true,
-  includeTemplateOption: true
-})).add(createInitAction({
-  id: "init.cli",
-  description: "Create a new CLI project",
-  command: "cli [directory]",
-  presetOverride: "cli"
-})).add(createInitAction({
-  id: "init.mcp",
-  description: "Create a new MCP server",
-  command: "mcp [directory]",
-  presetOverride: "mcp"
-})).add(createInitAction({
-  id: "init.daemon",
-  description: "Create a new daemon project",
-  command: "daemon [directory]",
-  presetOverride: "daemon"
-})).add(createInitAction({
-  id: "init.library",
-  description: "Create a new library project",
-  command: "library [directory]",
-  presetOverride: "library"
-})).add(createInitAction({
-  id: "init.full-stack",
-  description: "Create a full-stack workspace",
-  command: "full-stack [directory]",
-  presetOverride: "full-stack"
-})).add(demoAction).add(doctorAction).add(addAction).add(listBlocksAction).add(checkAction).add(checkTsdocAction).add(upgradeAction);
-
-export { outfitterActions };