outfitter 0.2.2 → 0.2.3

package/dist/shared/chunk-sak1tt33.js

@@ -1,3457 +0,0 @@
-// src/create/presets.ts
-var CREATE_PRESETS = {
-  basic: {
-    id: "basic",
-    template: "basic",
-    summary: "Minimal Bun + TypeScript project.",
-    defaultBlocks: ["scaffolding"]
-  },
-  cli: {
-    id: "cli",
-    template: "cli",
-    summary: "CLI starter with Outfitter command ergonomics.",
-    defaultBlocks: ["scaffolding"]
-  },
-  daemon: {
-    id: "daemon",
-    template: "daemon",
-    summary: "Daemon + control CLI starter.",
-    defaultBlocks: ["scaffolding"]
-  },
-  mcp: {
-    id: "mcp",
-    template: "mcp",
-    summary: "MCP server starter.",
-    defaultBlocks: ["scaffolding"]
-  }
-};
-var CREATE_PRESET_IDS = Object.keys(CREATE_PRESETS);
-function getCreatePreset(id) {
-  const presets = CREATE_PRESETS;
-  return presets[id];
-}
-
-// src/create/planner.ts
-import { Result, ValidationError } from "@outfitter/contracts";
-function derivePackageName(input) {
-  return (input.packageName ?? input.name).trim();
-}
-function deriveProjectName(packageName) {
-  if (!packageName.startsWith("@")) {
-    return packageName.trim();
-  }
-  const scopeSeparator = packageName.indexOf("/");
-  if (scopeSeparator < 0) {
-    return "";
-  }
-  return packageName.slice(scopeSeparator + 1).trim();
-}
-function deriveBinName(projectName) {
-  return projectName.toLowerCase().replace(/\s+/g, "-");
-}
-function planCreateProject(input) {
-  const packageName = derivePackageName(input);
-  if (packageName.length === 0) {
-    return Result.err(new ValidationError({
-      message: "Project name must not be empty",
-      field: "name"
-    }));
-  }
-  const targetDir = input.targetDir.trim();
-  if (targetDir.length === 0) {
-    return Result.err(new ValidationError({
-      message: "Target directory must not be empty",
-      field: "targetDir"
-    }));
-  }
-  const projectName = deriveProjectName(packageName);
-  if (projectName.length === 0) {
-    return Result.err(new ValidationError({
-      message: "Could not derive a project name from package name",
-      field: "packageName"
-    }));
-  }
-  const preset = getCreatePreset(input.preset);
-  if (!preset) {
-    return Result.err(new ValidationError({
-      message: `Unknown create preset '${input.preset}'`,
-      field: "preset"
-    }));
-  }
-  const includeTooling = input.includeTooling ?? true;
-  const defaultBlocks = includeTooling ? [...preset.defaultBlocks] : [];
-  const changes = [
-    {
-      type: "copy-template",
-      template: preset.template,
-      targetDir,
-      overlayBaseTemplate: true
-    },
-    { type: "inject-shared-config" }
-  ];
-  if (input.local) {
-    changes.push({ type: "rewrite-local-dependencies", mode: "workspace" });
-  }
-  if (defaultBlocks.length > 0) {
-    changes.push({ type: "add-blocks", blocks: defaultBlocks });
-  }
-  const plan = {
-    preset,
-    values: {
-      packageName,
-      projectName,
-      version: input.version?.trim() || "0.1.0",
-      description: input.description?.trim() || "A new project created with Outfitter",
-      binName: deriveBinName(projectName),
-      year: input.year ?? String(new Date().getFullYear())
-    },
-    changes
-  };
-  return Result.ok(plan);
-}
-// src/commands/create.ts
-import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync as readFileSync2,
-  statSync,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import { basename, dirname as dirname2, extname, join as join2, resolve as resolve2 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  outro,
-  select,
-  text
-} from "@clack/prompts";
-import { exitWithError, output as output2 } from "@outfitter/cli/output";
-import { Result as Result3 } from "@outfitter/contracts";
-
-// src/commands/add.ts
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync
-} from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { output } from "@outfitter/cli/output";
-import { Result as Result2 } from "@outfitter/contracts";
-import { RegistrySchema } from "@outfitter/tooling";
-
-class AddError extends Error {
-  _tag = "AddError";
-  constructor(message) {
-    super(message);
-    this.name = "AddError";
-  }
-}
-function getRegistryPath() {
-  let currentDir = dirname(fileURLToPath(import.meta.url));
-  for (let i = 0;i < 10; i++) {
-    const registryPath = join(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
-    if (existsSync(registryPath)) {
-      return registryPath;
-    }
-    const monoRepoPath = join(currentDir, "packages/tooling/registry/registry.json");
-    if (existsSync(monoRepoPath)) {
-      return monoRepoPath;
-    }
-    currentDir = dirname(currentDir);
-  }
-  throw new AddError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
-}
-function loadRegistry() {
-  try {
-    const registryPath = getRegistryPath();
-    const content = readFileSync(registryPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const registry = RegistrySchema.parse(parsed);
-    return Result2.ok(registry);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result2.err(new AddError(`Failed to load registry: ${message}`));
-  }
-}
-function resolveBlock(registry, blockName, visited = new Set) {
-  if (visited.has(blockName)) {
-    return Result2.err(new AddError(`Circular dependency detected for block: ${blockName}`));
-  }
-  visited.add(blockName);
-  const block = registry.blocks[blockName];
-  if (!block) {
-    const available = Object.keys(registry.blocks).join(", ");
-    return Result2.err(new AddError(`Block '${blockName}' not found. Available blocks: ${available}`));
-  }
-  if (block.extends && block.extends.length > 0) {
-    const mergedFiles = [];
-    const mergedDeps = {};
-    const mergedDevDeps = {};
-    for (const extendedName of block.extends) {
-      const extendedResult = resolveBlock(registry, extendedName, visited);
-      if (extendedResult.isErr()) {
-        return extendedResult;
-      }
-      const extended = extendedResult.value;
-      if (extended.files) {
-        mergedFiles.push(...extended.files);
-      }
-      if (extended.dependencies) {
-        Object.assign(mergedDeps, extended.dependencies);
-      }
-      if (extended.devDependencies) {
-        Object.assign(mergedDevDeps, extended.devDependencies);
-      }
-    }
-    if (block.files) {
-      mergedFiles.push(...block.files);
-    }
-    if (block.dependencies) {
-      Object.assign(mergedDeps, block.dependencies);
-    }
-    if (block.devDependencies) {
-      Object.assign(mergedDevDeps, block.devDependencies);
-    }
-    return Result2.ok({
-      name: block.name,
-      description: block.description,
-      files: mergedFiles.length > 0 ? mergedFiles : undefined,
-      dependencies: Object.keys(mergedDeps).length > 0 ? mergedDeps : undefined,
-      devDependencies: Object.keys(mergedDevDeps).length > 0 ? mergedDevDeps : undefined
-    });
-  }
-  return Result2.ok(block);
-}
-function writeFile(filePath, content, executable) {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(filePath, content, "utf-8");
-  if (executable) {
-    chmodSync(filePath, 493);
-  }
-}
-function updatePackageJson(cwd, dependencies, devDependencies, dryRun) {
-  const packageJsonPath = join(cwd, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return { dependencies, devDependencies };
-  }
-  const content = readFileSync(packageJsonPath, "utf-8");
-  const pkg = JSON.parse(content);
-  const existingDeps = pkg["dependencies"] ?? {};
-  const existingDevDeps = pkg["devDependencies"] ?? {};
-  const addedDeps = {};
-  const addedDevDeps = {};
-  for (const [name, version] of Object.entries(dependencies)) {
-    if (!existingDeps[name]) {
-      existingDeps[name] = version;
-      addedDeps[name] = version;
-    }
-  }
-  for (const [name, version] of Object.entries(devDependencies)) {
-    if (!(existingDevDeps[name] || existingDeps[name])) {
-      existingDevDeps[name] = version;
-      addedDevDeps[name] = version;
-    }
-  }
-  if (!dryRun && (Object.keys(addedDeps).length > 0 || Object.keys(addedDevDeps).length > 0)) {
-    if (Object.keys(existingDeps).length > 0) {
-      pkg["dependencies"] = existingDeps;
-    }
-    if (Object.keys(existingDevDeps).length > 0) {
-      pkg["devDependencies"] = existingDevDeps;
-    }
-    writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
-`);
-  }
-  return { dependencies: addedDeps, devDependencies: addedDevDeps };
-}
-async function runAdd(input) {
-  const { block: blockName, force, dryRun, cwd = process.cwd() } = input;
-  const resolvedCwd = resolve(cwd);
-  const registryResult = loadRegistry();
-  if (registryResult.isErr()) {
-    return registryResult;
-  }
-  const registry = registryResult.value;
-  const blockResult = resolveBlock(registry, blockName);
-  if (blockResult.isErr()) {
-    return blockResult;
-  }
-  const block = blockResult.value;
-  const created = [];
-  const skipped = [];
-  const overwritten = [];
-  if (block.files) {
-    for (const file of block.files) {
-      const targetPath = join(resolvedCwd, file.path);
-      const fileExists = existsSync(targetPath);
-      if (fileExists && !force) {
-        skipped.push(file.path);
-        continue;
-      }
-      if (!dryRun) {
-        writeFile(targetPath, file.content, file.executable ?? false);
-      }
-      if (fileExists) {
-        overwritten.push(file.path);
-      } else {
-        created.push(file.path);
-      }
-    }
-  }
-  const { dependencies, devDependencies } = updatePackageJson(resolvedCwd, block.dependencies ?? {}, block.devDependencies ?? {}, dryRun);
-  return Result2.ok({
-    created,
-    skipped,
-    overwritten,
-    dependencies,
-    devDependencies
-  });
-}
-async function printAddResults(result, dryRun, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output({
-      dryRun,
-      created: result.created,
-      overwritten: result.overwritten,
-      skipped: result.skipped,
-      dependencies: result.dependencies,
-      devDependencies: result.devDependencies
-    }, { mode });
-    return;
-  }
-  const lines = [];
-  const prefix = dryRun ? "[dry-run] Would " : "";
-  if (result.created.length > 0) {
-    lines.push(`${prefix}create ${result.created.length} file(s):`);
-    for (const file of result.created) {
-      lines.push(`  ✓ ${file}`);
-    }
-  }
-  if (result.overwritten.length > 0) {
-    lines.push(`${prefix}overwrite ${result.overwritten.length} file(s):`);
-    for (const file of result.overwritten) {
-      lines.push(`  ✓ ${file}`);
-    }
-  }
-  if (result.skipped.length > 0) {
-    lines.push(`Skipped ${result.skipped.length} existing file(s):`);
-    for (const file of result.skipped) {
-      lines.push(`  - ${file} (use --force to overwrite)`);
-    }
-  }
-  const depCount = Object.keys(result.dependencies).length + Object.keys(result.devDependencies).length;
-  if (depCount > 0) {
-    lines.push("", `${prefix}add ${depCount} package(s) to package.json:`);
-    for (const [name, version] of Object.entries(result.dependencies)) {
-      lines.push(`  + ${name}@${version}`);
-    }
-    for (const [name, version] of Object.entries(result.devDependencies)) {
-      lines.push(`  + ${name}@${version} (dev)`);
-    }
-    if (!dryRun) {
-      lines.push("", "Run `bun install` to install new dependencies.");
-    }
-  }
-  await output(lines);
-}
-function listBlocks() {
-  const registryResult = loadRegistry();
-  if (registryResult.isErr()) {
-    return registryResult;
-  }
-  const blocks = Object.keys(registryResult.value.blocks);
-  return Result2.ok(blocks);
-}
-
-// src/commands/shared-deps.ts
-var SHARED_DEV_DEPS = {
-  "@biomejs/biome": "^2.3.12",
-  "@outfitter/tooling": "^0.2.1",
-  "@types/bun": "^1.3.7",
-  lefthook: "^2.0.16",
-  typescript: "^5.9.3",
-  ultracite: "^7.1.1"
-};
-var SHARED_SCRIPTS = {
-  check: "ultracite check",
-  "clean:artifacts": "rm -rf dist .turbo",
-  "verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
-  lint: "biome check .",
-  "lint:fix": "biome check . --write",
-  format: "biome format --write .",
-  typecheck: "tsc --noEmit"
-};
-
-// src/commands/create.ts
-class CreateError extends Error {
-  _tag = "CreateError";
-  constructor(message) {
-    super(message);
-    this.name = "CreateError";
-  }
-}
-var BINARY_EXTENSIONS = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".ico",
-  ".webp",
-  ".bmp",
-  ".tiff",
-  ".svg",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".otf",
-  ".eot",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".ogg",
-  ".webm",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".7z",
-  ".pdf",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".node",
-  ".wasm",
-  ".bin",
-  ".dat",
-  ".db",
-  ".sqlite",
-  ".sqlite3"
-]);
-var DEPENDENCY_SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-function resolveYear() {
-  return String(new Date().getFullYear());
-}
-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 deriveProjectName2(packageName) {
-  if (packageName.startsWith("@")) {
-    const parts = packageName.split("/");
-    if (parts.length > 1 && parts[1]) {
-      return parts[1];
-    }
-  }
-  return packageName;
-}
-function getTemplatesDir() {
-  let currentDir = dirname2(fileURLToPath2(import.meta.url));
-  for (let i = 0;i < 10; i++) {
-    const templatesPath = join2(currentDir, "templates");
-    if (existsSync2(templatesPath)) {
-      return templatesPath;
-    }
-    currentDir = dirname2(currentDir);
-  }
-  return join2(process.cwd(), "templates");
-}
-function getOutputFilename(templateFilename) {
-  if (templateFilename.endsWith(".template")) {
-    return templateFilename.slice(0, -".template".length);
-  }
-  return templateFilename;
-}
-function isBinaryFile(filename) {
-  return BINARY_EXTENSIONS.has(extname(filename).toLowerCase());
-}
-function replacePlaceholders(content, values) {
-  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-    if (Object.hasOwn(values, key)) {
-      return values[key];
-    }
-    return match;
-  });
-}
-function copyTemplateFiles(templateDir, targetDir, values, force, allowOverwrite = false, overwritablePaths, writtenPaths) {
-  try {
-    if (!existsSync2(targetDir)) {
-      mkdirSync2(targetDir, { recursive: true });
-    }
-    const entries = readdirSync(templateDir);
-    for (const entry of entries) {
-      const sourcePath = join2(templateDir, entry);
-      const sourceStat = statSync(sourcePath);
-      if (sourceStat.isDirectory()) {
-        const targetSubDir = join2(targetDir, entry);
-        const nestedResult = copyTemplateFiles(sourcePath, targetSubDir, values, force, allowOverwrite, overwritablePaths, writtenPaths);
-        if (nestedResult.isErr()) {
-          return nestedResult;
-        }
-        continue;
-      }
-      if (!sourceStat.isFile()) {
-        continue;
-      }
-      const outputFilename = getOutputFilename(entry);
-      const targetPath = join2(targetDir, outputFilename);
-      const targetExists = existsSync2(targetPath);
-      const canOverlay = allowOverwrite && (!targetExists || Boolean(overwritablePaths?.has(targetPath)));
-      if (targetExists && !force && !canOverlay) {
-        return Result3.err(new CreateError(`File '${targetPath}' already exists. Use --force to overwrite.`));
-      }
-      if (isBinaryFile(outputFilename)) {
-        const buffer = readFileSync2(sourcePath);
-        writeFileSync2(targetPath, buffer);
-        writtenPaths?.add(targetPath);
-        continue;
-      }
-      const content = readFileSync2(sourcePath, "utf-8");
-      const processedContent = replacePlaceholders(content, values);
-      writeFileSync2(targetPath, processedContent, "utf-8");
-      writtenPaths?.add(targetPath);
-    }
-    return Result3.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result3.err(new CreateError(`Failed to copy template files: ${message}`));
-  }
-}
-function injectSharedConfig(targetDir) {
-  const packageJsonPath = join2(targetDir, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return Result3.ok(undefined);
-  }
-  try {
-    const content = readFileSync2(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const existingDevDeps = parsed["devDependencies"] ?? {};
-    parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
-    const existingScripts = parsed["scripts"] ?? {};
-    parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
-    writeFileSync2(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
-`, "utf-8");
-    return Result3.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result3.err(new CreateError(`Failed to inject shared config: ${message}`));
-  }
-}
-function rewriteLocalDependencies(targetDir) {
-  const packageJsonPath = join2(targetDir, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return Result3.ok(undefined);
-  }
-  try {
-    const content = readFileSync2(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    let updated = false;
-    for (const section of DEPENDENCY_SECTIONS) {
-      const deps = parsed[section];
-      if (!deps || typeof deps !== "object" || Array.isArray(deps)) {
-        continue;
-      }
-      const entries = deps;
-      for (const [name, version] of Object.entries(entries)) {
-        if (typeof version === "string" && name.startsWith("@outfitter/") && version !== "workspace:*") {
-          entries[name] = "workspace:*";
-          updated = true;
-        }
-      }
-    }
-    if (updated) {
-      writeFileSync2(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
-`, "utf-8");
-    }
-    return Result3.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result3.err(new CreateError(`Failed to update local dependencies: ${message}`));
-  }
-}
-async function addBlocks(targetDir, blocks, force) {
-  const mergedResult = {
-    created: [],
-    skipped: [],
-    overwritten: [],
-    dependencies: {},
-    devDependencies: {}
-  };
-  for (const blockName of blocks) {
-    const result = await runAdd({
-      block: blockName,
-      force,
-      dryRun: false,
-      cwd: targetDir
-    });
-    if (result.isErr()) {
-      return Result3.err(new CreateError(`Failed to add block '${blockName}': ${result.error.message}`));
-    }
-    mergedResult.created.push(...result.value.created);
-    mergedResult.skipped.push(...result.value.skipped);
-    mergedResult.overwritten.push(...result.value.overwritten);
-    Object.assign(mergedResult.dependencies, result.value.dependencies);
-    Object.assign(mergedResult.devDependencies, result.value.devDependencies);
-  }
-  return Result3.ok(mergedResult);
-}
-function findProjectTargetDir(plan) {
-  const copyStep = plan.changes.find((change) => change.type === "copy-template");
-  if (!copyStep) {
-    return Result3.err(new CreateError("Planner output missing copy-template step"));
-  }
-  return Result3.ok(copyStep.targetDir);
-}
-function applyBlockOverrides(plan, blocksOverride) {
-  if (!blocksOverride) {
-    return plan;
-  }
-  const changesWithoutBlocks = plan.changes.filter((change) => change.type !== "add-blocks");
-  if (blocksOverride.length === 0) {
-    return {
-      ...plan,
-      changes: changesWithoutBlocks
-    };
-  }
-  return {
-    ...plan,
-    changes: [
-      ...changesWithoutBlocks,
-      { type: "add-blocks", blocks: blocksOverride }
-    ]
-  };
-}
-async function executePlan(plan, force) {
-  const targetDirResult = findProjectTargetDir(plan);
-  if (targetDirResult.isErr()) {
-    return targetDirResult;
-  }
-  const targetDir = targetDirResult.value;
-  const templatesDir = getTemplatesDir();
-  const values = {
-    name: plan.values.projectName,
-    projectName: plan.values.projectName,
-    packageName: plan.values.packageName,
-    binName: plan.values.binName,
-    version: plan.values.version,
-    description: plan.values.description,
-    year: plan.values.year
-  };
-  let blocksAdded;
-  for (const change of plan.changes) {
-    if (change.type === "copy-template") {
-      const templatePath = join2(templatesDir, change.template);
-      if (!existsSync2(templatePath)) {
-        return Result3.err(new CreateError(`Template '${change.template}' not found in ${templatesDir}`));
-      }
-      if (change.overlayBaseTemplate) {
-        const basePath = join2(templatesDir, "_base");
-        if (existsSync2(basePath)) {
-          const baseWrittenPaths = new Set;
-          const baseResult = copyTemplateFiles(basePath, targetDir, values, force, false, undefined, baseWrittenPaths);
-          if (baseResult.isErr()) {
-            return baseResult;
-          }
-          const templateResult2 = copyTemplateFiles(templatePath, targetDir, values, force, true, baseWrittenPaths);
-          if (templateResult2.isErr()) {
-            return templateResult2;
-          }
-          continue;
-        }
-      }
-      const templateResult = copyTemplateFiles(templatePath, targetDir, values, force);
-      if (templateResult.isErr()) {
-        return templateResult;
-      }
-      continue;
-    }
-    if (change.type === "inject-shared-config") {
-      const result = injectSharedConfig(targetDir);
-      if (result.isErr()) {
-        return result;
-      }
-      continue;
-    }
-    if (change.type === "rewrite-local-dependencies") {
-      const result = rewriteLocalDependencies(targetDir);
-      if (result.isErr()) {
-        return result;
-      }
-      continue;
-    }
-    if (change.type === "add-blocks") {
-      const result = await addBlocks(targetDir, change.blocks, force);
-      if (result.isErr()) {
-        return result;
-      }
-      blocksAdded = result.value;
-    }
-  }
-  return Result3.ok(blocksAdded);
-}
-function buildWorkspaceRootPackageJson(workspaceName, projectDirName) {
-  const packagePath = `packages/${projectDirName}`;
-  const workspacePackage = {
-    name: workspaceName,
-    private: true,
-    version: "0.1.0",
-    workspaces: ["packages/*"],
-    scripts: {
-      build: `bun run --cwd ${packagePath} build`,
-      dev: `bun run --cwd ${packagePath} dev`,
-      test: `bun run --cwd ${packagePath} test`,
-      typecheck: `bun run --cwd ${packagePath} typecheck`,
-      lint: `bun run --cwd ${packagePath} lint`,
-      "lint:fix": `bun run --cwd ${packagePath} lint:fix`,
-      format: `bun run --cwd ${packagePath} format`
-    }
-  };
-  return `${JSON.stringify(workspacePackage, null, 2)}
-`;
-}
-function scaffoldWorkspaceRoot(rootDir, workspaceName, projectDirName, force) {
-  const packageJsonPath = join2(rootDir, "package.json");
-  if (existsSync2(packageJsonPath) && !force) {
-    return Result3.err(new CreateError(`Directory '${rootDir}' already has a package.json. Use --force to overwrite.`));
-  }
-  try {
-    if (!existsSync2(rootDir)) {
-      mkdirSync2(rootDir, { recursive: true });
-    }
-    mkdirSync2(join2(rootDir, "packages"), { recursive: true });
-    writeFileSync2(packageJsonPath, buildWorkspaceRootPackageJson(workspaceName, projectDirName), "utf-8");
-    const gitignorePath = join2(rootDir, ".gitignore");
-    if (force || !existsSync2(gitignorePath)) {
-      writeFileSync2(gitignorePath, `node_modules
-**/dist
-`, "utf-8");
-    }
-    return Result3.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result3.err(new CreateError(`Failed to scaffold workspace root: ${message}`));
-  }
-}
-async function resolveInput(options) {
-  const rootDir = resolve2(options.targetDir);
-  const defaultName = basename(rootDir);
-  if (options.yes) {
-    const packageName2 = (options.name ?? defaultName).trim();
-    if (packageName2.length === 0) {
-      return Result3.err(new CreateError("Project name must not be empty"));
-    }
-    const structure = options.structure ?? "single";
-    const blocksOverride2 = parseBlocks(options.with);
-    const workspaceName2 = (options.workspaceName ?? defaultName).trim() || defaultName;
-    return Result3.ok({
-      rootDir,
-      packageName: packageName2,
-      preset: options.preset ?? "basic",
-      structure,
-      includeTooling: !(options.noTooling ?? false),
-      local: Boolean(options.local),
-      ...blocksOverride2 ? { blocksOverride: blocksOverride2 } : {},
-      ...structure === "workspace" ? { workspaceName: workspaceName2 } : {}
-    });
-  }
-  intro("Outfitter create");
-  const packageNameValue = options.name ?? await text({
-    message: "Project package name",
-    placeholder: defaultName,
-    initialValue: defaultName,
-    validate: (value) => value.trim().length === 0 ? "Project name is required" : undefined
-  });
-  if (isCancel(packageNameValue)) {
-    cancel("Create cancelled.");
-    return Result3.err(new CreateError("Create cancelled"));
-  }
-  const presetValue = options.preset ?? await select({
-    message: "Select a preset",
-    options: CREATE_PRESET_IDS.map((id) => ({
-      value: id,
-      label: id,
-      hint: CREATE_PRESETS[id].summary
-    })),
-    initialValue: "basic"
-  });
-  if (isCancel(presetValue)) {
-    cancel("Create cancelled.");
-    return Result3.err(new CreateError("Create cancelled"));
-  }
-  const structureValue = options.structure ?? await select({
-    message: "Project structure",
-    options: [
-      {
-        value: "single",
-        label: "Single package",
-        hint: "One package in the target directory"
-      },
-      {
-        value: "workspace",
-        label: "Workspace",
-        hint: "Root workspace with project under packages/"
-      }
-    ],
-    initialValue: "single"
-  });
-  if (isCancel(structureValue)) {
-    cancel("Create cancelled.");
-    return Result3.err(new CreateError("Create cancelled"));
-  }
-  const includeTooling = options.noTooling !== undefined ? !options.noTooling : await confirm({
-    message: "Add default tooling blocks?",
-    initialValue: true
-  });
-  if (isCancel(includeTooling)) {
-    cancel("Create cancelled.");
-    return Result3.err(new CreateError("Create cancelled"));
-  }
-  const localValue = options.local !== undefined ? options.local : await confirm({
-    message: "Use workspace:* for @outfitter dependencies?",
-    initialValue: false
-  });
-  if (isCancel(localValue)) {
-    cancel("Create cancelled.");
-    return Result3.err(new CreateError("Create cancelled"));
-  }
-  let workspaceName;
-  if (structureValue === "workspace") {
-    const workspaceNameValue = options.workspaceName ?? await text({
-      message: "Workspace package name",
-      placeholder: defaultName,
-      initialValue: defaultName,
-      validate: (value) => value.trim().length === 0 ? "Workspace name is required" : undefined
-    });
-    if (isCancel(workspaceNameValue)) {
-      cancel("Create cancelled.");
-      return Result3.err(new CreateError("Create cancelled"));
-    }
-    workspaceName = workspaceNameValue.trim();
-  }
-  outro("Scaffolding project...");
-  const packageName = packageNameValue.trim();
-  if (packageName.length === 0) {
-    return Result3.err(new CreateError("Project name must not be empty"));
-  }
-  const blocksOverride = parseBlocks(options.with);
-  return Result3.ok({
-    rootDir,
-    packageName,
-    preset: presetValue,
-    structure: structureValue,
-    includeTooling,
-    local: Boolean(localValue),
-    ...blocksOverride ? { blocksOverride } : {},
-    ...workspaceName ? { workspaceName } : {}
-  });
-}
-async function runCreate(options) {
-  const inputResult = await resolveInput(options);
-  if (inputResult.isErr()) {
-    return inputResult;
-  }
-  const input = inputResult.value;
-  const projectDir = input.structure === "workspace" ? join2(input.rootDir, "packages", deriveProjectName2(input.packageName)) : input.rootDir;
-  const planResult = planCreateProject({
-    name: input.packageName,
-    targetDir: projectDir,
-    preset: input.preset,
-    includeTooling: input.includeTooling,
-    local: input.local,
-    year: resolveYear()
-  });
-  if (planResult.isErr()) {
-    return Result3.err(new CreateError(planResult.error.message));
-  }
-  const plan = applyBlockOverrides(planResult.value, input.blocksOverride);
-  if (input.structure === "workspace") {
-    const workspaceName = input.workspaceName && input.workspaceName.length > 0 ? input.workspaceName : basename(input.rootDir);
-    const workspaceResult = scaffoldWorkspaceRoot(input.rootDir, workspaceName, deriveProjectName2(input.packageName), options.force);
-    if (workspaceResult.isErr()) {
-      return workspaceResult;
-    }
-  } else if (existsSync2(join2(input.rootDir, "package.json")) && !options.force) {
-    return Result3.err(new CreateError(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite.`));
-  }
-  const executeResult = await executePlan(plan, options.force);
-  if (executeResult.isErr()) {
-    return executeResult;
-  }
-  return Result3.ok({
-    structure: input.structure,
-    rootDir: input.rootDir,
-    projectDir,
-    preset: input.preset,
-    packageName: input.packageName,
-    blocksAdded: executeResult.value
-  });
-}
-async function printCreateResults(result, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output2({
-      structure: result.structure,
-      rootDir: result.rootDir,
-      projectDir: result.projectDir,
-      preset: result.preset,
-      packageName: result.packageName,
-      blocksAdded: result.blocksAdded ?? null,
-      nextSteps: ["bun install", "bun run build", "bun run test"]
-    }, { mode });
-    return;
-  }
-  const lines = [
-    `Project created successfully in ${result.rootDir}`,
-    `Structure: ${result.structure}`,
-    `Preset: ${result.preset}`
-  ];
-  if (result.structure === "workspace") {
-    lines.push(`Workspace project path: ${result.projectDir}`);
-  }
-  if (result.blocksAdded) {
-    if (result.blocksAdded.created.length > 0) {
-      lines.push("", `Added ${result.blocksAdded.created.length} tooling file(s):`);
-      for (const file of result.blocksAdded.created) {
-        lines.push(`  ✓ ${file}`);
-      }
-    }
-    if (result.blocksAdded.skipped.length > 0) {
-      lines.push("", `Skipped ${result.blocksAdded.skipped.length} existing file(s):`);
-      for (const file of result.blocksAdded.skipped) {
-        lines.push(`  - ${file}`);
-      }
-    }
-  }
-  lines.push("", "Next steps:");
-  if (result.structure === "workspace") {
-    lines.push("  bun install", `  bun run --cwd ${result.projectDir} dev`);
-  } else {
-    lines.push("  bun install", "  bun run dev");
-  }
-  await output2(lines);
-}
-function createCommand(program) {
-  program.command("create [directory]").description("Interactive scaffolding flow for Outfitter projects").option("-n, --name <name>", "Package name").option("-p, --preset <preset>", `Preset to scaffold (${CREATE_PRESET_IDS.join(", ")})`).option("-s, --structure <mode>", "Project structure (single|workspace)").option("--workspace-name <name>", "Workspace root package name").option("--local", "Use workspace:* for @outfitter dependencies", false).option("--workspace", "Alias for --local", false).option("-f, --force", "Overwrite existing files", false).option("--with <blocks>", "Comma-separated tooling blocks to add").option("--no-tooling", "Skip default tooling blocks").option("-y, --yes", "Skip prompts and use defaults", false).action(async (targetDir, flags) => {
-    const result = await runCreate({
-      targetDir: targetDir ?? process.cwd(),
-      name: flags.name,
-      preset: flags.preset,
-      structure: flags.structure,
-      workspaceName: flags.workspaceName,
-      local: Boolean(flags.local || flags.workspace),
-      force: Boolean(flags.force),
-      with: flags.with,
-      noTooling: flags.noTooling,
-      yes: Boolean(flags.yes)
-    });
-    if (result.isErr()) {
-      exitWithError(result.error);
-      return;
-    }
-    await printCreateResults(result.value);
-  });
-}
-
-// src/commands/doctor.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { join as join3, resolve as resolve3 } from "node:path";
-import { output as output3 } from "@outfitter/cli/output";
-import { createTheme } from "@outfitter/cli/render";
-var MIN_BUN_VERSION = "1.3.6";
-function checkBunVersion() {
-  const required = MIN_BUN_VERSION;
-  const current = Bun.version;
-  const passed = Bun.semver.satisfies(current, `>=${required}`);
-  return {
-    passed,
-    version: current,
-    required,
-    ...passed ? {} : {
-      error: `Bun version ${current} is below minimum required ${required}`
-    }
-  };
-}
-function checkPackageJson(cwd) {
-  const packageJsonPath = join3(cwd, "package.json");
-  if (!existsSync3(packageJsonPath)) {
-    return {
-      passed: false,
-      error: "package.json not found in current directory"
-    };
-  }
-  try {
-    const content = readFileSync3(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (typeof parsed["name"] !== "string" || parsed["name"].length === 0) {
-      return {
-        passed: false,
-        error: "package.json is missing required 'name' field"
-      };
-    }
-    if (typeof parsed["version"] !== "string" || parsed["version"].length === 0) {
-      return {
-        passed: false,
-        error: "package.json is missing required 'version' field"
-      };
-    }
-    return {
-      passed: true,
-      name: parsed["name"],
-      version: parsed["version"]
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return {
-      passed: false,
-      error: `package.json is invalid JSON: ${message}`
-    };
-  }
-}
-function checkDependencies(cwd) {
-  const packageJsonPath = join3(cwd, "package.json");
-  if (!existsSync3(packageJsonPath)) {
-    return { passed: true, count: 0 };
-  }
-  try {
-    const content = readFileSync3(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const dependencies = parsed["dependencies"];
-    const devDependencies = parsed["devDependencies"];
-    const allDeps = [
-      ...Object.keys(dependencies ?? {}),
-      ...Object.keys(devDependencies ?? {})
-    ];
-    if (allDeps.length === 0) {
-      return { passed: true, count: 0 };
-    }
-    const nodeModulesPath = join3(cwd, "node_modules");
-    if (!existsSync3(nodeModulesPath)) {
-      return {
-        passed: false,
-        count: allDeps.length,
-        error: "node_modules not found. Run 'bun install' to install dependencies."
-      };
-    }
-    const missing = [];
-    for (const dep of allDeps) {
-      const depPath = join3(nodeModulesPath, dep);
-      if (!existsSync3(depPath)) {
-        missing.push(dep);
-      }
-    }
-    if (missing.length > 0) {
-      return {
-        passed: false,
-        count: allDeps.length,
-        missing,
-        error: `Missing dependencies: ${missing.join(", ")}. Run 'bun install' to install.`
-      };
-    }
-    return { passed: true, count: allDeps.length };
-  } catch {
-    return { passed: true, count: 0 };
-  }
-}
-function checkConfigFiles(cwd) {
-  return {
-    tsconfig: existsSync3(join3(cwd, "tsconfig.json")),
-    biome: existsSync3(join3(cwd, "biome.json"))
-  };
-}
-function checkDirectories(cwd) {
-  return {
-    src: existsSync3(join3(cwd, "src")),
-    tests: existsSync3(join3(cwd, "src", "__tests__")) || existsSync3(join3(cwd, "tests"))
-  };
-}
-function runDoctor(options) {
-  const cwd = resolve3(options.cwd);
-  const bunVersion = checkBunVersion();
-  const packageJson = checkPackageJson(cwd);
-  const dependencies = checkDependencies(cwd);
-  const configFiles = checkConfigFiles(cwd);
-  const directories = checkDirectories(cwd);
-  const checkResults = [
-    bunVersion.passed,
-    packageJson.passed,
-    dependencies.passed,
-    configFiles.tsconfig,
-    directories.src
-  ];
-  const passed = checkResults.filter(Boolean).length;
-  const failed = checkResults.length - passed;
-  const total = checkResults.length;
-  return {
-    checks: {
-      bunVersion,
-      packageJson,
-      dependencies,
-      configFiles,
-      directories
-    },
-    summary: { passed, failed, total },
-    exitCode: failed > 0 ? 1 : 0
-  };
-}
-async function printDoctorResults(result, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output3(result, { mode });
-    return;
-  }
-  const theme = createTheme();
-  const lines = ["", "Outfitter Doctor", "", "=".repeat(50)];
-  const bunIcon = result.checks.bunVersion.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
-  lines.push(`${bunIcon} Bun Version: ${result.checks.bunVersion.version} (requires ${result.checks.bunVersion.required})`);
-  if (result.checks.bunVersion.error) {
-    lines.push(`       ${theme.muted(result.checks.bunVersion.error)}`);
-  }
-  const pkgIcon = result.checks.packageJson.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
-  lines.push(`${pkgIcon} package.json`);
-  if (result.checks.packageJson.error) {
-    lines.push(`       ${theme.muted(result.checks.packageJson.error)}`);
-  } else if (result.checks.packageJson.name) {
-    lines.push(`       ${theme.muted(`${result.checks.packageJson.name}@${result.checks.packageJson.version}`)}`);
-  }
-  const depsIcon = result.checks.dependencies.passed ? theme.success("[PASS]") : theme.error("[FAIL]");
-  lines.push(`${depsIcon} Dependencies`);
-  if (result.checks.dependencies.error) {
-    lines.push(`       ${theme.muted(result.checks.dependencies.error)}`);
-  } else if (result.checks.dependencies.count !== undefined) {
-    lines.push(`       ${theme.muted(`${result.checks.dependencies.count} dependencies installed`)}`);
-  }
-  const tsconfigIcon = result.checks.configFiles.tsconfig ? theme.success("[PASS]") : theme.warning("[WARN]");
-  lines.push(`${tsconfigIcon} tsconfig.json`);
-  const srcIcon = result.checks.directories.src ? theme.success("[PASS]") : theme.warning("[WARN]");
-  lines.push(`${srcIcon} src/ directory`);
-  lines.push("", "=".repeat(50));
-  const summaryColor = result.exitCode === 0 ? theme.success : theme.error;
-  lines.push(summaryColor(`${result.summary.passed}/${result.summary.total} checks passed`));
-  if (result.exitCode !== 0) {
-    lines.push("", theme.muted("Run 'outfitter doctor' after fixing issues to verify."));
-  }
-  await output3(lines);
-}
-function doctorCommand(program) {
-  program.command("doctor").description("Validate environment and dependencies").option("--json", "Output as JSON", false).action(async (_flags, command) => {
-    const resolvedFlags = command.optsWithGlobals();
-    const outputOptions = resolvedFlags.json ? { mode: "json" } : undefined;
-    if (resolvedFlags.json) {
-      process.env["OUTFITTER_JSON"] = "1";
-    }
-    const result = await runDoctor({ cwd: process.cwd() });
-    await printDoctorResults(result, outputOptions);
-    process.exit(result.exitCode);
-  });
-}
-
-// src/commands/init.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
-  statSync as statSync2,
-  writeFileSync as writeFileSync3
-} from "node:fs";
-import { basename as basename2, dirname as dirname3, extname as extname2, join as join4, resolve as resolve4 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { exitWithError as exitWithError2, output as output4 } from "@outfitter/cli/output";
-import { Result as Result4 } from "@outfitter/contracts";
-class InitError extends Error {
-  _tag = "InitError";
-  constructor(message) {
-    super(message);
-    this.name = "InitError";
-  }
-}
-var BINARY_EXTENSIONS2 = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".ico",
-  ".webp",
-  ".bmp",
-  ".tiff",
-  ".svg",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".otf",
-  ".eot",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".ogg",
-  ".webm",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".7z",
-  ".pdf",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".node",
-  ".wasm",
-  ".bin",
-  ".dat",
-  ".db",
-  ".sqlite",
-  ".sqlite3"
-]);
-function isBinaryFile2(filename) {
-  const ext = extname2(filename).toLowerCase();
-  return BINARY_EXTENSIONS2.has(ext);
-}
-function getTemplatesDir2() {
-  let currentDir = dirname3(fileURLToPath3(import.meta.url));
-  for (let i = 0;i < 10; i++) {
-    const templatesPath = join4(currentDir, "templates");
-    if (existsSync4(templatesPath)) {
-      return templatesPath;
-    }
-    currentDir = dirname3(currentDir);
-  }
-  return join4(process.cwd(), "templates");
-}
-function validateTemplate(templateName) {
-  const templatesDir = getTemplatesDir2();
-  const templatePath = join4(templatesDir, templateName);
-  if (!existsSync4(templatePath)) {
-    return Result4.err(new InitError(`Template '${templateName}' not found. Available templates are in: ${templatesDir}`));
-  }
-  return Result4.ok(templatePath);
-}
-function replacePlaceholders2(content, values) {
-  return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-    if (Object.hasOwn(values, key)) {
-      return values[key];
-    }
-    return match;
-  });
-}
-function getOutputFilename2(templateFilename) {
-  if (templateFilename.endsWith(".template")) {
-    return templateFilename.slice(0, -".template".length);
-  }
-  return templateFilename;
-}
-function hasPackageJson(targetDir) {
-  return existsSync4(join4(targetDir, "package.json"));
-}
-function deriveProjectName3(packageName) {
-  if (packageName.startsWith("@")) {
-    const parts = packageName.split("/");
-    if (parts.length > 1 && parts[1]) {
-      return parts[1];
-    }
-  }
-  return packageName;
-}
-function resolvePackageName(options, resolvedTargetDir) {
-  return options.name ?? basename2(resolvedTargetDir);
-}
-function resolveBinName(options, projectName) {
-  return options.bin ?? deriveProjectName3(projectName);
-}
-function resolveTemplateName(options) {
-  return options.template ?? "basic";
-}
-function resolveAuthor() {
-  const fromEnv = process.env["GIT_AUTHOR_NAME"] ?? process.env["GIT_COMMITTER_NAME"] ?? process.env["AUTHOR"] ?? process.env["USER"] ?? process.env["USERNAME"];
-  if (fromEnv) {
-    return fromEnv;
-  }
-  try {
-    const result = Bun.spawnSync(["git", "config", "--get", "user.name"], {
-      stdout: "pipe",
-      stderr: "ignore"
-    });
-    if (result.exitCode === 0) {
-      const value = result.stdout.toString().trim();
-      return value.length > 0 ? value : "";
-    }
-  } catch {}
-  return "";
-}
-function resolveYear2() {
-  return String(new Date().getFullYear());
-}
-function resolveBlocks(options) {
-  if (options.noTooling) {
-    return;
-  }
-  if (options.with) {
-    const blocks = options.with.split(",").map((b) => b.trim()).filter(Boolean);
-    return blocks.length > 0 ? blocks : undefined;
-  }
-  return ["scaffolding"];
-}
-function copyTemplateFiles2(templateDir, targetDir, values, force, allowOverwrite = false) {
-  try {
-    if (!existsSync4(targetDir)) {
-      mkdirSync3(targetDir, { recursive: true });
-    }
-    const entries = readdirSync2(templateDir);
-    for (const entry of entries) {
-      const sourcePath = join4(templateDir, entry);
-      const stat = statSync2(sourcePath);
-      if (stat.isDirectory()) {
-        const targetSubDir = join4(targetDir, entry);
-        const result = copyTemplateFiles2(sourcePath, targetSubDir, values, force, allowOverwrite);
-        if (result.isErr()) {
-          return result;
-        }
-      } else if (stat.isFile()) {
-        const outputFilename = getOutputFilename2(entry);
-        const targetPath = join4(targetDir, outputFilename);
-        if (existsSync4(targetPath) && !force && !allowOverwrite) {
-          return Result4.err(new InitError(`File '${targetPath}' already exists. Use --force to overwrite.`));
-        }
-        if (isBinaryFile2(outputFilename)) {
-          const buffer = readFileSync4(sourcePath);
-          writeFileSync3(targetPath, buffer);
-        } else {
-          const content = readFileSync4(sourcePath, "utf-8");
-          const processedContent = replacePlaceholders2(content, values);
-          writeFileSync3(targetPath, processedContent, "utf-8");
-        }
-      }
-    }
-    return Result4.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result4.err(new InitError(`Failed to copy template files: ${message}`));
-  }
-}
-var DEPENDENCY_SECTIONS2 = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-function rewriteLocalDependencies2(targetDir) {
-  const packageJsonPath = join4(targetDir, "package.json");
-  if (!existsSync4(packageJsonPath)) {
-    return Result4.ok(undefined);
-  }
-  try {
-    const content = readFileSync4(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    let updated = false;
-    for (const section of DEPENDENCY_SECTIONS2) {
-      const deps = parsed[section];
-      if (!deps || typeof deps !== "object" || Array.isArray(deps)) {
-        continue;
-      }
-      const entries = deps;
-      for (const [name, version] of Object.entries(entries)) {
-        if (typeof version === "string" && name.startsWith("@outfitter/") && version !== "workspace:*") {
-          entries[name] = "workspace:*";
-          updated = true;
-        }
-      }
-    }
-    if (updated) {
-      writeFileSync3(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
-`, "utf-8");
-    }
-    return Result4.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result4.err(new InitError(`Failed to update local dependencies: ${message}`));
-  }
-}
-function injectSharedConfig2(targetDir) {
-  const packageJsonPath = join4(targetDir, "package.json");
-  if (!existsSync4(packageJsonPath)) {
-    return Result4.ok(undefined);
-  }
-  try {
-    const content = readFileSync4(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const existingDevDeps = parsed["devDependencies"] ?? {};
-    parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
-    const existingScripts = parsed["scripts"] ?? {};
-    parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
-    writeFileSync3(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
-`, "utf-8");
-    return Result4.ok(undefined);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result4.err(new InitError(`Failed to inject shared config: ${message}`));
-  }
-}
-async function runInit(options) {
-  const { targetDir, force } = options;
-  const resolvedTargetDir = resolve4(targetDir);
-  if (hasPackageJson(resolvedTargetDir) && !force) {
-    return Result4.err(new InitError(`Directory '${resolvedTargetDir}' already has a package.json. ` + `Use --force to overwrite, or use 'outfitter add' to add tooling to an existing project.`));
-  }
-  const templateName = resolveTemplateName(options);
-  const templateResult = validateTemplate(templateName);
-  if (templateResult.isErr()) {
-    return templateResult;
-  }
-  const templatePath = templateResult.value;
-  const packageName = resolvePackageName(options, resolvedTargetDir);
-  const projectName = deriveProjectName3(packageName);
-  const binName = resolveBinName(options, projectName);
-  const author = resolveAuthor();
-  const year = resolveYear2();
-  const values = {
-    name: projectName,
-    projectName,
-    packageName,
-    binName,
-    version: "0.1.0",
-    description: "A new project created with Outfitter",
-    author,
-    year
-  };
-  try {
-    if (!existsSync4(resolvedTargetDir)) {
-      mkdirSync3(resolvedTargetDir, { recursive: true });
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result4.err(new InitError(`Failed to create target directory: ${message}`));
-  }
-  const templatesDir = getTemplatesDir2();
-  const basePath = join4(templatesDir, "_base");
-  if (existsSync4(basePath)) {
-    const baseResult = copyTemplateFiles2(basePath, resolvedTargetDir, values, force);
-    if (baseResult.isErr()) {
-      return baseResult;
-    }
-  }
-  const copyResult = copyTemplateFiles2(templatePath, resolvedTargetDir, values, force, true);
-  if (copyResult.isErr()) {
-    return copyResult;
-  }
-  const injectResult = injectSharedConfig2(resolvedTargetDir);
-  if (injectResult.isErr()) {
-    return injectResult;
-  }
-  if (options.local) {
-    const rewriteResult = rewriteLocalDependencies2(resolvedTargetDir);
-    if (rewriteResult.isErr()) {
-      return rewriteResult;
-    }
-  }
-  const blocks = resolveBlocks(options);
-  let blocksAdded;
-  if (blocks && blocks.length > 0) {
-    const mergedResult = {
-      created: [],
-      skipped: [],
-      overwritten: [],
-      dependencies: {},
-      devDependencies: {}
-    };
-    for (const blockName of blocks) {
-      const addResult = await runAdd({
-        block: blockName,
-        force,
-        dryRun: false,
-        cwd: resolvedTargetDir
-      });
-      if (addResult.isErr()) {
-        return Result4.err(new InitError(`Failed to add block '${blockName}': ${addResult.error.message}`));
-      }
-      const blockResult = addResult.value;
-      mergedResult.created.push(...blockResult.created);
-      mergedResult.skipped.push(...blockResult.skipped);
-      mergedResult.overwritten.push(...blockResult.overwritten);
-      Object.assign(mergedResult.dependencies, blockResult.dependencies);
-      Object.assign(mergedResult.devDependencies, blockResult.devDependencies);
-    }
-    blocksAdded = mergedResult;
-  }
-  return Result4.ok({ blocksAdded });
-}
-async function printInitResults(targetDir, result, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output4({
-      targetDir: resolve4(targetDir),
-      blocksAdded: result.blocksAdded ?? null,
-      nextSteps: ["bun install", "bun run dev"]
-    }, { mode });
-    return;
-  }
-  const lines = [
-    `Project initialized successfully in ${resolve4(targetDir)}`
-  ];
-  if (result.blocksAdded) {
-    const { created, skipped, dependencies, devDependencies } = result.blocksAdded;
-    if (created.length > 0) {
-      lines.push("", `Added ${created.length} tooling file(s):`);
-      for (const file of created) {
-        lines.push(`  ✓ ${file}`);
-      }
-    }
-    if (skipped.length > 0) {
-      lines.push("", `Skipped ${skipped.length} existing file(s):`);
-      for (const file of skipped) {
-        lines.push(`  - ${file}`);
-      }
-    }
-    const depCount = Object.keys(dependencies).length + Object.keys(devDependencies).length;
-    if (depCount > 0) {
-      lines.push("", `Added ${depCount} package(s) to package.json:`);
-      for (const [name, version] of Object.entries(dependencies)) {
-        lines.push(`  + ${name}@${version}`);
-      }
-      for (const [name, version] of Object.entries(devDependencies)) {
-        lines.push(`  + ${name}@${version} (dev)`);
-      }
-    }
-  }
-  lines.push("", "Next steps:", "  bun install", "  bun run dev");
-  await output4(lines);
-}
-function initCommand(program) {
-  const init = program.command("init").description("Scaffold a new Outfitter project");
-  const resolveFlags = (flags, command) => {
-    if (command) {
-      return command.optsWithGlobals();
-    }
-    return typeof flags.opts === "function" ? flags.opts() : flags;
-  };
-  const resolveLocal = (flags) => Boolean(flags.local || flags.workspace);
-  const withCommonOptions = (command) => command.option("-n, --name <name>", "Package name (defaults to directory name)").option("-b, --bin <name>", "Binary name (defaults to project name)").option("-f, --force", "Overwrite existing files", false).option("--local", "Use workspace:* for @outfitter dependencies", false).option("--workspace", "Alias for --local", false).option("--with <blocks>", "Tooling to add (comma-separated: scaffolding, claude, biome, lefthook, bootstrap)").option("--no-tooling", "Skip tooling setup").option("--json", "Output as JSON", false);
-  const resolveOutputMode = (flags) => {
-    if (flags.json) {
-      process.env["OUTFITTER_JSON"] = "1";
-      return "json";
-    }
-    return;
-  };
-  withCommonOptions(init.argument("[directory]").option("-t, --template <template>", "Template to use")).action(async (directory, flags, command) => {
-    const targetDir = directory ?? process.cwd();
-    const resolvedFlags = resolveFlags(flags, command);
-    const mode = resolveOutputMode(resolvedFlags);
-    const outputOptions = mode ? { mode } : undefined;
-    const local = resolveLocal(resolvedFlags);
-    const result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      template: resolvedFlags.template,
-      local,
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
-    });
-    if (result.isErr()) {
-      exitWithError2(result.error, outputOptions);
-    }
-    await printInitResults(targetDir, result.value, outputOptions);
-  });
-  withCommonOptions(init.command("cli [directory]").description("Scaffold a new CLI project")).action(async (directory, flags, command) => {
-    const targetDir = directory ?? process.cwd();
-    const resolvedFlags = resolveFlags(flags, command);
-    const mode = resolveOutputMode(resolvedFlags);
-    const outputOptions = mode ? { mode } : undefined;
-    const local = resolveLocal(resolvedFlags);
-    const result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      template: "cli",
-      local,
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
-    });
-    if (result.isErr()) {
-      exitWithError2(result.error, outputOptions);
-    }
-    await printInitResults(targetDir, result.value, outputOptions);
-  });
-  withCommonOptions(init.command("mcp [directory]").description("Scaffold a new MCP server")).action(async (directory, flags, command) => {
-    const targetDir = directory ?? process.cwd();
-    const resolvedFlags = resolveFlags(flags, command);
-    const mode = resolveOutputMode(resolvedFlags);
-    const outputOptions = mode ? { mode } : undefined;
-    const local = resolveLocal(resolvedFlags);
-    const result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      template: "mcp",
-      local,
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
-    });
-    if (result.isErr()) {
-      exitWithError2(result.error, outputOptions);
-    }
-    await printInitResults(targetDir, result.value, outputOptions);
-  });
-  withCommonOptions(init.command("daemon [directory]").description("Scaffold a new daemon project")).action(async (directory, flags, command) => {
-    const targetDir = directory ?? process.cwd();
-    const resolvedFlags = resolveFlags(flags, command);
-    const mode = resolveOutputMode(resolvedFlags);
-    const outputOptions = mode ? { mode } : undefined;
-    const local = resolveLocal(resolvedFlags);
-    const result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      template: "daemon",
-      local,
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
-    });
-    if (result.isErr()) {
-      exitWithError2(result.error, outputOptions);
-    }
-    await printInitResults(targetDir, result.value, outputOptions);
-  });
-}
-
-// src/commands/migrate-kit.ts
-import {
-  existsSync as existsSync5,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync5,
-  statSync as statSync3,
-  writeFileSync as writeFileSync4
-} from "node:fs";
-import { basename as basename3, dirname as dirname4, join as join5, relative, resolve as resolve5 } from "node:path";
-import { output as output5 } from "@outfitter/cli/output";
-import { Result as Result5 } from "@outfitter/contracts";
-import ts from "typescript";
-var FOUNDATION_IMPORT_MAP = {
-  "@outfitter/contracts": "@outfitter/kit/foundation/contracts",
-  "@outfitter/types": "@outfitter/kit/foundation/types"
-};
-var FOUNDATION_PACKAGES = [
-  "@outfitter/contracts",
-  "@outfitter/types"
-];
-var DEPENDENCY_SECTIONS3 = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies"
-];
-var SOURCE_EXTENSIONS = new Set([
-  ".ts",
-  ".tsx",
-  ".mts",
-  ".cts",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs"
-]);
-var IGNORED_DIRECTORIES = new Set([
-  ".git",
-  ".next",
-  ".turbo",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules",
-  "out"
-]);
-
-class MigrateKitError extends Error {
-  _tag = "MigrateKitError";
-  constructor(message) {
-    super(message);
-    this.name = "MigrateKitError";
-  }
-}
-function normalizePath(filePath) {
-  return filePath.replaceAll("\\", "/");
-}
-function parseManifest(filePath) {
-  try {
-    const raw = readFileSync5(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return Result5.err(new MigrateKitError(`Invalid package.json at ${filePath}`));
-    }
-    return Result5.ok(parsed);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result5.err(new MigrateKitError(`Failed to read package.json at ${filePath}: ${message}`));
-  }
-}
-function resolveWorkspacePatterns(manifest) {
-  const workspaces = manifest["workspaces"];
-  if (Array.isArray(workspaces)) {
-    return workspaces.filter((value) => typeof value === "string");
-  }
-  if (!workspaces || typeof workspaces !== "object" || Array.isArray(workspaces)) {
-    return [];
-  }
-  const packages = workspaces.packages;
-  if (!Array.isArray(packages)) {
-    return [];
-  }
-  return packages.filter((value) => typeof value === "string");
-}
-function normalizeWorkspacePattern(pattern) {
-  let value = pattern.trim().replaceAll("\\", "/");
-  if (value.length === 0)
-    return value;
-  if (value.endsWith("/")) {
-    value = value.slice(0, -1);
-  }
-  if (value.endsWith("package.json")) {
-    return value;
-  }
-  return `${value}/package.json`;
-}
-function collectPackageJsonFiles(rootDir) {
-  const rootPackageJson = join5(rootDir, "package.json");
-  if (!existsSync5(rootPackageJson)) {
-    return Result5.err(new MigrateKitError(`No package.json found at ${rootPackageJson}`));
-  }
-  const manifestResult = parseManifest(rootPackageJson);
-  if (manifestResult.isErr()) {
-    return manifestResult;
-  }
-  const workspacePatterns = resolveWorkspacePatterns(manifestResult.value);
-  const files = new Set([rootPackageJson]);
-  for (const pattern of workspacePatterns) {
-    const normalized = normalizeWorkspacePattern(pattern);
-    if (normalized.length === 0) {
-      continue;
-    }
-    const glob = new Bun.Glob(normalized);
-    for (const entry of glob.scanSync({ cwd: rootDir })) {
-      const absolute = resolve5(rootDir, entry);
-      if (existsSync5(absolute) && basename3(absolute) === "package.json") {
-        files.add(absolute);
-      }
-    }
-  }
-  return Result5.ok(Array.from(files).sort((a, b) => a.localeCompare(b)));
-}
-function isSourceFile(filename) {
-  for (const extension of SOURCE_EXTENSIONS) {
-    if (filename.endsWith(extension)) {
-      return true;
-    }
-  }
-  return false;
-}
-function collectSourceFiles(packageDir) {
-  const files = [];
-  const stack = [packageDir];
-  while (stack.length > 0) {
-    const currentDir = stack.pop();
-    if (!currentDir)
-      continue;
-    let entries;
-    try {
-      entries = readdirSync3(currentDir).sort((a, b) => a.localeCompare(b));
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return Result5.err(new MigrateKitError(`Failed to read source directory ${currentDir}: ${message}`));
-    }
-    for (const entry of entries) {
-      const fullPath = join5(currentDir, entry);
-      let stat;
-      try {
-        stat = statSync3(fullPath);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return Result5.err(new MigrateKitError(`Failed to read source tree entry ${fullPath}: ${message}`));
-      }
-      if (stat.isDirectory()) {
-        if (IGNORED_DIRECTORIES.has(entry)) {
-          continue;
-        }
-        if (existsSync5(join5(fullPath, "package.json"))) {
-          continue;
-        }
-        stack.push(fullPath);
-        continue;
-      }
-      if (!stat.isFile()) {
-        continue;
-      }
-      if (!isSourceFile(entry)) {
-        continue;
-      }
-      files.push(fullPath);
-    }
-  }
-  return Result5.ok(files.sort((a, b) => a.localeCompare(b)));
-}
-function getScriptKind(filePath) {
-  if (filePath.endsWith(".tsx"))
-    return ts.ScriptKind.TSX;
-  if (filePath.endsWith(".ts"))
-    return ts.ScriptKind.TS;
-  if (filePath.endsWith(".mts"))
-    return ts.ScriptKind.TS;
-  if (filePath.endsWith(".cts"))
-    return ts.ScriptKind.TS;
-  if (filePath.endsWith(".jsx"))
-    return ts.ScriptKind.JSX;
-  if (filePath.endsWith(".js"))
-    return ts.ScriptKind.JS;
-  if (filePath.endsWith(".mjs"))
-    return ts.ScriptKind.JS;
-  if (filePath.endsWith(".cjs"))
-    return ts.ScriptKind.JS;
-  return ts.ScriptKind.Unknown;
-}
-function mapFoundationSpecifier(specifier) {
-  return FOUNDATION_IMPORT_MAP[specifier];
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function collectRemainingFoundationImports(content) {
-  const remaining = new Set;
-  for (const foundationPackage of FOUNDATION_PACKAGES) {
-    const pattern = new RegExp(`["']${escapeRegex(foundationPackage)}(?:\\/[^"'\\s]+)?["']`);
-    if (pattern.test(content)) {
-      remaining.add(foundationPackage);
-    }
-  }
-  return remaining;
-}
-function mergeFoundationImportsForPackage(byPackage, packageDir, imports) {
-  if (imports.size === 0) {
-    return;
-  }
-  const existing = byPackage.get(packageDir);
-  if (existing) {
-    for (const importPath of imports) {
-      existing.add(importPath);
-    }
-    return;
-  }
-  byPackage.set(packageDir, new Set(imports));
-}
-function findOwningPackageDir(filePath, packageDirs) {
-  const normalizedFilePath = normalizePath(filePath);
-  for (const packageDir of packageDirs) {
-    const normalizedPackageDir = normalizePath(packageDir);
-    if (normalizedFilePath === normalizedPackageDir || normalizedFilePath.startsWith(`${normalizedPackageDir}/`)) {
-      return packageDir;
-    }
-  }
-  return;
-}
-function quoteForLiteral(literalText) {
-  return literalText.startsWith("'") ? "'" : '"';
-}
-function enqueueModuleSpecifierReplacement(sourceFile, literal, replacements) {
-  const mapped = mapFoundationSpecifier(literal.text);
-  if (!mapped) {
-    return false;
-  }
-  const quote = quoteForLiteral(literal.getText(sourceFile));
-  replacements.push({
-    start: literal.getStart(sourceFile),
-    end: literal.getEnd(),
-    text: `${quote}${mapped}${quote}`
-  });
-  return true;
-}
-function enqueueImportTypeReplacement(sourceFile, node, replacements) {
-  const argument = node.argument;
-  if (!ts.isLiteralTypeNode(argument)) {
-    return false;
-  }
-  if (!ts.isStringLiteral(argument.literal)) {
-    return false;
-  }
-  return enqueueModuleSpecifierReplacement(sourceFile, argument.literal, replacements);
-}
-function enqueueCallExpressionReplacement(sourceFile, node, replacements) {
-  const [firstArg] = node.arguments;
-  if (!(firstArg && ts.isStringLiteral(firstArg))) {
-    return false;
-  }
-  const isDynamicImport = node.expression.kind === ts.SyntaxKind.ImportKeyword;
-  const isRequireCall = ts.isIdentifier(node.expression) && node.expression.text === "require";
-  if (!(isDynamicImport || isRequireCall)) {
-    return false;
-  }
-  return enqueueModuleSpecifierReplacement(sourceFile, firstArg, replacements);
-}
-function applyReplacements(content, replacements) {
-  if (replacements.length === 0) {
-    return content;
-  }
-  let next = content;
-  const ordered = [...replacements].sort((a, b) => b.start - a.start);
-  for (const replacement of ordered) {
-    next = next.slice(0, replacement.start) + replacement.text + next.slice(replacement.end);
-  }
-  return next;
-}
-function rewriteFoundationImports(filePath) {
-  let content;
-  try {
-    content = readFileSync5(filePath, "utf-8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result5.err(new MigrateKitError(`Failed to read source file ${filePath}: ${message}`));
-  }
-  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
-  const replacements = [];
-  let rewrites = 0;
-  function visit(node) {
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-      if (enqueueModuleSpecifierReplacement(sourceFile, node.moduleSpecifier, replacements)) {
-        rewrites += 1;
-      }
-    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-      if (enqueueModuleSpecifierReplacement(sourceFile, node.moduleSpecifier, replacements)) {
-        rewrites += 1;
-      }
-    } else if (ts.isImportTypeNode(node)) {
-      if (enqueueImportTypeReplacement(sourceFile, node, replacements)) {
-        rewrites += 1;
-      }
-    } else if (ts.isCallExpression(node) && enqueueCallExpressionReplacement(sourceFile, node, replacements)) {
-      rewrites += 1;
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  if (replacements.length === 0) {
-    return Result5.ok({ content, rewrites: 0 });
-  }
-  return Result5.ok({
-    content: applyReplacements(content, replacements),
-    rewrites
-  });
-}
-function sortRecord(value) {
-  if (!value)
-    return value;
-  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
-}
-function rewriteManifestDependencies(content, options) {
-  let manifest;
-  try {
-    const parsed = JSON.parse(content);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return Result5.err(new MigrateKitError("package.json must contain an object"));
-    }
-    manifest = parsed;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return Result5.err(new MigrateKitError(`Invalid package.json JSON: ${message}`));
-  }
-  const keepFoundationPackages = options?.keepFoundationPackages;
-  const addKitDependency = options?.addKitDependency ?? false;
-  let changed = false;
-  let kitVersionCandidate;
-  let kitSectionCandidate;
-  for (const section of DEPENDENCY_SECTIONS3) {
-    const current = manifest[section];
-    if (!current || typeof current !== "object" || Array.isArray(current)) {
-      continue;
-    }
-    const deps = { ...current };
-    for (const foundationName of FOUNDATION_PACKAGES) {
-      const version = deps[foundationName];
-      if (typeof version !== "string") {
-        continue;
-      }
-      if (!kitVersionCandidate) {
-        kitVersionCandidate = version;
-        kitSectionCandidate = section;
-      }
-      if (keepFoundationPackages?.has(foundationName)) {
-        continue;
-      }
-      delete deps[foundationName];
-      changed = true;
-    }
-    manifest[section] = sortRecord(deps);
-  }
-  let hasKitDependency = false;
-  for (const section of DEPENDENCY_SECTIONS3) {
-    const current = manifest[section];
-    if (!current || typeof current !== "object" || Array.isArray(current)) {
-      continue;
-    }
-    const deps = current;
-    if (typeof deps["@outfitter/kit"] === "string") {
-      hasKitDependency = true;
-      break;
-    }
-  }
-  const shouldAddKit = addKitDependency || changed;
-  if (kitVersionCandidate && shouldAddKit && !hasKitDependency) {
-    const targetSection = kitSectionCandidate ?? "dependencies";
-    const existingSection = manifest[targetSection];
-    const deps = existingSection && typeof existingSection === "object" && !Array.isArray(existingSection) ? { ...existingSection } : {};
-    deps["@outfitter/kit"] = kitVersionCandidate;
-    manifest[targetSection] = sortRecord(deps);
-    changed = true;
-  }
-  if (!changed) {
-    return Result5.ok({ content, changed: false });
-  }
-  return Result5.ok({
-    content: `${JSON.stringify(manifest, null, 2)}
-`,
-    changed: true
-  });
-}
-function splitLines(value) {
-  return value.replace(/\r\n/g, `
-`).split(`
-`);
-}
-function createLineDiff(before, after) {
-  const left = splitLines(before);
-  const right = splitLines(after);
-  const rows = left.length + 1;
-  const cols = right.length + 1;
-  const lcs = Array.from({ length: rows }, () => new Array(cols).fill(0));
-  for (let i2 = left.length - 1;i2 >= 0; i2 -= 1) {
-    const row = lcs[i2];
-    if (!row) {
-      continue;
-    }
-    for (let j2 = right.length - 1;j2 >= 0; j2 -= 1) {
-      const leftLine = left[i2];
-      const rightLine = right[j2];
-      if (leftLine === rightLine) {
-        row[j2] = 1 + (lcs[i2 + 1]?.[j2 + 1] ?? 0);
-      } else {
-        row[j2] = Math.max(lcs[i2 + 1]?.[j2] ?? 0, lcs[i2]?.[j2 + 1] ?? 0);
-      }
-    }
-  }
-  const ops = [];
-  let i = 0;
-  let j = 0;
-  while (i < left.length && j < right.length) {
-    const leftLine = left[i];
-    const rightLine = right[j];
-    if (leftLine === undefined || rightLine === undefined) {
-      break;
-    }
-    if (leftLine === rightLine) {
-      ops.push({ type: "equal", line: leftLine });
-      i += 1;
-      j += 1;
-      continue;
-    }
-    if ((lcs[i + 1]?.[j] ?? 0) >= (lcs[i]?.[j + 1] ?? 0)) {
-      ops.push({ type: "remove", line: leftLine });
-      i += 1;
-    } else {
-      ops.push({ type: "add", line: rightLine });
-      j += 1;
-    }
-  }
-  while (i < left.length) {
-    const line = left[i];
-    if (line === undefined)
-      break;
-    ops.push({ type: "remove", line });
-    i += 1;
-  }
-  while (j < right.length) {
-    const line = right[j];
-    if (line === undefined)
-      break;
-    ops.push({ type: "add", line });
-    j += 1;
-  }
-  return ops;
-}
-function createUnifiedDiff(filePath, before, after) {
-  if (before === after) {
-    return "";
-  }
-  const ops = createLineDiff(before, after);
-  const context = 3;
-  const changedIndexes = ops.map((op, index) => op.type === "equal" ? -1 : index).filter((index) => index >= 0);
-  if (changedIndexes.length === 0) {
-    return "";
-  }
-  const firstChanged = changedIndexes[0];
-  if (firstChanged === undefined) {
-    return "";
-  }
-  const hunks = [];
-  let groupStart = firstChanged;
-  let previous = firstChanged;
-  for (let index = 1;index < changedIndexes.length; index += 1) {
-    const current = changedIndexes[index];
-    if (current === undefined) {
-      continue;
-    }
-    if (current - previous <= context * 2) {
-      previous = current;
-      continue;
-    }
-    hunks.push({
-      start: Math.max(0, groupStart - context),
-      end: Math.min(ops.length, previous + context + 1)
-    });
-    groupStart = current;
-    previous = current;
-  }
-  hunks.push({
-    start: Math.max(0, groupStart - context),
-    end: Math.min(ops.length, previous + context + 1)
-  });
-  const oldLineAt = [];
-  const newLineAt = [];
-  let oldLine = 1;
-  let newLine = 1;
-  for (const op of ops) {
-    oldLineAt.push(oldLine);
-    newLineAt.push(newLine);
-    if (op.type !== "add") {
-      oldLine += 1;
-    }
-    if (op.type !== "remove") {
-      newLine += 1;
-    }
-  }
-  const lines = [`--- a/${filePath}`, `+++ b/${filePath}`];
-  for (const hunk of hunks) {
-    const oldStart = oldLineAt[hunk.start] ?? 1;
-    const newStart = newLineAt[hunk.start] ?? 1;
-    let oldCount = 0;
-    let newCount = 0;
-    for (let index = hunk.start;index < hunk.end; index += 1) {
-      const op = ops[index];
-      if (!op) {
-        continue;
-      }
-      if (op.type !== "add") {
-        oldCount += 1;
-      }
-      if (op.type !== "remove") {
-        newCount += 1;
-      }
-    }
-    lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
-    for (let index = hunk.start;index < hunk.end; index += 1) {
-      const op = ops[index];
-      if (!op) {
-        continue;
-      }
-      if (op.type === "equal") {
-        lines.push(` ${op.line}`);
-      } else if (op.type === "remove") {
-        lines.push(`-${op.line}`);
-      } else {
-        lines.push(`+${op.line}`);
-      }
-    }
-  }
-  return `${lines.join(`
-`)}
-`;
-}
-function writeChanges(changes, dryRun) {
-  if (dryRun) {
-    return Result5.ok(undefined);
-  }
-  for (const change of changes) {
-    try {
-      writeFileSync4(change.path, change.after, "utf-8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return Result5.err(new MigrateKitError(`Failed to write ${change.path}: ${message}`));
-    }
-  }
-  return Result5.ok(undefined);
-}
-async function runMigrateKit(options) {
-  const targetDir = resolve5(options.targetDir ?? process.cwd());
-  const dryRun = options.dryRun ?? false;
-  const packageJsonResult = collectPackageJsonFiles(targetDir);
-  if (packageJsonResult.isErr()) {
-    return packageJsonResult;
-  }
-  const packageJsonFiles = packageJsonResult.value;
-  const packageDirectories = Array.from(new Set(packageJsonFiles.map((path) => resolve5(dirname4(path))))).sort((left, right) => right.length - left.length);
-  const sourceSet = new Set;
-  for (const packageDir of packageDirectories) {
-    const sourceFilesResult = collectSourceFiles(packageDir);
-    if (sourceFilesResult.isErr()) {
-      return sourceFilesResult;
-    }
-    for (const file of sourceFilesResult.value) {
-      sourceSet.add(file);
-    }
-  }
-  const sourceFiles = Array.from(sourceSet).sort((a, b) => a.localeCompare(b));
-  const remainingFoundationImportsByPackage = new Map;
-  const rewritesByPackage = new Map;
-  const changes = [];
-  const diffs = [];
-  let importRewrites = 0;
-  let manifestUpdates = 0;
-  for (const sourceFile of sourceFiles) {
-    const rewriteResult = rewriteFoundationImports(sourceFile);
-    if (rewriteResult.isErr()) {
-      return rewriteResult;
-    }
-    const packageDir = findOwningPackageDir(sourceFile, packageDirectories);
-    if (packageDir) {
-      const remainingImports = collectRemainingFoundationImports(rewriteResult.value.content);
-      mergeFoundationImportsForPackage(remainingFoundationImportsByPackage, packageDir, remainingImports);
-      if (rewriteResult.value.rewrites > 0) {
-        rewritesByPackage.set(packageDir, (rewritesByPackage.get(packageDir) ?? 0) + rewriteResult.value.rewrites);
-      }
-    }
-    if (rewriteResult.value.rewrites === 0) {
-      continue;
-    }
-    const before = readFileSync5(sourceFile, "utf-8");
-    const after = rewriteResult.value.content;
-    if (before === after) {
-      continue;
-    }
-    importRewrites += rewriteResult.value.rewrites;
-    const path = normalizePath(relative(targetDir, sourceFile));
-    changes.push({ path: sourceFile, before, after });
-    diffs.push({ path, preview: createUnifiedDiff(path, before, after) });
-  }
-  for (const packageJsonPath of packageJsonFiles) {
-    let before;
-    try {
-      before = readFileSync5(packageJsonPath, "utf-8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return Result5.err(new MigrateKitError(`Failed to read ${packageJsonPath}: ${message}`));
-    }
-    const packageDir = resolve5(dirname4(packageJsonPath));
-    const keepFoundationPackages = remainingFoundationImportsByPackage.get(packageDir);
-    const rewriteResult = rewriteManifestDependencies(before, {
-      ...keepFoundationPackages ? { keepFoundationPackages } : {},
-      addKitDependency: (rewritesByPackage.get(packageDir) ?? 0) > 0
-    });
-    if (rewriteResult.isErr()) {
-      return rewriteResult;
-    }
-    if (!rewriteResult.value.changed || rewriteResult.value.content === before) {
-      continue;
-    }
-    manifestUpdates += 1;
-    const path = normalizePath(relative(targetDir, packageJsonPath));
-    changes.push({
-      path: packageJsonPath,
-      before,
-      after: rewriteResult.value.content
-    });
-    diffs.push({
-      path,
-      preview: createUnifiedDiff(path, before, rewriteResult.value.content)
-    });
-  }
-  const writeResult = writeChanges(changes, dryRun);
-  if (writeResult.isErr()) {
-    return writeResult;
-  }
-  const changedFiles = changes.map((change) => normalizePath(relative(targetDir, change.path))).sort((a, b) => a.localeCompare(b));
-  return Result5.ok({
-    targetDir,
-    dryRun,
-    packageJsonFiles: packageJsonFiles.length,
-    sourceFiles: sourceFiles.length,
-    manifestUpdates,
-    importRewrites,
-    changedFiles,
-    diffs: diffs.sort((left, right) => left.path.localeCompare(right.path))
-  });
-}
-async function printMigrateKitResults(result, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output5(result, { mode });
-    return;
-  }
-  const lines = [];
-  if (result.changedFiles.length === 0) {
-    lines.push("No kit migration changes needed.");
-    await output5(lines);
-    return;
-  }
-  lines.push(result.dryRun ? "Dry run complete. No files were written." : "Migration complete.", "");
-  lines.push(`Changed files: ${result.changedFiles.length}`);
-  lines.push(`Import rewrites: ${result.importRewrites}`);
-  lines.push(`Manifest updates: ${result.manifestUpdates}`, "");
-  for (const file of result.changedFiles) {
-    lines.push(`  - ${file}`);
-  }
-  if (result.dryRun && result.diffs.length > 0) {
-    lines.push("", "Diff preview:", "");
-    for (const diff of result.diffs) {
-      lines.push(diff.preview.trimEnd(), "");
-    }
-  }
-  await output5(lines);
-}
-function migrateKitCommand(program) {
-  const existingMigrate = program.commands.find((command) => command.name() === "migrate");
-  const migrate = existingMigrate ?? program.command("migrate").description("Migration commands");
-  if (migrate.commands.some((command) => command.name() === "kit")) {
-    return;
-  }
-  migrate.command("kit [directory]").description("Migrate foundation imports and dependencies to @outfitter/kit").option("--dry-run", "Preview changes without writing files", false).option("--json", "Output result as JSON", false).action(async (directory, flags) => {
-    if (flags.json) {
-      process.env["OUTFITTER_JSON"] = "1";
-    }
-    const result = await runMigrateKit({
-      ...directory ? { targetDir: directory } : {},
-      dryRun: Boolean(flags.dryRun)
-    });
-    if (result.isErr()) {
-      throw result.error;
-    }
-    await printMigrateKitResults(result.value, flags.json ? { mode: "json" } : undefined);
-  });
-}
-
-// src/actions.ts
-import { resolve as resolve7 } from "node:path";
-import { output as output8 } from "@outfitter/cli/output";
-import {
-  createActionRegistry,
-  defineAction,
-  InternalError as InternalError2,
-  Result as Result7
-} from "@outfitter/contracts";
-import { z } from "zod";
-
-// src/commands/demo.ts
-import { isCancel as isCancel2, select as select2 } from "@clack/prompts";
-import { output as output6 } from "@outfitter/cli/output";
-import { createTheme as createTheme3, renderTable as renderTable2, SPINNERS } from "@outfitter/cli/render";
-import { ANSI } from "@outfitter/cli/streaming";
-import { isInteractive } from "@outfitter/cli/terminal";
-
-// src/commands/demo/index.ts
-import {
-  getPrimitive,
-  getPrimitiveIds,
-  renderAllDemos,
-  renderDemo
-} from "@outfitter/cli/demo";
-var appSections = [];
-var DEMO_CONFIG = {
-  examples: {
-    success: "Package published",
-    error: "Init failed",
-    warning: "Deprecated API",
-    spinnerMessage: "Installing dependencies...",
-    boxTitle: "Outfitter",
-    boxContent: "CLI scaffolding tool"
-  }
-};
-function registerSection(section) {
-  appSections.push(section);
-}
-function getSectionIds() {
-  const primitiveIds = getPrimitiveIds();
-  const appIds = appSections.map((s) => s.id);
-  return [...primitiveIds, ...appIds];
-}
-function getSections() {
-  const primitiveSections = getPrimitiveIds().map((id) => {
-    const meta = getPrimitive(id);
-    return {
-      id: meta.id,
-      description: meta.description,
-      run: () => renderDemo(id, DEMO_CONFIG)
-    };
-  });
-  return [...primitiveSections, ...appSections];
-}
-function getSection(id) {
-  const primitiveIds = getPrimitiveIds();
-  if (primitiveIds.includes(id)) {
-    const meta = getPrimitive(id);
-    return {
-      id: meta.id,
-      description: meta.description,
-      run: () => renderDemo(id, DEMO_CONFIG)
-    };
-  }
-  return appSections.find((s) => s.id === id);
-}
-function runSection(id) {
-  const section = getSection(id);
-  if (!section) {
-    return;
-  }
-  return section.run();
-}
-function runAllSections() {
-  const outputs = [];
-  outputs.push(renderAllDemos(DEMO_CONFIG));
-  for (const section of appSections) {
-    outputs.push("");
-    outputs.push(section.run());
-  }
-  return outputs.join(`
-`).trimEnd();
-}
-
-// src/commands/demo/errors.ts
-import { createTheme as createTheme2, renderTable } from "@outfitter/cli/render";
-import {
-  AuthError,
-  exitCodeMap,
-  NotFoundError,
-  statusCodeMap,
-  ValidationError as ValidationError2
-} from "@outfitter/contracts";
-function getErrorInfos() {
-  return [
-    { name: "ValidationError", category: "validation" },
-    { name: "NotFoundError", category: "not_found" },
-    { name: "ConflictError", category: "conflict" },
-    { name: "PermissionError", category: "permission" },
-    { name: "TimeoutError", category: "timeout" },
-    { name: "RateLimitError", category: "rate_limit" },
-    { name: "NetworkError", category: "network" },
-    { name: "InternalError", category: "internal" },
-    { name: "AuthError", category: "auth" },
-    { name: "CancelledError", category: "cancelled" }
-  ];
-}
-function formatErrorHuman(error) {
-  return `${error._tag}: ${error.message}`;
-}
-function formatErrorJson(error) {
-  const result = {
-    message: error.message,
-    _tag: error._tag,
-    category: error.category
-  };
-  if (error.context !== undefined) {
-    result["context"] = error.context;
-  }
-  return JSON.stringify(result);
-}
-function runErrorsDemo() {
-  const theme = createTheme2();
-  const lines = [];
-  lines.push("ERROR OUTPUT");
-  lines.push("============");
-  lines.push("");
-  lines.push('import { exitWithError } from "@outfitter/cli";');
-  lines.push('import { ValidationError, NotFoundError } from "@outfitter/contracts";');
-  lines.push("");
-  const validationError = new ValidationError2({
-    message: "Invalid email format",
-    field: "email"
-  });
-  lines.push("// Human mode (TTY):");
-  lines.push('exitWithError(new ValidationError({ message: "Invalid email format" }))');
-  lines.push(`→ stderr: "${formatErrorHuman(validationError)}"`);
-  lines.push(`→ exit code: ${validationError.exitCode()}`);
-  lines.push("");
-  const notFoundError = new NotFoundError({
-    message: "User not found",
-    resourceType: "user",
-    resourceId: "abc123"
-  });
-  lines.push('exitWithError(new NotFoundError({ message: "User not found", ... }))');
-  lines.push(`→ stderr: "${formatErrorHuman(notFoundError)}"`);
-  lines.push(`→ exit code: ${notFoundError.exitCode()}`);
-  lines.push("");
-  lines.push("// JSON mode (pipe/CI):");
-  const validationWithContext = new ValidationError2({
-    message: "Invalid email",
-    field: "email"
-  });
-  lines.push('exitWithError(new ValidationError({ message: "Invalid email", field: "email" }))');
-  lines.push(`→ stderr: ${formatErrorJson({
-    ...validationWithContext,
-    context: { field: "email" }
-  })}`);
-  lines.push(`→ exit code: ${validationWithContext.exitCode()}`);
-  lines.push("");
-  lines.push("ERROR TAXONOMY → EXIT CODES");
-  lines.push("===========================");
-  lines.push("");
-  const taxonomyData = getErrorInfos().map((info) => ({
-    Category: info.category,
-    "Exit Code": exitCodeMap[info.category],
-    "HTTP Status": statusCodeMap[info.category],
-    "Example Error": info.name
-  }));
-  lines.push(renderTable(taxonomyData));
-  lines.push("");
-  lines.push("CREATING ERRORS");
-  lines.push("===============");
-  lines.push("");
-  lines.push('import { ValidationError, NotFoundError, TimeoutError } from "@outfitter/contracts";');
-  lines.push("");
-  lines.push("// Input validation failed");
-  lines.push('new ValidationError({ message: "Email format invalid", field: "email" })');
-  lines.push("");
-  lines.push("// Resource not found");
-  lines.push('new NotFoundError({ message: "note not found: abc123", resourceType: "note", resourceId: "abc123" })');
-  lines.push("");
-  lines.push("// Operation timed out");
-  lines.push('new TimeoutError({ message: "Database query timed out", operation: "query", timeoutMs: 5000 })');
-  lines.push("");
-  lines.push("MODE DETECTION");
-  lines.push("==============");
-  lines.push("");
-  lines.push("Output mode auto-detected:");
-  lines.push("- TTY → human-readable format");
-  lines.push("- Pipe/CI → JSON format");
-  lines.push("- OUTFITTER_JSON=1 → force JSON");
-  lines.push("- OUTFITTER_JSONL=1 → force JSONL");
-  lines.push("");
-  lines.push("ERROR METHODS");
-  lines.push("=============");
-  lines.push("");
-  lines.push("All error classes provide:");
-  lines.push("- .exitCode() → CLI exit code (from exitCodeMap)");
-  lines.push("- .statusCode() → HTTP status code (from statusCodeMap)");
-  lines.push("- .category → error category string");
-  lines.push("- ._tag → error type name (e.g., 'ValidationError')");
-  lines.push("");
-  const authError = new AuthError({
-    message: "Invalid token",
-    reason: "expired"
-  });
-  lines.push(theme.muted("Example:"));
-  lines.push(`const err = new AuthError({ message: "Invalid token", reason: "expired" })`);
-  lines.push(`err.exitCode()   // ${authError.exitCode()}`);
-  lines.push(`err.statusCode() // ${authError.statusCode()}`);
-  lines.push(`err.category     // "${authError.category}"`);
-  lines.push(`err._tag         // "${authError._tag}"`);
-  return lines.join(`
-`);
-}
-registerSection({
-  id: "errors",
-  description: "Error taxonomy and output formatting",
-  run: runErrorsDemo
-});
-
-// src/commands/demo.ts
-async function runDemo(options) {
-  if (options.list) {
-    return listSections();
-  }
-  if (options.animate) {
-    await runAnimatedSpinnerDemo();
-    return { output: "", exitCode: 0 };
-  }
-  if (options.section) {
-    return runSectionByName(options.section);
-  }
-  if (isInteractive()) {
-    const selectedSection = await selectSection();
-    if (selectedSection === null) {
-      return { output: "", exitCode: 130 };
-    }
-    return runSectionByName(selectedSection);
-  }
-  const output7 = runAllSections();
-  return { output: output7, exitCode: 0 };
-}
-function runSectionByName(sectionName) {
-  if (sectionName === "all") {
-    const output8 = runAllSections();
-    return { output: output8, exitCode: 0 };
-  }
-  const output7 = runSection(sectionName);
-  if (output7 === undefined) {
-    return {
-      output: formatError(sectionName),
-      exitCode: 1
-    };
-  }
-  return { output: output7, exitCode: 0 };
-}
-async function selectSection() {
-  const sections = getSections();
-  const options = [
-    { value: "all", label: "All sections", hint: "Run all demos" },
-    ...sections.map((s) => ({
-      value: s.id,
-      label: s.id,
-      hint: s.description
-    }))
-  ];
-  const selection = await select2({
-    message: "Select a demo section",
-    options
-  });
-  if (isCancel2(selection)) {
-    return null;
-  }
-  return String(selection);
-}
-function listSections() {
-  const sections = getSections();
-  const theme = createTheme3();
-  if (sections.length === 0) {
-    return {
-      output: theme.muted("No demo sections available."),
-      exitCode: 0
-    };
-  }
-  const lines = [
-    "Available demo sections:",
-    "",
-    renderTable2(sections.map((s) => ({ section: s.id, description: s.description })), { headers: { section: "Section", description: "Description" } }),
-    "",
-    theme.muted('Run "outfitter demo [section]" to run a specific section.'),
-    theme.muted('Run "outfitter demo all" to run all sections.')
-  ];
-  return { output: lines.join(`
-`), exitCode: 0 };
-}
-function formatError(sectionId) {
-  const theme = createTheme3();
-  const available = getSectionIds();
-  const lines = [
-    theme.error(`Unknown section: ${sectionId}`),
-    "",
-    `Available sections: ${available.length > 0 ? available.join(", ") : "(none)"}`,
-    "",
-    theme.muted('Run "outfitter demo --list" to see all sections.')
-  ];
-  return lines.join(`
-`);
-}
-async function runAnimatedSpinnerDemo() {
-  const theme = createTheme3();
-  const styles = Object.keys(SPINNERS);
-  const intervalMs = 80;
-  const stream = process.stdout;
-  const isTTY = stream.isTTY ?? false;
-  const writeLine = (line) => {
-    stream.write(`${line}
-`);
-  };
-  writeLine("");
-  writeLine(theme.bold("ANIMATED SPINNER DEMO"));
-  writeLine(theme.muted("All styles running simultaneously"));
-  writeLine(theme.muted("Press Ctrl+C to stop"));
-  writeLine("");
-  if (!isTTY) {
-    for (const style of styles) {
-      const spinner = SPINNERS[style];
-      writeLine(`${style.padEnd(10)} ${spinner.frames.join(" ")}`);
-    }
-    return;
-  }
-  stream.write(ANSI.hideCursor);
-  const numLines = styles.length;
-  for (const style of styles) {
-    const spinner = SPINNERS[style];
-    const frame = spinner.frames[0] ?? "";
-    stream.write(`  ${frame}  ${style.padEnd(10)} ${theme.muted(`(${spinner.interval}ms)`)}
-`);
-  }
-  const frameIndices = styles.map(() => 0);
-  const animate = () => {
-    stream.write(ANSI.cursorUp(numLines));
-    for (let i = 0;i < styles.length; i++) {
-      const style = styles[i];
-      if (!style)
-        continue;
-      const spinner = SPINNERS[style];
-      const frameIndex = frameIndices[i] ?? 0;
-      const frame = spinner.frames[frameIndex % spinner.frames.length] ?? "";
-      stream.write(ANSI.clearLine);
-      stream.write(`  ${frame}  ${style.padEnd(10)} ${theme.muted(`(${spinner.interval}ms)`)}
-`);
-      frameIndices[i] = frameIndex + 1;
-    }
-  };
-  const timer = setInterval(animate, intervalMs);
-  const cleanup = () => {
-    clearInterval(timer);
-    stream.write(ANSI.showCursor);
-    writeLine("");
-    writeLine(theme.muted("Use createSpinner() from @outfitter/cli/streaming"));
-    writeLine("");
-    process.exit(0);
-  };
-  process.on("SIGINT", cleanup);
-  await new Promise(() => {});
-}
-async function printDemoResults(result) {
-  if (result.output) {
-    await output6(result.output, { mode: "human" });
-  }
-}
-
-// src/commands/update.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { join as join6, resolve as resolve6 } from "node:path";
-import { output as output7 } from "@outfitter/cli/output";
-import { createTheme as createTheme4 } from "@outfitter/cli/render";
-import { InternalError, Result as Result6 } from "@outfitter/contracts";
-function getInstalledPackages(cwd) {
-  const pkgPath = join6(cwd, "package.json");
-  if (!existsSync6(pkgPath)) {
-    return Result6.err(InternalError.create("No package.json found", { cwd }));
-  }
-  let raw;
-  try {
-    raw = readFileSync6(pkgPath, "utf-8");
-  } catch {
-    return Result6.err(InternalError.create("Failed to read package.json", { cwd }));
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(raw);
-  } catch {
-    return Result6.err(InternalError.create("Invalid JSON in package.json", { cwd }));
-  }
-  const deps = {
-    ...pkg.dependencies ?? {},
-    ...pkg.devDependencies ?? {}
-  };
-  const packages = [];
-  for (const [name, version] of Object.entries(deps)) {
-    if (!name.startsWith("@outfitter/"))
-      continue;
-    if (version.startsWith("workspace:")) {
-      const wsVersion = version.slice("workspace:".length);
-      if (wsVersion === "*" || wsVersion === "~" || wsVersion === "^") {
-        continue;
-      }
-      const wsClean = wsVersion.replace(/^[\^~>=<]+/, "");
-      try {
-        if (!Bun.semver.satisfies(wsClean, "*"))
-          continue;
-      } catch {
-        continue;
-      }
-      packages.push({ name, version: wsClean });
-      continue;
-    }
-    const cleaned = version.replace(/^[\^~>=<]+/, "");
-    try {
-      if (!Bun.semver.satisfies(cleaned, "*"))
-        continue;
-    } catch {
-      continue;
-    }
-    packages.push({ name, version: cleaned });
-  }
-  return Result6.ok(packages);
-}
-async function getLatestVersion(name) {
-  try {
-    const proc = Bun.spawn(["npm", "view", name, "version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const stdout = await new Response(proc.stdout).text();
-    const exitCode = await proc.exited;
-    if (exitCode !== 0)
-      return null;
-    return stdout.trim() || null;
-  } catch {
-    return null;
-  }
-}
-var MIGRATION_DOC_PATHS = [
-  "plugins/kit/shared/migrations",
-  "node_modules/@outfitter/kit/shared/migrations"
-];
-function findMigrationDocsDir(cwd, binaryDir) {
-  for (const relative2 of MIGRATION_DOC_PATHS) {
-    const dir = join6(cwd, relative2);
-    if (existsSync6(dir))
-      return dir;
-  }
-  let current = resolve6(cwd);
-  const root = resolve6("/");
-  while (current !== root) {
-    const parent = resolve6(current, "..");
-    if (parent === current)
-      break;
-    current = parent;
-    for (const relative2 of MIGRATION_DOC_PATHS) {
-      const dir = join6(current, relative2);
-      if (existsSync6(dir))
-        return dir;
-    }
-  }
-  const resolvedBinaryDir = binaryDir ?? resolve6(import.meta.dir, "../../../..");
-  for (const relative2 of MIGRATION_DOC_PATHS) {
-    const dir = join6(resolvedBinaryDir, relative2);
-    if (existsSync6(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 = join6(migrationsDir, entry);
-    const content = readFileSync6(filePath, "utf-8");
-    const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "").trim();
-    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);
-}
-async function runUpdate(options) {
-  const cwd = resolve6(options.cwd);
-  const installedResult = getInstalledPackages(cwd);
-  if (installedResult.isErr())
-    return installedResult;
-  const installed = installedResult.value;
-  if (installed.length === 0) {
-    return Result6.ok({
-      packages: [],
-      total: 0,
-      updatesAvailable: 0,
-      hasBreaking: false
-    });
-  }
-  const packages = await Promise.all(installed.map(async (pkg) => {
-    const latest = await getLatestVersion(pkg.name);
-    const updateAvailable = latest !== null && Bun.semver.order(latest, pkg.version) > 0;
-    const breaking = updateAvailable && latest !== null ? getMajor(latest) > getMajor(pkg.version) : false;
-    return {
-      name: pkg.name,
-      current: pkg.version,
-      latest,
-      updateAvailable,
-      breaking
-    };
-  }));
-  const updatesAvailable = packages.filter((p) => p.updateAvailable).length;
-  const hasBreaking = packages.some((p) => p.breaking);
-  return Result6.ok({
-    packages,
-    total: packages.length,
-    updatesAvailable,
-    hasBreaking
-  });
-}
-function getMajor(version) {
-  const parts = version.split(".");
-  return Number.parseInt(parts[0] ?? "0", 10);
-}
-async function printUpdateResults(result, options) {
-  const mode = options?.mode;
-  if (mode === "json" || mode === "jsonl") {
-    await output7(result, { mode });
-    return;
-  }
-  const theme = createTheme4();
-  const lines = ["", "Outfitter Update", "", "=".repeat(60)];
-  if (result.packages.length === 0) {
-    lines.push("No @outfitter/* packages found in package.json.");
-    await output7(lines);
-    return;
-  }
-  lines.push(`  ${"Package".padEnd(28)} ${"Current".padEnd(10)} ${"Available".padEnd(10)} Migration`);
-  lines.push(`  ${"─".repeat(28)} ${"─".repeat(10)} ${"─".repeat(10)} ${"─".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("major (breaking)");
-    } else {
-      migration = theme.success("minor (no breaking)");
-    }
-    lines.push(`  ${name} ${current} ${available} ${migration}`);
-  }
-  lines.push("");
-  if (result.updatesAvailable > 0) {
-    lines.push(theme.muted("Run 'outfitter update --guide' for migration instructions."));
-  } else {
-    lines.push(theme.success("All packages are up to date."));
-  }
-  if (options?.guide && result.updatesAvailable > 0) {
-    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 output7(lines);
-}
-
-// src/actions.ts
-var outputModeSchema = z.enum(["human", "json", "jsonl"]).optional();
-var initInputSchema = z.object({
-  targetDir: z.string(),
-  name: z.string().optional(),
-  bin: z.string().optional(),
-  template: z.string().optional(),
-  local: z.boolean().optional(),
-  force: z.boolean(),
-  with: z.string().optional(),
-  noTooling: z.boolean().optional(),
-  outputMode: outputModeSchema
-});
-var createInputSchema = z.object({
-  targetDir: z.string(),
-  name: z.string().optional(),
-  preset: z.enum(["basic", "cli", "daemon", "mcp"]).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(),
-  outputMode: outputModeSchema
-});
-var migrateKitInputSchema = z.object({
-  targetDir: z.string(),
-  dryRun: z.boolean(),
-  outputMode: outputModeSchema
-});
-var doctorInputSchema = z.object({
-  cwd: z.string(),
-  outputMode: outputModeSchema
-});
-function resolveStringFlag(value) {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function resolveOutputMode(flags) {
-  if (flags["json"]) {
-    process.env["OUTFITTER_JSON"] = "1";
-    return "json";
-  }
-  return;
-}
-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, templateOverride) {
-  const flags = context.flags;
-  const targetDir = context.args[0] ?? process.cwd();
-  const name = resolveStringFlag(flags.name);
-  const bin = resolveStringFlag(flags.bin);
-  const template = templateOverride ?? resolveStringFlag(flags.template);
-  const local = resolveLocalFlag(flags);
-  const force = Boolean(flags.force);
-  const withBlocks = resolveStringFlag(flags.with);
-  const noTooling = resolveNoToolingFlag(flags);
-  const outputMode = resolveOutputMode(context.flags);
-  return {
-    targetDir,
-    name,
-    template,
-    force,
-    ...local !== undefined ? { local } : {},
-    ...withBlocks ? { with: withBlocks } : {},
-    ...noTooling !== undefined ? { noTooling } : {},
-    ...bin ? { bin } : {},
-    ...outputMode ? { outputMode } : {}
-  };
-}
-function resolveCreateOptions(context) {
-  const flags = context.flags;
-  const outputMode = resolveOutputMode(context.flags);
-  const noTooling = resolveNoToolingFlag(flags);
-  const local = resolveLocalFlag(flags);
-  return {
-    targetDir: context.args[0] ?? process.cwd(),
-    name: resolveStringFlag(flags.name),
-    preset: resolveStringFlag(flags.preset),
-    structure: resolveStringFlag(flags.structure),
-    workspaceName: resolveStringFlag(flags.workspaceName),
-    force: Boolean(flags.force),
-    ...local !== undefined ? { local } : {},
-    with: resolveStringFlag(flags.with),
-    ...noTooling !== undefined ? { noTooling } : {},
-    yes: Boolean(flags.yes),
-    ...outputMode ? { outputMode } : {}
-  };
-}
-function resolveMigrateKitOptions(context) {
-  const flags = context.flags;
-  const outputMode = resolveOutputMode(context.flags);
-  return {
-    targetDir: context.args[0] ?? process.cwd(),
-    dryRun: Boolean(flags.dryRun || context.flags["dry-run"]),
-    ...outputMode ? { 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: "-f, --force",
-    description: "Overwrite existing files",
-    defaultValue: false
-  },
-  {
-    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"
-};
-function createInitAction(options) {
-  const initOptions = options.includeTemplateOption ? [...commonInitOptions, templateOption] : commonInitOptions;
-  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.templateOverride)
-    },
-    handler: async (input) => {
-      const { outputMode, ...initInput } = input;
-      const outputOptions = outputMode ? { mode: outputMode } : undefined;
-      const result = await runInit(initInput);
-      if (result.isErr()) {
-        return Result7.err(new InternalError2({
-          message: result.error.message,
-          context: { action: options.id }
-        }));
-      }
-      await printInitResults(initInput.targetDir, result.value, outputOptions);
-      return Result7.ok({ ok: true });
-    }
-  });
-}
-var createAction = defineAction({
-  id: "create",
-  description: "Interactive scaffolding flow for Outfitter projects (single package or workspace)",
-  surfaces: ["cli"],
-  input: createInputSchema,
-  cli: {
-    command: "create [directory]",
-    description: "Interactive scaffolding flow for Outfitter projects (single package or workspace)",
-    options: [
-      {
-        flags: "-n, --name <name>",
-        description: "Package name"
-      },
-      {
-        flags: "-p, --preset <preset>",
-        description: "Preset to scaffold (basic, cli, daemon, mcp)"
-      },
-      {
-        flags: "-s, --structure <structure>",
-        description: "Project structure (single|workspace)"
-      },
-      {
-        flags: "--workspace-name <name>",
-        description: "Workspace root package name"
-      },
-      {
-        flags: "--local",
-        description: "Use workspace:* for @outfitter dependencies"
-      },
-      {
-        flags: "--workspace",
-        description: "Alias for --local"
-      },
-      {
-        flags: "-f, --force",
-        description: "Overwrite existing files",
-        defaultValue: false
-      },
-      {
-        flags: "--with <blocks>",
-        description: "Comma-separated tooling blocks to add"
-      },
-      {
-        flags: "--no-tooling",
-        description: "Skip default tooling blocks"
-      },
-      {
-        flags: "-y, --yes",
-        description: "Skip prompts and use defaults for missing values",
-        defaultValue: false
-      }
-    ],
-    mapInput: resolveCreateOptions
-  },
-  handler: async (input) => {
-    const { outputMode, ...createInput } = input;
-    const outputOptions = outputMode ? { mode: outputMode } : undefined;
-    const result = await runCreate(createInput);
-    if (result.isErr()) {
-      return Result7.err(new InternalError2({
-        message: result.error.message,
-        context: { action: "create" }
-      }));
-    }
-    await printCreateResults(result.value, outputOptions);
-    return Result7.ok(result.value);
-  }
-});
-var demoInputSchema = z.object({
-  section: z.string().optional(),
-  list: z.boolean().optional(),
-  animate: z.boolean().optional()
-});
-var demoAction = defineAction({
-  id: "demo",
-  description: "Showcase @outfitter/cli rendering capabilities",
-  surfaces: ["cli"],
-  input: demoInputSchema,
-  cli: {
-    command: "demo [section]",
-    description: "Showcase @outfitter/cli rendering capabilities",
-    options: [
-      {
-        flags: "-l, --list",
-        description: "List available demo sections",
-        defaultValue: false
-      },
-      {
-        flags: "-a, --animate",
-        description: "Run animated demo (spinners only)",
-        defaultValue: false
-      }
-    ],
-    mapInput: (context) => {
-      resolveOutputMode(context.flags);
-      return {
-        section: context.args[0],
-        list: Boolean(context.flags["list"]),
-        animate: Boolean(context.flags["animate"])
-      };
-    }
-  },
-  handler: async (input) => {
-    const result = await runDemo(input);
-    await printDemoResults(result);
-    if (result.exitCode !== 0) {
-      process.exit(result.exitCode);
-    }
-    return Result7.ok(result);
-  }
-});
-var doctorAction = defineAction({
-  id: "doctor",
-  description: "Validate environment and dependencies",
-  surfaces: ["cli"],
-  input: doctorInputSchema,
-  cli: {
-    command: "doctor",
-    description: "Validate environment and dependencies",
-    mapInput: (context) => {
-      const outputMode = resolveOutputMode(context.flags);
-      return {
-        cwd: process.cwd(),
-        ...outputMode ? { outputMode } : {}
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...doctorInput } = input;
-    const outputOptions = outputMode ? { mode: outputMode } : undefined;
-    const result = await runDoctor(doctorInput);
-    await printDoctorResults(result, outputOptions);
-    if (result.exitCode !== 0) {
-      process.exit(result.exitCode);
-    }
-    return Result7.ok(result);
-  }
-});
-var addInputSchema = z.object({
-  block: z.string(),
-  force: z.boolean(),
-  dryRun: z.boolean(),
-  cwd: z.string().optional(),
-  outputMode: outputModeSchema
-});
-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: [
-      {
-        flags: "-f, --force",
-        description: "Overwrite existing files",
-        defaultValue: false
-      },
-      {
-        flags: "--dry-run",
-        description: "Show what would be added without making changes",
-        defaultValue: false
-      }
-    ],
-    mapInput: (context) => {
-      const outputMode = resolveOutputMode(context.flags);
-      return {
-        block: context.args[0],
-        force: Boolean(context.flags["force"]),
-        dryRun: Boolean(context.flags["dry-run"] ?? context.flags["dryRun"]),
-        cwd: process.cwd(),
-        ...outputMode ? { outputMode } : {}
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...addInput } = input;
-    const outputOptions = outputMode ? { mode: outputMode } : undefined;
-    const result = await runAdd(addInput);
-    if (result.isErr()) {
-      return Result7.err(new InternalError2({
-        message: result.error.message,
-        context: { action: "add" }
-      }));
-    }
-    await printAddResults(result.value, addInput.dryRun, outputOptions);
-    return Result7.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 = resolveOutputMode(context.flags);
-      return {
-        ...outputMode ? { outputMode } : {}
-      };
-    }
-  },
-  handler: async (input) => {
-    const result = listBlocks();
-    if (result.isErr()) {
-      return Result7.err(new InternalError2({
-        message: result.error.message,
-        context: { action: "add.list" }
-      }));
-    }
-    if (input.outputMode === "json" || input.outputMode === "jsonl") {
-      await output8({ blocks: result.value }, { mode: input.outputMode });
-    } else {
-      const lines = [
-        "Available blocks:",
-        ...result.value.map((block) => `  - ${block}`)
-      ];
-      await output8(lines);
-    }
-    return Result7.ok({ blocks: result.value });
-  }
-});
-var updateInputSchema = z.object({
-  cwd: z.string(),
-  guide: z.boolean(),
-  outputMode: outputModeSchema
-});
-var updateAction = defineAction({
-  id: "update",
-  description: "Check for @outfitter/* package updates and migration guidance",
-  surfaces: ["cli"],
-  input: updateInputSchema,
-  cli: {
-    command: "update",
-    description: "Check for @outfitter/* package updates and migration guidance",
-    options: [
-      {
-        flags: "--guide",
-        description: "Show migration instructions for available updates",
-        defaultValue: false
-      },
-      {
-        flags: "--cwd <path>",
-        description: "Working directory (defaults to current directory)"
-      }
-    ],
-    mapInput: (context) => {
-      const outputMode = resolveOutputMode(context.flags);
-      const cwd = typeof context.flags["cwd"] === "string" ? resolve7(process.cwd(), context.flags["cwd"]) : process.cwd();
-      return {
-        cwd,
-        guide: Boolean(context.flags["guide"]),
-        ...outputMode ? { outputMode } : {}
-      };
-    }
-  },
-  handler: async (input) => {
-    const { outputMode, ...updateInput } = input;
-    const result = await runUpdate(updateInput);
-    if (result.isErr()) {
-      return Result7.err(new InternalError2({
-        message: result.error.message,
-        context: { action: "update" }
-      }));
-    }
-    await printUpdateResults(result.value, {
-      ...outputMode ? { mode: outputMode } : {},
-      guide: updateInput.guide,
-      cwd: updateInput.cwd
-    });
-    return Result7.ok(result.value);
-  }
-});
-var migrateKitAction = defineAction({
-  id: "migrate.kit",
-  description: "Migrate foundation imports and dependencies to @outfitter/kit",
-  surfaces: ["cli"],
-  input: migrateKitInputSchema,
-  cli: {
-    group: "migrate",
-    command: "kit [directory]",
-    description: "Migrate foundation imports and dependencies to @outfitter/kit",
-    options: [
-      {
-        flags: "--dry-run",
-        description: "Preview changes without writing files",
-        defaultValue: false
-      }
-    ],
-    mapInput: resolveMigrateKitOptions
-  },
-  handler: async (input) => {
-    const { outputMode, ...migrateInput } = input;
-    const outputOptions = outputMode ? { mode: outputMode } : undefined;
-    const result = await runMigrateKit(migrateInput);
-    if (result.isErr()) {
-      return Result7.err(new InternalError2({
-        message: result.error.message,
-        context: { action: "migrate.kit" }
-      }));
-    }
-    await printMigrateKitResults(result.value, outputOptions);
-    return Result7.ok(result.value);
-  }
-});
-var outfitterActions = createActionRegistry().add(createAction).add(createInitAction({
-  id: "init",
-  description: "Scaffold a new Outfitter project",
-  command: "[directory]",
-  includeTemplateOption: true
-})).add(createInitAction({
-  id: "init.cli",
-  description: "Scaffold a new CLI project",
-  command: "cli [directory]",
-  templateOverride: "cli"
-})).add(createInitAction({
-  id: "init.mcp",
-  description: "Scaffold a new MCP server",
-  command: "mcp [directory]",
-  templateOverride: "mcp"
-})).add(createInitAction({
-  id: "init.daemon",
-  description: "Scaffold a new daemon project",
-  command: "daemon [directory]",
-  templateOverride: "daemon"
-})).add(demoAction).add(doctorAction).add(addAction).add(listBlocksAction).add(migrateKitAction).add(updateAction);
-
-export { CREATE_PRESETS, CREATE_PRESET_IDS, getCreatePreset, planCreateProject, CreateError, runCreate, printCreateResults, createCommand, runDoctor, printDoctorResults, doctorCommand, InitError, runInit, initCommand, MigrateKitError, runMigrateKit, printMigrateKitResults, migrateKitCommand, outfitterActions };