outfitter 0.2.5 → 0.2.6

package/dist/shared/outfitter-qn864k6h.js

@@ -0,0 +1,581 @@
+// @bun
+import {
+  INIT_TARGET_IDS,
+  TARGET_REGISTRY,
+  getInitTarget
+} from "./outfitter-1dd0k853.js";
+import {
+  runPostScaffold
+} from "./outfitter-4s9meh3j.js";
+import {
+  scaffoldWorkspaceRoot
+} from "./outfitter-2np85etz.js";
+import {
+  deriveBinName,
+  deriveProjectName,
+  resolveAuthor,
+  resolvePackageName,
+  resolveYear
+} from "./outfitter-q9agarmb.js";
+import {
+  executePlan
+} from "./outfitter-66b25bj8.js";
+import {
+  renderOperationPlan
+} from "./outfitter-ttjr95y9.js";
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/init.ts
+import { existsSync } from "fs";
+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";
+}
+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 presetFromFlagsResult = resolvePresetFromFlags(options);
+  if (presetFromFlagsResult.isErr()) {
+    return presetFromFlagsResult;
+  }
+  const presetFromFlags = presetFromFlagsResult.value;
+  if (options.yes || !process.stdout.isTTY) {
+    const packageName2 = resolvePackageName(rootDir, options.name).trim();
+    if (packageName2.length === 0) {
+      return Result.err(new InitError("Project name must not be empty"));
+    }
+    const preset = presetOverride ?? presetFromFlags ?? "minimal";
+    const structure = options.structure ?? "single";
+    const blocksOverride2 = parseBlocks(options.with);
+    const workspaceName2 = structure === "workspace" ? (options.workspaceName ?? defaultName).trim() || defaultName : undefined;
+    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: defaultName,
+    initialValue: defaultName,
+    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 = 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: defaultName,
+      initialValue: defaultName,
+      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 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 dryRun = Boolean(options.dryRun);
+  const collector = dryRun ? new OperationCollector : undefined;
+  const projectDir = input.structure === "workspace" ? join(input.rootDir, target.placement, deriveProjectName(input.packageName)) : 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 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) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (result.dryRunPlan) {
+    if (structuredMode) {
+      await output({
+        rootDir: result.rootDir,
+        projectDir: result.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: result.rootDir });
+    return;
+  }
+  if (structuredMode) {
+    await output({
+      structure: result.structure,
+      rootDir: result.rootDir,
+      projectDir: result.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 ${result.rootDir}`,
+    `Structure: ${result.structure}`,
+    `Preset: ${result.preset}`
+  ];
+  if (result.structure === "workspace") {
+    lines.push(`Workspace project path: ${result.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)").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);
+  });
+}
+
+export { InitError, runInit, printInitResults, initCommand };