outfitter 0.2.7 → 0.3.3

package/dist/shared/outfitter-p2wn07b7.js

@@ -0,0 +1,160 @@
+// @bun
+import {
+  resolveStructuredOutputMode
+} from "./outfitter-7r12fj7f.js";
+
+// apps/outfitter/src/commands/check-action-ceremony.ts
+import { readdirSync } from "fs";
+import { resolve } from "path";
+import { Result } from "@outfitter/contracts";
+var ACTIONS_RELATIVE_DIR = "apps/outfitter/src/actions";
+var CEREMONY_BUDGETS = [
+  {
+    id: "direct-defineAction-generics",
+    description: "Direct defineAction<T> invocations should stay constrained (prefer export-level typing)",
+    maxCount: 1,
+    pattern: /(?<!typeof\s)defineAction</g
+  },
+  {
+    id: "schema-zodtype-casts",
+    description: "Action-local schema casts should not expand without justification",
+    maxCount: 6,
+    pattern: /as z\.ZodType</g
+  },
+  {
+    id: "direct-internalerror-construction",
+    description: "Direct InternalError creation in action handlers should stay minimal (use shared adapter)",
+    maxCount: 1,
+    pattern: /new InternalError\(/g
+  }
+];
+
+class CheckActionCeremonyError extends Error {
+  _tag = "CheckActionCeremonyError";
+  constructor(message) {
+    super(message);
+    this.name = "CheckActionCeremonyError";
+  }
+}
+function countMatches(content, pattern) {
+  const matches = content.match(pattern);
+  return matches ? matches.length : 0;
+}
+function readActionSources(actionsDir) {
+  return readdirSync(actionsDir).filter((entry) => entry.endsWith(".ts")).map((entry) => resolve(actionsDir, entry));
+}
+async function runCheckActionCeremony(options) {
+  try {
+    const cwd = resolve(options.cwd);
+    const actionsDir = resolve(cwd, ACTIONS_RELATIVE_DIR);
+    const actionFiles = readActionSources(actionsDir);
+    const counts = Object.fromEntries(CEREMONY_BUDGETS.map((budget) => [budget.id, 0]));
+    for (const filePath of actionFiles) {
+      const file = Bun.file(filePath);
+      const content = await file.text();
+      for (const budget of CEREMONY_BUDGETS) {
+        if (budget.id === "direct-internalerror-construction" && filePath.endsWith("shared.ts")) {
+          continue;
+        }
+        counts[budget.id] = (counts[budget.id] ?? 0) + countMatches(content, budget.pattern);
+      }
+    }
+    const budgets = CEREMONY_BUDGETS.map((budget) => {
+      const count = counts[budget.id] ?? 0;
+      return {
+        id: budget.id,
+        description: budget.description,
+        count,
+        maxCount: budget.maxCount,
+        ok: count <= budget.maxCount
+      };
+    });
+    return Result.ok({
+      actionsDir,
+      budgets,
+      ok: budgets.every((budget) => budget.ok)
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to check action ceremony";
+    return Result.err(new CheckActionCeremonyError(message));
+  }
+}
+async function printCheckActionCeremonyResult(result, options) {
+  const structuredMode = resolveStructuredOutputMode(options?.mode);
+  if (structuredMode) {
+    const serialized = structuredMode === "json" ? JSON.stringify(result, null, 2) : JSON.stringify(result);
+    process.stdout.write(`${serialized}
+`);
+    return;
+  }
+  process.stdout.write(`[action-ceremony] checked ${result.budgets.length} guardrails in ${result.actionsDir}
+`);
+  const failed = result.budgets.filter((budget) => !budget.ok);
+  if (failed.length === 0) {
+    process.stdout.write(`[action-ceremony] all ceremony guardrails are within budget
+`);
+    return;
+  }
+  process.stderr.write(`[action-ceremony] ceremony budget exceeded:
+`);
+  for (const budget of failed) {
+    process.stderr.write(`  - ${budget.id}: ${budget.count}/${budget.maxCount} (${budget.description})
+`);
+  }
+}
+function parseCliArgs(argv) {
+  let cwd = process.cwd();
+  let outputMode = "human";
+  for (let index = 0;index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--cwd") {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new CheckActionCeremonyError("Missing value for --cwd");
+      }
+      cwd = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      outputMode = "json";
+      continue;
+    }
+    if (arg === "--jsonl") {
+      outputMode = "jsonl";
+      continue;
+    }
+  }
+  return {
+    cwd: resolve(cwd),
+    outputMode
+  };
+}
+async function runCheckActionCeremonyFromArgv(argv) {
+  let parsed;
+  try {
+    parsed = parseCliArgs(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid command arguments";
+    process.stderr.write(`${message}
+`);
+    return 1;
+  }
+  const result = await runCheckActionCeremony({ cwd: parsed.cwd });
+  if (result.isErr()) {
+    process.stderr.write(`${result.error.message}
+`);
+    return 1;
+  }
+  await printCheckActionCeremonyResult(result.value, {
+    mode: parsed.outputMode
+  });
+  return result.value.ok ? 0 : 1;
+}
+if (import.meta.main) {
+  runCheckActionCeremonyFromArgv(process.argv.slice(2)).then((exitCode) => {
+    process.exit(exitCode);
+  });
+}
+
+export { CheckActionCeremonyError, runCheckActionCeremony, printCheckActionCeremonyResult, runCheckActionCeremonyFromArgv };

package/dist/shared/{outfitter-5y646xzk.js → outfitter-px5sv5gn.js}

@@ -1,14 +1,14 @@
 // @bun
-import {
-  getWorkspacePatterns,
-  hasWorkspacesField
-} from "./outfitter-1fy7byz5.js";
 import {
   validatePackageName
-} from "./outfitter-4q1zfmvc.js";
+} from "./outfitter-q1g58t85.js";
 import {
   resolveStructuredOutputMode
 } from "./outfitter-7r12fj7f.js";
+import {
+  getWorkspacePatterns,
+  hasWorkspacesField
+} from "./outfitter-1fy7byz5.js";
 
 // apps/outfitter/src/commands/doctor.ts
 import { existsSync, readFileSync } from "fs";
@@ -16,9 +16,29 @@ import { join, resolve } from "path";
 import { output } from "@outfitter/cli";
 import { createTheme } from "@outfitter/tui/render";
 var MIN_BUN_VERSION = "1.3.6";
-function checkBunVersion() {
-  const required = MIN_BUN_VERSION;
+function readPinnedBunVersion(projectRoot) {
+  const versionFile = join(projectRoot, ".bun-version");
+  if (!existsSync(versionFile)) {
+    return;
+  }
+  const pinned = readFileSync(versionFile, "utf-8").trim();
+  return pinned.length > 0 ? pinned : undefined;
+}
+function checkBunVersion(cwd, rootCwd) {
   const current = Bun.version;
+  const pinned = readPinnedBunVersion(rootCwd ?? cwd);
+  if (pinned) {
+    const passed2 = current === pinned;
+    return {
+      passed: passed2,
+      version: current,
+      required: pinned,
+      ...passed2 ? {} : {
+        error: `Bun version ${current} does not match pinned ${pinned}`
+      }
+    };
+  }
+  const required = MIN_BUN_VERSION;
   const passed = Bun.semver.satisfies(current, `>=${required}`);
   return {
     passed,
@@ -172,7 +192,7 @@ function discoverWorkspaceMemberPaths(cwd, packageJson) {
       }
     }
   }
-  return [...memberPaths].sort();
+  return [...memberPaths].toSorted();
 }
 function isWorkspaceRoot(packageJson) {
   return packageJson ? hasWorkspacesField(packageJson) : false;
@@ -180,7 +200,7 @@ function isWorkspaceRoot(packageJson) {
 function runDoctorForCwd(cwd, options) {
   const packageJsonRead = readPackageJson(cwd);
   const wsRoot = isWorkspaceRoot(packageJsonRead.parsed);
-  const bunVersion = checkBunVersion();
+  const bunVersion = checkBunVersion(cwd, options.rootCwd);
   const packageJson = checkPackageJson(packageJsonRead);
   const dependencies = checkDependencies(cwd, packageJsonRead, options.rootCwd);
   const configFiles = checkConfigFiles(cwd);

package/dist/shared/outfitter-q1g58t85.js

@@ -0,0 +1,8 @@
+export { addBlocks } from "./blocks.js";
+export { injectSharedConfig, rewriteLocalDependencies } from "./config.js";
+export { executePlan } from "./executor.js";
+export { deriveBinName, deriveProjectName, isPathWithin, resolveAuthor, resolvePackageName, resolveYear, sanitizePackageName, validatePackageName, validateProjectDirectoryName } from "./names.js";
+export { copyPresetFiles, getOutputFilename, getPresetsBaseDir, isBinaryFile, replacePlaceholders } from "./preset.js";
+export { copyTemplateFiles, getTemplatesDir } from "./template.js";
+export { ScaffoldError } from "./types.js";
+export { buildWorkspaceRootPackageJson, detectWorkspaceRoot, scaffoldWorkspaceRoot } from "./workspace.js";

package/dist/shared/{outfitter-pj9vp00r.js → outfitter-qsd5638j.js}

@@ -1,25 +1,6 @@
 // @bun
-import {
-  runPostScaffold
-} from "./outfitter-4s9meh3j.js";
-import {
-  getScaffoldTarget
-} from "./outfitter-xe5mzgdc.js";
-import {
-  OperationCollector
-} from "./outfitter-1h7k8xxt.js";
-import {
-  renderOperationPlan
-} from "./outfitter-ttjr95y9.js";
-import {
-  executePlan
-} from "./outfitter-5akzvppx.js";
 import {
   buildWorkspaceRootPackageJson,
-  detectWorkspaceRoot,
-  scaffoldWorkspaceRoot
-} from "./outfitter-1fy7byz5.js";
-import {
   deriveBinName,
   deriveProjectName,
   isPathWithin,
@@ -28,12 +9,12 @@ import {
   sanitizePackageName,
   validatePackageName,
   validateProjectDirectoryName
-} from "./outfitter-4q1zfmvc.js";
+} from "./outfitter-q1g58t85.js";
 import {
-  resolveStructuredOutputMode
-} from "./outfitter-7r12fj7f.js";
+  detectWorkspaceRoot
+} from "./outfitter-1fy7byz5.js";
 
-// apps/outfitter/src/commands/scaffold.ts
+// apps/outfitter/src/commands/scaffold-planning.ts
 import {
   cpSync,
   existsSync,
@@ -46,15 +27,7 @@ import {
   writeFileSync
 } from "fs";
 import { basename, dirname, join, resolve } from "path";
-import { exitWithError, output } from "@outfitter/cli";
 import { Result } from "@outfitter/contracts";
-class ScaffoldCommandError extends Error {
-  _tag = "ScaffoldCommandError";
-  constructor(message) {
-    super(message);
-    this.name = "ScaffoldCommandError";
-  }
-}
 function readPackageJson(path) {
   if (!existsSync(path)) {
     return null;
@@ -103,7 +76,7 @@ function detectProjectStructure(cwd) {
     }
     const wsResult2 = detectWorkspaceRoot(resolvedCwd);
     if (wsResult2.isErr()) {
-      return Result.err(new ScaffoldCommandError(wsResult2.error.message));
+      return Result.err(wsResult2.error.message);
     }
     if (wsResult2.value) {
       const rootPkg = readPackageJson(join(wsResult2.value, "package.json"));
@@ -123,7 +96,7 @@ function detectProjectStructure(cwd) {
   }
   const wsResult = detectWorkspaceRoot(resolvedCwd);
   if (wsResult.isErr()) {
-    return Result.err(new ScaffoldCommandError(wsResult.error.message));
+    return Result.err(wsResult.error.message);
   }
   if (wsResult.value) {
     const rootPkg = readPackageJson(join(wsResult.value, "package.json"));
@@ -138,7 +111,7 @@ function detectProjectStructure(cwd) {
   return Result.ok({ kind: "none", rootDir: resolvedCwd });
 }
 function detectExistingCategory(pkg) {
-  const metadata = readTemplateMetadata(pkg);
+  const metadata = readPresetMetadata(pkg);
   if (metadata?.kind) {
     return metadata.kind;
   }
@@ -160,15 +133,15 @@ function detectExistingCategory(pkg) {
     }
   }
   const deps = {
-    ...pkg.dependencies ?? {},
-    ...pkg.devDependencies ?? {}
+    ...pkg.dependencies,
+    ...pkg.devDependencies
   };
   if (deps["@modelcontextprotocol/sdk"] || deps["@outfitter/mcp"]) {
     return "runnable";
   }
   return "library";
 }
-function readTemplateMetadata(pkg) {
+function readPresetMetadata(pkg) {
   const outfitter = pkg.outfitter;
   if (!outfitter || typeof outfitter !== "object" || Array.isArray(outfitter)) {
     return null;
@@ -180,7 +153,7 @@ function readTemplateMetadata(pkg) {
   const templateRecord = template;
   const kind = templateRecord["kind"] === "runnable" || templateRecord["kind"] === "library" ? templateRecord["kind"] : undefined;
   const placement = templateRecord["placement"] === "apps" || templateRecord["placement"] === "packages" ? templateRecord["placement"] : undefined;
-  const surfaces = parseTemplateSurfaces(templateRecord["surfaces"]);
+  const surfaces = parsePresetSurfaces(templateRecord["surfaces"]);
   const hasMetadata = kind !== undefined || placement !== undefined || surfaces !== undefined && surfaces.length > 0;
   if (!hasMetadata) {
     return null;
@@ -191,7 +164,7 @@ function readTemplateMetadata(pkg) {
     ...surfaces ? { surfaces } : {}
   };
 }
-function parseTemplateSurfaces(value) {
+function parsePresetSurfaces(value) {
   if (!Array.isArray(value)) {
     return;
   }
@@ -210,7 +183,7 @@ function ensureWorkspacePattern(rootDir, placement, dryRun, collector) {
       });
       return Result.ok(true);
     }
-    return Result.err(new ScaffoldCommandError("Failed to read workspace package.json"));
+    return Result.err("Failed to read workspace package.json");
   }
   const pattern = `${placement}/*`;
   const patterns = [...extractWorkspacePatterns(pkg)];
@@ -257,22 +230,22 @@ function movePath(source, destination) {
 function convertToWorkspace(rootDir, existingPkg, dryRun, collector) {
   const parentWorkspace = detectWorkspaceRoot(dirname(rootDir));
   if (parentWorkspace.isErr()) {
-    return Result.err(new ScaffoldCommandError(parentWorkspace.error.message));
+    return Result.err(parentWorkspace.error.message);
   }
   if (parentWorkspace.value && parentWorkspace.value !== rootDir) {
-    return Result.err(new ScaffoldCommandError(`Cannot convert to workspace: already inside workspace at '${parentWorkspace.value}'`));
+    return Result.err(`Cannot convert to workspace: already inside workspace at '${parentWorkspace.value}'`);
   }
   const category = detectExistingCategory(existingPkg);
   const placement = category === "runnable" ? "apps" : "packages";
   const existingName = deriveProjectName(existingPkg.name ?? basename(rootDir));
   const invalidExistingName = validateProjectDirectoryName(existingName);
   if (invalidExistingName) {
-    return Result.err(new ScaffoldCommandError(`Invalid existing project name '${existingName}': ${invalidExistingName}`));
+    return Result.err(`Invalid existing project name '${existingName}': ${invalidExistingName}`);
   }
   const destinationBaseDir = resolve(rootDir, placement);
   const destinationDir = resolve(destinationBaseDir, existingName);
   if (!isPathWithin(destinationBaseDir, destinationDir)) {
-    return Result.err(new ScaffoldCommandError(`Invalid existing project name '${existingName}': path escapes '${destinationBaseDir}'`));
+    return Result.err(`Invalid existing project name '${existingName}': path escapes '${destinationBaseDir}'`);
   }
   const entries = readdirSync(rootDir);
   const preserve = new Set([".git", "node_modules", ".outfitter", "bun.lock"]);
@@ -341,7 +314,7 @@ function convertToWorkspace(rootDir, existingPkg, dryRun, collector) {
         rmSync(stagingDir, { recursive: true, force: true });
       }
     } catch {}
-    return Result.err(new ScaffoldCommandError(`Workspace conversion failed: ${error instanceof Error ? error.message : "Unknown error"}`));
+    return Result.err(`Workspace conversion failed: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
   return Result.ok({
     movedExisting: {
@@ -376,9 +349,10 @@ function buildScaffoldPlan(target, rootDir, targetName, options) {
     },
     changes: [
       {
-        type: "copy-template",
-        template: target.templateDir,
+        type: "copy-preset",
+        preset: target.presetDir,
         targetDir,
+        includeTooling: !options.noTooling,
         overlayBaseTemplate: true
       },
       { type: "inject-shared-config" },
@@ -387,215 +361,18 @@ function buildScaffoldPlan(target, rootDir, targetName, options) {
     ]
   };
 }
-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);
+function validateScaffoldTargetName(targetName) {
   const invalidTargetName = validateProjectDirectoryName(targetName);
   if (invalidTargetName) {
-    return Result.err(new ScaffoldCommandError(`Invalid target name '${targetName}': ${invalidTargetName}`));
+    return Result.err(`Invalid target name '${targetName}': ${invalidTargetName}`);
   }
   const invalidPackageName = validatePackageName(targetName);
   if (invalidPackageName) {
     const suggested = sanitizePackageName(targetName);
     const suggestion = suggested.length > 0 && suggested !== targetName ? ` Try '${suggested}'.` : "";
-    return Result.err(new ScaffoldCommandError(`Invalid package name '${targetName}': ${invalidPackageName}.${suggestion}`));
-  }
-  const structureResult = detectProjectStructure(options.cwd);
-  if (structureResult.isErr()) {
-    return structureResult;
-  }
-  const dryRun = options.dryRun;
-  const collector = dryRun ? new OperationCollector : undefined;
-  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 patternResult;
-    }
-    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 conversionResult;
-    }
-    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.`));
+    return Result.err(`Invalid package name '${targetName}': ${invalidPackageName}.${suggestion}`);
   }
-  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() } : {}
-  });
-}
-async function printScaffoldResults(result, options) {
-  const structuredMode = resolveStructuredOutputMode(options?.mode);
-  if (result.dryRunPlan) {
-    if (structuredMode) {
-      await output({
-        target: result.target,
-        rootDir: result.rootDir,
-        targetDir: result.targetDir,
-        converted: result.converted,
-        movedExisting: result.movedExisting ?? null,
-        ...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({
-      target: result.target,
-      rootDir: result.rootDir,
-      targetDir: result.targetDir,
-      converted: result.converted,
-      movedExisting: result.movedExisting ?? null,
-      workspacePatternsUpdated: result.workspacePatternsUpdated,
-      blocksAdded: result.blocksAdded ?? null,
-      postScaffold: result.postScaffold,
-      nextSteps: result.postScaffold.nextSteps
-    }, { mode: structuredMode });
-    return;
-  }
-  const lines = [];
-  if (result.converted) {
-    lines.push("Converted to workspace structure:");
-    if (result.movedExisting) {
-      lines.push(`  Moved existing package -> ${result.movedExisting.to}`);
-    }
-    lines.push("  Created workspace root package.json");
-    lines.push("");
-  }
-  lines.push(`Scaffolded ${result.targetDir}`);
-  if (result.blocksAdded && result.blocksAdded.created.length > 0) {
-    lines.push(`Added ${result.blocksAdded.created.length} tooling file(s):`);
-    for (const created of result.blocksAdded.created) {
-      lines.push(`  + ${created}`);
-    }
-  }
-  lines.push("", "Next steps:");
-  for (const step of result.postScaffold.nextSteps) {
-    lines.push(`  ${step}`);
-  }
-  await output(lines, { mode: "human" });
-}
-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);
-  });
+  return Result.ok(undefined);
 }
 
-export { ScaffoldCommandError, runScaffold, printScaffoldResults, scaffoldCommand };
+export { detectProjectStructure, ensureWorkspacePattern, convertToWorkspace, buildScaffoldPlan, validateScaffoldTargetName };