outfitter 0.3.2 → 0.3.3

package/dist/shared/outfitter-6mpkh3zn.js

@@ -0,0 +1,432 @@
+// @bun
+import {
+  printInitResults
+} from "./outfitter-n0ed012k.js";
+import {
+  isBinaryPreset,
+  parseBlocks,
+  resolvePresetFromFlags
+} from "./outfitter-2z61gp5w.js";
+import {
+  executeInitPipeline
+} from "./outfitter-tavatb5p.js";
+import {
+  INIT_TARGET_IDS,
+  TARGET_REGISTRY,
+  getInitTarget
+} from "./outfitter-g3hvjshg.js";
+import {
+  deriveBinName,
+  deriveProjectName,
+  resolvePackageName,
+  sanitizePackageName,
+  validatePackageName
+} from "./outfitter-q1g58t85.js";
+
+// apps/outfitter/src/commands/init.ts
+import { basename, resolve } from "path";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  outro,
+  select,
+  text
+} from "@clack/prompts";
+import { exitWithError } from "@outfitter/cli";
+import { Result } from "@outfitter/contracts";
+class InitError extends Error {
+  _tag = "InitError";
+  constructor(message) {
+    super(message);
+    this.name = "InitError";
+  }
+}
+async function resolveInitInput(options, presetOverride) {
+  const rootDir = resolve(options.targetDir);
+  const defaultName = basename(rootDir);
+  const defaultPackageName = sanitizePackageName(defaultName) || defaultName;
+  const presetFromFlagsResult = resolvePresetFromFlags(options.preset, INIT_TARGET_IDS);
+  if (presetFromFlagsResult.isErr()) {
+    return Result.err(new InitError(presetFromFlagsResult.error));
+  }
+  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 } : {}
+  });
+}
+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 executeResult = await executeInitPipeline(input, targetResult.value, {
+    dryRun: Boolean(options.dryRun),
+    force: options.force,
+    skipInstall: Boolean(options.skipInstall),
+    skipGit: Boolean(options.skipGit),
+    skipCommit: Boolean(options.skipCommit),
+    installTimeout: options.installTimeout ?? 60000
+  });
+  if (executeResult.isErr()) {
+    return Result.err(new InitError(executeResult.error));
+  }
+  return Result.ok(executeResult.value);
+}
+var resolveLocal = (flags) => {
+  if (flags.local === true || flags.workspace === true) {
+    return true;
+  }
+  return;
+};
+var resolveOutputMode = (flags) => {
+  if (flags.json) {
+    return "json";
+  }
+  return;
+};
+var 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");
+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;
+  };
+  withCommonOptions(init.argument("[directory]")).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,
+      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, initCommand };

package/dist/shared/outfitter-6rtcemk7.d.ts

@@ -0,0 +1,18 @@
+import { EngineOptions, PlaceholderValues, ScaffoldError } from "./outfitter-cyvr4r8d.js";
+import { Result } from "@outfitter/contracts";
+/**
+* Get the directory containing scaffold preset files.
+* Delegates to `@outfitter/presets` which is the single source of truth.
+*/
+declare function getPresetsBaseDir(): string;
+declare function getOutputFilename(templateFilename: string): string;
+declare function isBinaryFile(filename: string): boolean;
+declare function replacePlaceholders(content: string, values: PlaceholderValues): string;
+declare function copyPresetFiles(presetDir: string, targetDir: string, values: PlaceholderValues, options: EngineOptions, copyOptions?: {
+	readonly allowOverwrite?: boolean;
+	readonly overwritablePaths?: ReadonlySet<string>;
+	readonly writtenPaths?: Set<string>;
+	readonly skipFilter?: (relativePath: string) => boolean;
+	readonly relativePrefix?: string;
+}): Result<void, ScaffoldError>;
+export { getPresetsBaseDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyPresetFiles };

package/dist/shared/outfitter-6t7xeyg1.js

@@ -0,0 +1,159 @@
+// @bun
+import {
+  ScaffoldError
+} from "./outfitter-8y2dfx6n.js";
+
+// apps/outfitter/src/engine/preset.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { extname, join } from "path";
+import { Result } from "@outfitter/contracts";
+import { getPresetsDir } from "@outfitter/presets";
+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"
+]);
+function getPresetsBaseDir() {
+  return getPresetsDir();
+}
+function getOutputFilename(templateFilename) {
+  return templateFilename.endsWith(".template") ? templateFilename.slice(0, -".template".length) : 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 copyPresetFiles(presetDir, targetDir, values, options, copyOptions) {
+  const allowOverwrite = copyOptions?.allowOverwrite ?? false;
+  const relativePrefix = copyOptions?.relativePrefix ?? "";
+  try {
+    if (!existsSync(targetDir)) {
+      if (options.collector) {
+        options.collector.add({
+          type: "dir-create",
+          path: targetDir
+        });
+      } else {
+        mkdirSync(targetDir, { recursive: true });
+      }
+    }
+    const entries = readdirSync(presetDir);
+    for (const entry of entries) {
+      const sourcePath = join(presetDir, entry);
+      const sourceStat = statSync(sourcePath);
+      const relativePath = relativePrefix ? `${relativePrefix}/${entry}` : entry;
+      if (copyOptions?.skipFilter?.(relativePath)) {
+        continue;
+      }
+      if (sourceStat.isDirectory()) {
+        const targetSubDir = join(targetDir, entry);
+        const nestedResult = copyPresetFiles(sourcePath, targetSubDir, values, options, {
+          ...copyOptions,
+          relativePrefix: relativePath
+        });
+        if (nestedResult.isErr()) {
+          return nestedResult;
+        }
+        continue;
+      }
+      if (!sourceStat.isFile()) {
+        continue;
+      }
+      const outputFilename = getOutputFilename(entry);
+      const targetPath = join(targetDir, outputFilename);
+      const targetExists = existsSync(targetPath);
+      const canOverlay = allowOverwrite && (!targetExists || Boolean(copyOptions?.overwritablePaths?.has(targetPath)));
+      if (targetExists && !options.force && !canOverlay) {
+        if (options.collector) {
+          options.collector.add({
+            type: "file-skip",
+            path: targetPath,
+            reason: "exists"
+          });
+          continue;
+        }
+        return Result.err(new ScaffoldError(`File '${targetPath}' already exists. Use --force to overwrite.`));
+      }
+      if (options.collector) {
+        if (targetExists) {
+          options.collector.add({
+            type: "file-overwrite",
+            path: targetPath,
+            source: "preset"
+          });
+        } else {
+          options.collector.add({
+            type: "file-create",
+            path: targetPath,
+            source: "preset"
+          });
+        }
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      if (isBinaryFile(outputFilename)) {
+        const buffer = readFileSync(sourcePath);
+        writeFileSync(targetPath, buffer);
+        copyOptions?.writtenPaths?.add(targetPath);
+        continue;
+      }
+      const content = readFileSync(sourcePath, "utf-8");
+      const processedContent = replacePlaceholders(content, values);
+      writeFileSync(targetPath, processedContent, "utf-8");
+      copyOptions?.writtenPaths?.add(targetPath);
+    }
+    return Result.ok(undefined);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new ScaffoldError(`Failed to copy preset files: ${message}`));
+  }
+}
+
+export { getPresetsBaseDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyPresetFiles };