outfitter 0.2.7 → 0.3.2

package/dist/shared/outfitter-mt7d1ek2.js

@@ -1,698 +0,0 @@
-// @bun
-import {
-  runPostScaffold
-} from "./outfitter-4s9meh3j.js";
-import {
-  INIT_TARGET_IDS,
-  TARGET_REGISTRY,
-  getInitTarget
-} from "./outfitter-xe5mzgdc.js";
-import {
-  OperationCollector
-} from "./outfitter-1h7k8xxt.js";
-import {
-  renderOperationPlan
-} from "./outfitter-ttjr95y9.js";
-import {
-  executePlan
-} from "./outfitter-5akzvppx.js";
-import {
-  scaffoldWorkspaceRoot
-} from "./outfitter-1fy7byz5.js";
-import {
-  deriveBinName,
-  deriveProjectName,
-  isPathWithin,
-  resolveAuthor,
-  resolvePackageName,
-  resolveYear,
-  sanitizePackageName,
-  validatePackageName,
-  validateProjectDirectoryName
-} from "./outfitter-4q1zfmvc.js";
-import {
-  resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
-
-// apps/outfitter/src/commands/init.ts
-import { existsSync } from "fs";
-import { realpath } from "fs/promises";
-import { basename, join, resolve } from "path";
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  outro,
-  select,
-  text
-} from "@clack/prompts";
-import { exitWithError, output } from "@outfitter/cli";
-import { Result } from "@outfitter/contracts";
-class InitError extends Error {
-  _tag = "InitError";
-  constructor(message) {
-    super(message);
-    this.name = "InitError";
-  }
-}
-function parseBlocks(withFlag) {
-  if (!withFlag) {
-    return;
-  }
-  const blocks = withFlag.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
-  return blocks.length > 0 ? blocks : undefined;
-}
-function isBinaryPreset(preset) {
-  return preset === "cli" || preset === "daemon";
-}
-function isValidInitPreset(value) {
-  return value === "minimal" || value === "cli" || value === "mcp" || value === "daemon" || value === "library" || value === "full-stack";
-}
-function resolvePresetFromFlags(options) {
-  const presetFromFlag = options.preset;
-  if (presetFromFlag) {
-    if (!isValidInitPreset(presetFromFlag)) {
-      return Result.err(new InitError(`Unknown preset '${presetFromFlag}'. Available presets: ${INIT_TARGET_IDS.join(", ")}`));
-    }
-    return Result.ok(presetFromFlag);
-  }
-  if (options.template) {
-    const mapped = options.template === "basic" ? "minimal" : options.template;
-    process.stderr.write(`Warning: --template is deprecated and will be removed in the next major version.
-` + `  Use --preset instead: outfitter init --preset ${mapped}
-` + (options.template === "basic" ? `  Note: "basic" has been renamed to "minimal".
-` : ""));
-    if (isValidInitPreset(mapped)) {
-      return Result.ok(mapped);
-    }
-    return Result.err(new InitError(`Unknown template '${options.template}'. Available presets: ${INIT_TARGET_IDS.join(", ")}`));
-  }
-  return Result.ok(undefined);
-}
-async function resolveInitInput(options, presetOverride) {
-  const rootDir = resolve(options.targetDir);
-  const defaultName = basename(rootDir);
-  const defaultPackageName = sanitizePackageName(defaultName) || defaultName;
-  const presetFromFlagsResult = resolvePresetFromFlags(options);
-  if (presetFromFlagsResult.isErr()) {
-    return presetFromFlagsResult;
-  }
-  const presetFromFlags = presetFromFlagsResult.value;
-  if (options.yes || !process.stdout.isTTY) {
-    const packageNameRaw = resolvePackageName(rootDir, options.name).trim();
-    const packageName2 = options.name === undefined ? sanitizePackageName(packageNameRaw) : packageNameRaw;
-    if (packageName2.length === 0) {
-      return Result.err(new InitError("Project name must not be empty"));
-    }
-    const invalidPackageName2 = validatePackageName(packageName2);
-    if (invalidPackageName2) {
-      const suggested = sanitizePackageName(packageNameRaw);
-      const suggestion = suggested.length > 0 && suggested !== packageNameRaw ? ` Try '${suggested}'.` : "";
-      return Result.err(new InitError(`Invalid package name '${packageNameRaw}': ${invalidPackageName2}.${suggestion}`));
-    }
-    const preset = presetOverride ?? presetFromFlags ?? "minimal";
-    const structure = preset === "full-stack" ? "single" : options.structure ?? "single";
-    const blocksOverride2 = parseBlocks(options.with);
-    const workspaceName2 = structure === "workspace" ? (options.workspaceName ?? defaultPackageName).trim() || defaultPackageName : undefined;
-    if (workspaceName2) {
-      const invalidWorkspaceName = validatePackageName(workspaceName2);
-      if (invalidWorkspaceName) {
-        return Result.err(new InitError(`Invalid workspace package name '${workspaceName2}': ${invalidWorkspaceName}`));
-      }
-    }
-    return Result.ok({
-      rootDir,
-      packageName: packageName2,
-      preset,
-      structure,
-      includeTooling: !(options.noTooling ?? false),
-      local: Boolean(options.local),
-      ...blocksOverride2 ? { blocksOverride: blocksOverride2 } : {},
-      ...workspaceName2 ? { workspaceName: workspaceName2 } : {},
-      ...options.bin ? { binName: options.bin } : {}
-    });
-  }
-  intro("Outfitter init");
-  const packageNameValue = options.name ?? await text({
-    message: "Project package name",
-    placeholder: defaultPackageName,
-    initialValue: defaultPackageName,
-    validate: (value) => (value ?? "").trim().length === 0 ? "Project name is required" : undefined
-  });
-  if (isCancel(packageNameValue)) {
-    cancel("Init cancelled.");
-    return Result.err(new InitError("Init cancelled"));
-  }
-  const presetValue = presetOverride ?? presetFromFlags ?? await select({
-    message: "Select a preset",
-    options: INIT_TARGET_IDS.map((id) => {
-      const target = TARGET_REGISTRY.get(id);
-      return {
-        value: id,
-        label: id,
-        hint: target?.description ?? ""
-      };
-    }),
-    initialValue: "minimal"
-  });
-  if (isCancel(presetValue)) {
-    cancel("Init cancelled.");
-    return Result.err(new InitError("Init cancelled"));
-  }
-  const structureValue = presetValue === "full-stack" ? "single" : 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 apps/ or packages/"
-      }
-    ],
-    initialValue: "single"
-  });
-  if (isCancel(structureValue)) {
-    cancel("Init cancelled.");
-    return Result.err(new InitError("Init cancelled"));
-  }
-  let binName;
-  if (isBinaryPreset(presetValue) && process.stdout.isTTY) {
-    const defaultBin = deriveBinName(deriveProjectName(packageNameValue.trim()));
-    const binValue = options.bin ?? await text({
-      message: "Binary name",
-      placeholder: defaultBin,
-      initialValue: defaultBin
-    });
-    if (isCancel(binValue)) {
-      cancel("Init cancelled.");
-      return Result.err(new InitError("Init cancelled"));
-    }
-    binName = binValue.trim();
-  }
-  let includeTooling;
-  if (options.noTooling !== undefined) {
-    includeTooling = !options.noTooling;
-  } else if (options.with !== undefined) {
-    includeTooling = true;
-  } else {
-    includeTooling = await confirm({
-      message: "Add default tooling blocks?",
-      initialValue: true
-    });
-  }
-  if (isCancel(includeTooling)) {
-    cancel("Init cancelled.");
-    return Result.err(new InitError("Init cancelled"));
-  }
-  const localValue = options.local !== undefined ? options.local : await confirm({
-    message: "Use workspace:* for @outfitter dependencies?",
-    initialValue: false
-  });
-  if (isCancel(localValue)) {
-    cancel("Init cancelled.");
-    return Result.err(new InitError("Init cancelled"));
-  }
-  let workspaceName;
-  if (structureValue === "workspace") {
-    const workspaceNameValue = options.workspaceName ?? await text({
-      message: "Workspace package name",
-      placeholder: defaultPackageName,
-      initialValue: defaultPackageName,
-      validate: (value) => (value ?? "").trim().length === 0 ? "Workspace name is required" : undefined
-    });
-    if (isCancel(workspaceNameValue)) {
-      cancel("Init cancelled.");
-      return Result.err(new InitError("Init cancelled"));
-    }
-    workspaceName = workspaceNameValue.trim();
-  }
-  outro("Scaffolding project...");
-  const packageName = packageNameValue.trim();
-  if (packageName.length === 0) {
-    return Result.err(new InitError("Project name must not be empty"));
-  }
-  const invalidPackageName = validatePackageName(packageName);
-  if (invalidPackageName) {
-    const suggested = sanitizePackageName(packageName);
-    const suggestion = suggested.length > 0 && suggested !== packageName ? ` Try '${suggested}'.` : "";
-    return Result.err(new InitError(`Invalid package name '${packageName}': ${invalidPackageName}.${suggestion}`));
-  }
-  if (workspaceName) {
-    const invalidWorkspaceName = validatePackageName(workspaceName);
-    if (invalidWorkspaceName) {
-      return Result.err(new InitError(`Invalid workspace package name '${workspaceName}': ${invalidWorkspaceName}`));
-    }
-  }
-  const blocksOverride = parseBlocks(options.with);
-  return Result.ok({
-    rootDir,
-    packageName,
-    preset: presetValue,
-    structure: structureValue,
-    includeTooling,
-    local: Boolean(localValue),
-    ...blocksOverride ? { blocksOverride } : {},
-    ...workspaceName ? { workspaceName } : {},
-    ...binName ? { binName } : {}
-  });
-}
-function toInitError(error) {
-  if (error instanceof InitError) {
-    return error;
-  }
-  if (error instanceof Error) {
-    return new InitError(error.message);
-  }
-  return new InitError("Unknown init error");
-}
-function buildInitPlan(target, input, projectDir, resolvedBinName) {
-  const blocks = input.includeTooling ? input.blocksOverride ?? [...target.defaultBlocks] : [];
-  return {
-    values: {
-      name: deriveProjectName(input.packageName),
-      projectName: deriveProjectName(input.packageName),
-      packageName: input.packageName,
-      binName: resolvedBinName,
-      version: "0.1.0",
-      description: "A new project created with Outfitter",
-      author: resolveAuthor(),
-      year: resolveYear()
-    },
-    changes: [
-      {
-        type: "copy-template",
-        template: target.templateDir,
-        targetDir: projectDir,
-        overlayBaseTemplate: true
-      },
-      { type: "inject-shared-config" },
-      ...input.local ? [{ type: "rewrite-local-dependencies", mode: "workspace" }] : [],
-      ...blocks.length > 0 ? [{ type: "add-blocks", blocks }] : []
-    ]
-  };
-}
-async function runInit(options, presetOverride) {
-  const inputResult = await resolveInitInput(options, presetOverride);
-  if (inputResult.isErr()) {
-    return inputResult;
-  }
-  const input = inputResult.value;
-  const targetResult = getInitTarget(input.preset);
-  if (targetResult.isErr()) {
-    return Result.err(new InitError(targetResult.error.message));
-  }
-  const target = targetResult.value;
-  const projectName = deriveProjectName(input.packageName);
-  if (input.structure === "workspace") {
-    const invalidProjectName = validateProjectDirectoryName(projectName);
-    if (invalidProjectName) {
-      return Result.err(new InitError(`Invalid workspace project name '${projectName}': ${invalidProjectName}`));
-    }
-  }
-  const dryRun = Boolean(options.dryRun);
-  const collector = dryRun ? new OperationCollector : undefined;
-  const projectBaseDir = resolve(input.rootDir, target.placement);
-  const resolvedProjectDir = resolve(projectBaseDir, projectName);
-  if (input.structure === "workspace" && !isPathWithin(projectBaseDir, resolvedProjectDir)) {
-    return Result.err(new InitError(`Invalid workspace project name '${projectName}': path escapes '${projectBaseDir}'`));
-  }
-  const projectDir = input.structure === "workspace" ? resolvedProjectDir : input.rootDir;
-  if (input.structure === "single") {
-    if (existsSync(join(input.rootDir, "package.json")) && !options.force) {
-      return Result.err(new InitError(`Directory '${input.rootDir}' already has a package.json. ` + `Use --force to overwrite, or use 'outfitter add' for existing projects.`));
-    }
-  } else {
-    const workspaceName = input.workspaceName ?? basename(input.rootDir);
-    const workspacePackageJsonPath = join(input.rootDir, "package.json");
-    if (dryRun) {
-      if (existsSync(workspacePackageJsonPath) && !options.force) {
-        return Result.err(new InitError(`Directory '${input.rootDir}' already has a package.json. Use --force to overwrite.`));
-      }
-      collector?.add({
-        type: "dir-create",
-        path: join(input.rootDir, "apps")
-      });
-      collector?.add({
-        type: "dir-create",
-        path: join(input.rootDir, "packages")
-      });
-      collector?.add(existsSync(workspacePackageJsonPath) ? {
-        type: "file-overwrite",
-        path: workspacePackageJsonPath,
-        source: "generated"
-      } : {
-        type: "file-create",
-        path: workspacePackageJsonPath,
-        source: "generated"
-      });
-      const readmePath = join(input.rootDir, "README.md");
-      if (options.force || !existsSync(readmePath)) {
-        collector?.add(existsSync(readmePath) ? {
-          type: "file-overwrite",
-          path: readmePath,
-          source: "generated"
-        } : {
-          type: "file-create",
-          path: readmePath,
-          source: "generated"
-        });
-      }
-      const gitignorePath = join(input.rootDir, ".gitignore");
-      if (options.force || !existsSync(gitignorePath)) {
-        collector?.add(existsSync(gitignorePath) ? {
-          type: "file-overwrite",
-          path: gitignorePath,
-          source: "generated"
-        } : {
-          type: "file-create",
-          path: gitignorePath,
-          source: "generated"
-        });
-      }
-    } else {
-      const workspaceResult = scaffoldWorkspaceRoot(input.rootDir, workspaceName, options.force);
-      if (workspaceResult.isErr()) {
-        return Result.err(new InitError(workspaceResult.error.message));
-      }
-    }
-  }
-  const resolvedBinName = input.binName ?? deriveBinName(deriveProjectName(input.packageName));
-  const plan = buildInitPlan(target, input, projectDir, resolvedBinName);
-  const executeResult = await executePlan(plan, {
-    force: options.force,
-    ...collector ? { collector } : {}
-  });
-  if (executeResult.isErr()) {
-    return Result.err(toInitError(executeResult.error));
-  }
-  const postScaffoldResult = await runPostScaffold({
-    rootDir: input.rootDir,
-    projectDir,
-    origin: "init",
-    target: input.preset,
-    structure: input.structure,
-    skipInstall: Boolean(options.skipInstall),
-    skipGit: Boolean(options.skipGit),
-    skipCommit: Boolean(options.skipCommit),
-    dryRun,
-    installTimeoutMs: options.installTimeout ?? 60000
-  }, collector);
-  if (postScaffoldResult.isErr()) {
-    return Result.err(new InitError("Post-scaffold step failed"));
-  }
-  const result = {
-    structure: input.structure,
-    rootDir: input.rootDir,
-    projectDir,
-    preset: input.preset,
-    packageName: input.packageName,
-    blocksAdded: executeResult.value.blocksAdded,
-    postScaffold: postScaffoldResult.value,
-    ...collector ? { dryRunPlan: collector.toJSON() } : {}
-  };
-  return Result.ok(result);
-}
-async function printInitResults(result, options) {
-  let rootDir = result.rootDir;
-  let projectDir = result.projectDir;
-  try {
-    rootDir = await realpath(rootDir);
-    projectDir = await realpath(projectDir);
-  } catch {}
-  const structuredMode = resolveStructuredOutputMode(options?.mode);
-  if (result.dryRunPlan) {
-    if (structuredMode) {
-      await output({
-        rootDir,
-        projectDir,
-        structure: result.structure,
-        preset: result.preset,
-        packageName: result.packageName,
-        ...result.dryRunPlan
-      }, { mode: structuredMode });
-      return;
-    }
-    const collector = new OperationCollector;
-    for (const op of result.dryRunPlan.operations) {
-      collector.add(op);
-    }
-    await renderOperationPlan(collector, { rootDir });
-    return;
-  }
-  if (structuredMode) {
-    await output({
-      structure: result.structure,
-      rootDir,
-      projectDir,
-      preset: result.preset,
-      packageName: result.packageName,
-      blocksAdded: result.blocksAdded ?? null,
-      postScaffold: result.postScaffold,
-      nextSteps: result.postScaffold.nextSteps
-    }, { mode: structuredMode });
-    return;
-  }
-  const lines = [
-    `Project initialized successfully in ${rootDir}`,
-    `Structure: ${result.structure}`,
-    `Preset: ${result.preset}`
-  ];
-  if (result.structure === "workspace") {
-    lines.push(`Workspace project path: ${projectDir}`);
-  }
-  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(`  \u2713 ${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)`);
-      }
-    }
-  }
-  if (result.postScaffold.installResult === "failed") {
-    lines.push("", `Warning: bun install failed: ${result.postScaffold.installError ?? "unknown"}`);
-  }
-  if (result.postScaffold.gitInitResult === "failed") {
-    lines.push("", `Warning: git setup failed: ${result.postScaffold.gitError ?? "unknown"}`);
-  }
-  lines.push("", "Next steps:");
-  for (const step of result.postScaffold.nextSteps) {
-    lines.push(`  ${step}`);
-  }
-  await output(lines, { mode: "human" });
-}
-function initCommand(program) {
-  const init = program.command("init").description("Create a new Outfitter project");
-  const resolveFlags = (flags, command) => {
-    if (command) {
-      return command.optsWithGlobals();
-    }
-    return typeof flags.opts === "function" ? flags.opts() : flags;
-  };
-  const resolveLocal = (flags) => {
-    if (flags.local === true || flags.workspace === true) {
-      return true;
-    }
-    return;
-  };
-  const resolveOutputMode = (flags) => {
-    if (flags.json) {
-      return "json";
-    }
-    return;
-  };
-  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("-p, --preset <preset>", "Preset to use (minimal|cli|mcp|daemon|library|full-stack)").option("-s, --structure <mode>", "Project structure (single|workspace)").option("--workspace-name <name>", "Workspace root package name").option("-f, --force", "Overwrite existing files", false).option("--local", "Use workspace:* for @outfitter dependencies").option("--workspace", "Alias for --local").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).option("--dry-run", "Preview changes without writing files", false).option("--skip-install", "Skip bun install", false).option("--skip-git", "Skip git init and initial commit", false).option("--skip-commit", "Skip initial commit only", false).option("--install-timeout <ms>", "bun install timeout in ms");
-  withCommonOptions(init.argument("[directory]").option("-t, --template <template>", "Template to use (deprecated)")).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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      preset: resolvedFlags.preset,
-      template: resolvedFlags.template,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    });
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-  withCommonOptions(init.command("cli [directory]").description("Create 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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    }, "cli");
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-  withCommonOptions(init.command("mcp [directory]").description("Create 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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    }, "mcp");
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-  withCommonOptions(init.command("daemon [directory]").description("Create 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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    }, "daemon");
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-  withCommonOptions(init.command("library [directory]").description("Create a new library")).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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    }, "library");
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-  withCommonOptions(init.command("full-stack [directory]").description("Create a full-stack workspace")).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 result = await runInit({
-      targetDir,
-      name: resolvedFlags.name,
-      bin: resolvedFlags.bin,
-      structure: resolvedFlags.structure,
-      workspaceName: resolvedFlags.workspaceName,
-      local: resolveLocal(resolvedFlags),
-      force: resolvedFlags.force ?? false,
-      with: resolvedFlags.with,
-      noTooling: resolvedFlags.noTooling,
-      yes: resolvedFlags.yes,
-      dryRun: Boolean(resolvedFlags.dryRun),
-      skipInstall: Boolean(resolvedFlags.skipInstall),
-      skipGit: Boolean(resolvedFlags.skipGit),
-      skipCommit: Boolean(resolvedFlags.skipCommit),
-      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
-    }, "full-stack");
-    if (result.isErr()) {
-      exitWithError(result.error, outputOptions);
-      return;
-    }
-    await printInitResults(result.value, outputOptions);
-  });
-}
-
-export { InitError, runInit, printInitResults, initCommand };