outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-5vx1bp7h.js

@@ -0,0 +1,41 @@
+// @bun
+// apps/outfitter/src/commands/jq-utils.ts
+async function applyJq(data, expr, options) {
+  try {
+    const json = JSON.stringify(data);
+    const args = ["jq", ...options?.compact ? ["-c"] : [], expr];
+    const proc = Bun.spawn(args, {
+      stdin: new Response(json),
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (exitCode !== 0) {
+      process.stderr.write(`jq error: ${stderr.trim()}
+`);
+      return options?.compact ? `${JSON.stringify(data)}
+` : `${JSON.stringify(data, null, 2)}
+`;
+    }
+    return stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown jq execution error";
+    const missingBinary = /enoent|not found/i.test(message);
+    if (missingBinary) {
+      process.stderr.write(`jq is not installed. Install jq or omit --jq to continue.
+`);
+    } else {
+      process.stderr.write(`jq execution error: ${message}
+`);
+    }
+    return options?.compact ? `${JSON.stringify(data)}
+` : `${JSON.stringify(data, null, 2)}
+`;
+  }
+}
+
+export { applyJq };

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

@@ -0,0 +1,190 @@
+// @bun
+import {
+  buildScaffoldPlan,
+  convertToWorkspace,
+  detectProjectStructure,
+  ensureWorkspacePattern,
+  validateScaffoldTargetName
+} from "./outfitter-qsd5638j.js";
+import {
+  getScaffoldTarget
+} from "./outfitter-g3hvjshg.js";
+import {
+  deriveProjectName,
+  executePlan,
+  isPathWithin
+} from "./outfitter-q1g58t85.js";
+import {
+  printScaffoldResults
+} from "./outfitter-qsrx7m4w.js";
+import {
+  runPostScaffold
+} from "./outfitter-4s9meh3j.js";
+import {
+  scaffoldWorkspaceRoot
+} from "./outfitter-1fy7byz5.js";
+import {
+  OperationCollector
+} from "./outfitter-1h7k8xxt.js";
+
+// apps/outfitter/src/commands/scaffold.ts
+import { existsSync } from "fs";
+import { basename, join, resolve } from "path";
+import { exitWithError } from "@outfitter/cli";
+import { Result } from "@outfitter/contracts";
+class ScaffoldCommandError extends Error {
+  _tag = "ScaffoldCommandError";
+  constructor(message) {
+    super(message);
+    this.name = "ScaffoldCommandError";
+  }
+}
+async function runScaffold(options) {
+  const targetResult = getScaffoldTarget(options.target);
+  if (targetResult.isErr()) {
+    return Result.err(new ScaffoldCommandError(targetResult.error.message));
+  }
+  const target = targetResult.value;
+  const targetName = deriveProjectName(options.name ?? target.id);
+  const targetNameValidation = validateScaffoldTargetName(targetName);
+  if (targetNameValidation.isErr()) {
+    return Result.err(new ScaffoldCommandError(targetNameValidation.error));
+  }
+  const dryRun = options.dryRun;
+  const collector = dryRun ? new OperationCollector : undefined;
+  const structureResult = detectProjectStructure(options.cwd);
+  if (structureResult.isErr()) {
+    return Result.err(new ScaffoldCommandError(structureResult.error));
+  }
+  let rootDir = resolve(options.cwd);
+  let converted = false;
+  let movedExisting;
+  let workspacePatternsUpdated = false;
+  if (structureResult.value.kind === "workspace") {
+    rootDir = structureResult.value.rootDir;
+    const patternResult = ensureWorkspacePattern(rootDir, target.placement, dryRun, collector);
+    if (patternResult.isErr()) {
+      return Result.err(new ScaffoldCommandError(patternResult.error));
+    }
+    workspacePatternsUpdated = patternResult.value;
+  } else if (structureResult.value.kind === "single-package") {
+    const conversionResult = convertToWorkspace(structureResult.value.rootDir, structureResult.value.packageJson, dryRun, collector);
+    if (conversionResult.isErr()) {
+      return Result.err(new ScaffoldCommandError(conversionResult.error));
+    }
+    rootDir = structureResult.value.rootDir;
+    converted = true;
+    movedExisting = conversionResult.value.movedExisting;
+  } else {
+    const workspaceName = `${basename(rootDir)}-workspace`;
+    if (dryRun) {
+      const packageJsonPath = join(rootDir, "package.json");
+      if (existsSync(packageJsonPath) && !options.force) {
+        return Result.err(new ScaffoldCommandError(`Directory '${rootDir}' already has a package.json. Use --force to overwrite.`));
+      }
+      collector?.add({
+        type: "dir-create",
+        path: join(rootDir, "apps")
+      });
+      collector?.add({
+        type: "dir-create",
+        path: join(rootDir, "packages")
+      });
+      collector?.add(existsSync(packageJsonPath) ? {
+        type: "file-overwrite",
+        path: packageJsonPath,
+        source: "generated"
+      } : {
+        type: "file-create",
+        path: packageJsonPath,
+        source: "generated"
+      });
+      const gitignorePath = join(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(rootDir, workspaceName, options.force);
+      if (workspaceResult.isErr()) {
+        return Result.err(new ScaffoldCommandError(workspaceResult.error.message));
+      }
+    }
+    converted = true;
+  }
+  const targetBaseDir = resolve(rootDir, target.placement);
+  const targetDir = resolve(targetBaseDir, targetName);
+  if (!isPathWithin(targetBaseDir, targetDir)) {
+    return Result.err(new ScaffoldCommandError(`Invalid target name '${targetName}': path escapes '${targetBaseDir}'`));
+  }
+  if (existsSync(targetDir) && !options.force && !dryRun) {
+    return Result.err(new ScaffoldCommandError(`'${target.placement}/${targetName}/' already exists. Use --force to overwrite.`));
+  }
+  const plan = buildScaffoldPlan(target, rootDir, targetName, options);
+  const executeResult = await executePlan(plan, {
+    force: options.force,
+    ...collector ? { collector } : {}
+  });
+  if (executeResult.isErr()) {
+    return Result.err(new ScaffoldCommandError(executeResult.error.message));
+  }
+  const postScaffoldResult = await runPostScaffold({
+    rootDir,
+    projectDir: targetDir,
+    origin: "scaffold",
+    target: target.id,
+    structure: "workspace",
+    skipInstall: options.skipInstall,
+    skipGit: true,
+    skipCommit: true,
+    dryRun,
+    installTimeoutMs: options.installTimeout ?? 60000
+  }, collector);
+  if (postScaffoldResult.isErr()) {
+    return Result.err(new ScaffoldCommandError("Post-scaffold step failed"));
+  }
+  return Result.ok({
+    target: target.id,
+    rootDir,
+    targetDir,
+    converted,
+    movedExisting,
+    workspacePatternsUpdated,
+    blocksAdded: executeResult.value.blocksAdded,
+    postScaffold: postScaffoldResult.value,
+    ...collector ? { dryRunPlan: collector.toJSON() } : {}
+  });
+}
+function scaffoldCommand(program) {
+  program.command("scaffold <target> [name]").description("Add a capability to an existing project").option("-f, --force", "Overwrite existing files", false).option("--skip-install", "Skip bun install", false).option("--dry-run", "Preview changes without executing", false).option("--with <blocks>", "Comma-separated tooling blocks to add").option("--no-tooling", "Skip default tooling blocks").option("--local", "Use workspace:* for @outfitter dependencies").option("--install-timeout <ms>", "bun install timeout in ms").action(async (target, name, _flags, command) => {
+    const resolvedFlags = command.optsWithGlobals();
+    const mode = resolvedFlags.json ? "json" : undefined;
+    const outputOptions = mode ? { mode } : undefined;
+    const result = await runScaffold({
+      target,
+      name,
+      force: Boolean(resolvedFlags.force),
+      skipInstall: Boolean(resolvedFlags.skipInstall),
+      dryRun: Boolean(resolvedFlags.dryRun),
+      with: resolvedFlags.with,
+      noTooling: resolvedFlags.noTooling,
+      local: resolvedFlags.local,
+      cwd: process.cwd(),
+      ...resolvedFlags.installTimeout !== undefined ? { installTimeout: resolvedFlags.installTimeout } : {}
+    });
+    if (result.isErr()) {
+      exitWithError(result.error, outputOptions);
+      return;
+    }
+    await printScaffoldResults(result.value, outputOptions);
+  });
+}
+
+export { ScaffoldCommandError, runScaffold, scaffoldCommand };

package/dist/shared/{outfitter-mt7d1ek2.js → outfitter-6mpkh3zn.js}

@@ -1,43 +1,30 @@
 // @bun
 import {
-  runPostScaffold
-} from "./outfitter-4s9meh3j.js";
+  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-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";
+} from "./outfitter-g3hvjshg.js";
 import {
   deriveBinName,
   deriveProjectName,
-  isPathWithin,
-  resolveAuthor,
   resolvePackageName,
-  resolveYear,
   sanitizePackageName,
-  validatePackageName,
-  validateProjectDirectoryName
-} from "./outfitter-4q1zfmvc.js";
-import {
-  resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
+  validatePackageName
+} from "./outfitter-q1g58t85.js";
 
 // apps/outfitter/src/commands/init.ts
-import { existsSync } from "fs";
-import { realpath } from "fs/promises";
-import { basename, join, resolve } from "path";
+import { basename, resolve } from "path";
 import {
   cancel,
   confirm,
@@ -47,7 +34,7 @@ import {
   select,
   text
 } from "@clack/prompts";
-import { exitWithError, output } from "@outfitter/cli";
+import { exitWithError } from "@outfitter/cli";
 import { Result } from "@outfitter/contracts";
 class InitError extends Error {
   _tag = "InitError";
@@ -56,47 +43,13 @@ class InitError extends Error {
     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);
+  const presetFromFlagsResult = resolvePresetFromFlags(options.preset, INIT_TARGET_IDS);
   if (presetFromFlagsResult.isErr()) {
-    return presetFromFlagsResult;
+    return Result.err(new InitError(presetFromFlagsResult.error));
   }
   const presetFromFlags = presetFromFlagsResult.value;
   if (options.yes || !process.stdout.isTTY) {
@@ -261,41 +214,6 @@ async function resolveInitInput(options, presetOverride) {
     ...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()) {
@@ -306,202 +224,32 @@ async function runInit(options, presetOverride) {
   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, {
+  const executeResult = await executeInitPipeline(input, targetResult.value, {
+    dryRun: Boolean(options.dryRun),
     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}`);
+    installTimeout: options.installTimeout ?? 60000
+  });
+  if (executeResult.isErr()) {
+    return Result.err(new InitError(executeResult.error));
   }
-  await output(lines, { mode: "human" });
+  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) => {
@@ -510,20 +258,7 @@ function initCommand(program) {
     }
     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) => {
+  withCommonOptions(init.argument("[directory]")).action(async (directory, flags, command) => {
     const targetDir = directory ?? process.cwd();
     const resolvedFlags = resolveFlags(flags, command);
     const mode = resolveOutputMode(resolvedFlags);
@@ -533,7 +268,6 @@ function initCommand(program) {
       name: resolvedFlags.name,
       bin: resolvedFlags.bin,
       preset: resolvedFlags.preset,
-      template: resolvedFlags.template,
       structure: resolvedFlags.structure,
       workspaceName: resolvedFlags.workspaceName,
       local: resolveLocal(resolvedFlags),
@@ -695,4 +429,4 @@ function initCommand(program) {
   });
 }
 
-export { InitError, runInit, printInitResults, initCommand };
+export { InitError, runInit, initCommand };

package/dist/shared/{outfitter-ybbazsxq.d.ts → outfitter-6rtcemk7.d.ts}

@@ -1,14 +1,18 @@
-import { EngineOptions, PlaceholderValues, ScaffoldError } from "./outfitter-n9g1zk4x.js";
+import { EngineOptions, PlaceholderValues, ScaffoldError } from "./outfitter-cyvr4r8d.js";
 import { Result } from "@outfitter/contracts";
-declare function getTemplatesDir(): string;
+/**
+* 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 copyTemplateFiles(templateDir: string, targetDir: string, values: PlaceholderValues, options: EngineOptions, copyOptions?: {
+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 { getTemplatesDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyTemplateFiles };
+export { getPresetsBaseDir, getOutputFilename, isBinaryFile, replacePlaceholders, copyPresetFiles };