outfitter 0.1.0-rc.2 → 0.1.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import {
   outfitterActions
-} from "./shared/chunk-1rebv144.js";
+} from "./shared/chunk-429agb93.js";
 
 // src/cli.ts
 import { buildCliCommands } from "@outfitter/cli/actions";

package/dist/index.d.ts

@@ -128,6 +128,7 @@ declare function printDoctorResults(result: DoctorResult): void;
 */
 declare function doctorCommand(program: Command): void;
 import { Result } from "@outfitter/contracts";
+import { AddBlockResult } from "@outfitter/tooling";
 import { Command as Command2 } from "commander";
 /**
 * Options for the init command.
@@ -138,13 +139,24 @@ interface InitOptions {
 	/** Package name (defaults to directory name if not provided) */
 	readonly name: string | undefined;
 	/** Binary name (defaults to project name if not provided) */
-	readonly bin?: string;
+	readonly bin?: string | undefined;
 	/** Template to use (defaults to 'basic') */
 	readonly template: string | undefined;
 	/** Whether to use local/workspace dependencies */
-	readonly local?: boolean;
+	readonly local?: boolean | undefined;
 	/** Whether to overwrite existing files */
 	readonly force: boolean;
+	/** Tooling blocks to add (e.g., "scaffolding" or "claude,biome,lefthook") */
+	readonly with?: string | undefined;
+	/** Skip tooling prompt in interactive mode */
+	readonly noTooling?: boolean | undefined;
+}
+/**
+* Result of running init, including any blocks added.
+*/
+interface InitResult {
+	/** The blocks that were added, if any */
+	readonly blocksAdded?: AddBlockResult | undefined;
 }
 /**
 * Error returned when initialization fails.
@@ -166,16 +178,20 @@ declare class InitError extends Error {
 *   name: "my-project",
 *   template: "basic",
 *   force: false,
+*   blocks: "scaffolding", // Optional: add tooling blocks
 * });
 *
 * if (result.isOk()) {
 *   console.log("Project initialized successfully!");
+*   if (result.value.blocksAdded) {
+*     console.log(`Added ${result.value.blocksAdded.created.length} tooling files`);
+*   }
 * } else {
 *   console.error("Failed:", result.error.message);
 * }
 * ```
 */
-declare function runInit(options: InitOptions): Promise<Result<void, InitError>>;
+declare function runInit(options: InitOptions): Promise<Result<InitResult, InitError>>;
 /**
 * Registers the init command with the CLI program.
 *

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   printDoctorResults,
   runDoctor,
   runInit
-} from "./shared/chunk-1rebv144.js";
+} from "./shared/chunk-429agb93.js";
 export {
   runInit,
   runDoctor,

package/dist/shared/{chunk-1rebv144.js → chunk-429agb93.js}

@@ -186,21 +186,249 @@ function doctorCommand(program) {
 
 // src/commands/init.ts
 import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync3,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { basename, dirname as dirname2, extname, join as join3, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { Result as Result2 } from "@outfitter/contracts";
+
+// src/commands/add.ts
+import {
+  chmodSync,
   existsSync as existsSync2,
   mkdirSync,
-  readdirSync,
   readFileSync as readFileSync2,
-  statSync,
   writeFileSync
 } from "node:fs";
-import { basename, dirname, extname, join as join2, resolve as resolve2 } from "node:path";
+import { dirname, join as join2, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { confirm, isCancel, select, text } from "@clack/prompts";
 import { Result } from "@outfitter/contracts";
+import { RegistrySchema } from "@outfitter/tooling";
+
+class AddError extends Error {
+  _tag = "AddError";
+  constructor(message) {
+    super(message);
+    this.name = "AddError";
+  }
+}
+function getRegistryPath() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0;i < 10; i++) {
+    const registryPath = join2(currentDir, "node_modules/@outfitter/tooling/registry/registry.json");
+    if (existsSync2(registryPath)) {
+      return registryPath;
+    }
+    const monoRepoPath = join2(currentDir, "packages/tooling/registry/registry.json");
+    if (existsSync2(monoRepoPath)) {
+      return monoRepoPath;
+    }
+    currentDir = dirname(currentDir);
+  }
+  throw new AddError("Could not find registry.json. Ensure @outfitter/tooling is installed.");
+}
+function loadRegistry() {
+  try {
+    const registryPath = getRegistryPath();
+    const content = readFileSync2(registryPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const registry = RegistrySchema.parse(parsed);
+    return Result.ok(registry);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return Result.err(new AddError(`Failed to load registry: ${message}`));
+  }
+}
+function resolveBlock(registry, blockName, visited = new Set) {
+  if (visited.has(blockName)) {
+    return Result.err(new AddError(`Circular dependency detected for block: ${blockName}`));
+  }
+  visited.add(blockName);
+  const block = registry.blocks[blockName];
+  if (!block) {
+    const available = Object.keys(registry.blocks).join(", ");
+    return Result.err(new AddError(`Block '${blockName}' not found. Available blocks: ${available}`));
+  }
+  if (block.extends && block.extends.length > 0) {
+    const mergedFiles = [];
+    const mergedDeps = {};
+    const mergedDevDeps = {};
+    for (const extendedName of block.extends) {
+      const extendedResult = resolveBlock(registry, extendedName, visited);
+      if (extendedResult.isErr()) {
+        return extendedResult;
+      }
+      const extended = extendedResult.value;
+      if (extended.files) {
+        mergedFiles.push(...extended.files);
+      }
+      if (extended.dependencies) {
+        Object.assign(mergedDeps, extended.dependencies);
+      }
+      if (extended.devDependencies) {
+        Object.assign(mergedDevDeps, extended.devDependencies);
+      }
+    }
+    if (block.files) {
+      mergedFiles.push(...block.files);
+    }
+    if (block.dependencies) {
+      Object.assign(mergedDeps, block.dependencies);
+    }
+    if (block.devDependencies) {
+      Object.assign(mergedDevDeps, block.devDependencies);
+    }
+    return Result.ok({
+      name: block.name,
+      description: block.description,
+      files: mergedFiles.length > 0 ? mergedFiles : undefined,
+      dependencies: Object.keys(mergedDeps).length > 0 ? mergedDeps : undefined,
+      devDependencies: Object.keys(mergedDevDeps).length > 0 ? mergedDevDeps : undefined
+    });
+  }
+  return Result.ok(block);
+}
+function writeFile(filePath, content, executable) {
+  const dir = dirname(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+  if (executable) {
+    chmodSync(filePath, 493);
+  }
+}
+function updatePackageJson(cwd, dependencies, devDependencies, dryRun) {
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    return { dependencies, devDependencies };
+  }
+  const content = readFileSync2(packageJsonPath, "utf-8");
+  const pkg = JSON.parse(content);
+  const existingDeps = pkg["dependencies"] ?? {};
+  const existingDevDeps = pkg["devDependencies"] ?? {};
+  const addedDeps = {};
+  const addedDevDeps = {};
+  for (const [name, version] of Object.entries(dependencies)) {
+    if (!existingDeps[name]) {
+      existingDeps[name] = version;
+      addedDeps[name] = version;
+    }
+  }
+  for (const [name, version] of Object.entries(devDependencies)) {
+    if (!(existingDevDeps[name] || existingDeps[name])) {
+      existingDevDeps[name] = version;
+      addedDevDeps[name] = version;
+    }
+  }
+  if (!dryRun && (Object.keys(addedDeps).length > 0 || Object.keys(addedDevDeps).length > 0)) {
+    if (Object.keys(existingDeps).length > 0) {
+      pkg["dependencies"] = existingDeps;
+    }
+    if (Object.keys(existingDevDeps).length > 0) {
+      pkg["devDependencies"] = existingDevDeps;
+    }
+    writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+  return { dependencies: addedDeps, devDependencies: addedDevDeps };
+}
+async function runAdd(input) {
+  const { block: blockName, force, dryRun, cwd = process.cwd() } = input;
+  const resolvedCwd = resolve2(cwd);
+  const registryResult = loadRegistry();
+  if (registryResult.isErr()) {
+    return registryResult;
+  }
+  const registry = registryResult.value;
+  const blockResult = resolveBlock(registry, blockName);
+  if (blockResult.isErr()) {
+    return blockResult;
+  }
+  const block = blockResult.value;
+  const created = [];
+  const skipped = [];
+  const overwritten = [];
+  if (block.files) {
+    for (const file of block.files) {
+      const targetPath = join2(resolvedCwd, file.path);
+      const fileExists = existsSync2(targetPath);
+      if (fileExists && !force) {
+        skipped.push(file.path);
+        continue;
+      }
+      if (!dryRun) {
+        writeFile(targetPath, file.content, file.executable ?? false);
+      }
+      if (fileExists) {
+        overwritten.push(file.path);
+      } else {
+        created.push(file.path);
+      }
+    }
+  }
+  const { dependencies, devDependencies } = updatePackageJson(resolvedCwd, block.dependencies ?? {}, block.devDependencies ?? {}, dryRun);
+  return Result.ok({
+    created,
+    skipped,
+    overwritten,
+    dependencies,
+    devDependencies
+  });
+}
+function printAddResults(result, dryRun) {
+  const prefix = dryRun ? "[dry-run] Would " : "";
+  if (result.created.length > 0) {
+    console.log(`${prefix}create ${result.created.length} file(s):`);
+    for (const file of result.created) {
+      console.log(`  ✓ ${file}`);
+    }
+  }
+  if (result.overwritten.length > 0) {
+    console.log(`${prefix}overwrite ${result.overwritten.length} file(s):`);
+    for (const file of result.overwritten) {
+      console.log(`  ✓ ${file}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log(`Skipped ${result.skipped.length} existing file(s):`);
+    for (const file of result.skipped) {
+      console.log(`  - ${file} (use --force to overwrite)`);
+    }
+  }
+  const depCount = Object.keys(result.dependencies).length + Object.keys(result.devDependencies).length;
+  if (depCount > 0) {
+    console.log(`
+${prefix}add ${depCount} package(s) to package.json:`);
+    for (const [name, version] of Object.entries(result.dependencies)) {
+      console.log(`  + ${name}@${version}`);
+    }
+    for (const [name, version] of Object.entries(result.devDependencies)) {
+      console.log(`  + ${name}@${version} (dev)`);
+    }
+    if (!dryRun) {
+      console.log("\nRun `bun install` to install new dependencies.");
+    }
+  }
+}
+function listBlocks() {
+  const registryResult = loadRegistry();
+  if (registryResult.isErr()) {
+    return registryResult;
+  }
+  const blocks = Object.keys(registryResult.value.blocks);
+  return Result.ok(blocks);
+}
 
 // src/commands/shared-deps.ts
 var SHARED_DEV_DEPS = {
   "@biomejs/biome": "^2.3.11",
+  "@outfitter/tooling": "^0.1.0-rc.1",
   "@types/bun": "latest",
   lefthook: "^2.0.15",
   typescript: "^5.9.3",
@@ -264,23 +492,23 @@ function isBinaryFile(filename) {
   return BINARY_EXTENSIONS.has(ext);
 }
 function getTemplatesDir() {
-  let currentDir = dirname(fileURLToPath(import.meta.url));
+  let currentDir = dirname2(fileURLToPath2(import.meta.url));
   for (let i = 0;i < 10; i++) {
-    const templatesPath = join2(currentDir, "templates");
-    if (existsSync2(templatesPath)) {
+    const templatesPath = join3(currentDir, "templates");
+    if (existsSync3(templatesPath)) {
       return templatesPath;
     }
-    currentDir = dirname(currentDir);
+    currentDir = dirname2(currentDir);
   }
-  return join2(process.cwd(), "templates");
+  return join3(process.cwd(), "templates");
 }
 function validateTemplate(templateName) {
   const templatesDir = getTemplatesDir();
-  const templatePath = join2(templatesDir, templateName);
-  if (!existsSync2(templatePath)) {
-    return Result.err(new InitError(`Template '${templateName}' not found. Available templates are in: ${templatesDir}`));
+  const templatePath = join3(templatesDir, templateName);
+  if (!existsSync3(templatePath)) {
+    return Result2.err(new InitError(`Template '${templateName}' not found. Available templates are in: ${templatesDir}`));
   }
-  return Result.ok(templatePath);
+  return Result2.ok(templatePath);
 }
 function replacePlaceholders(content, values) {
   return content.replace(/\{\{(\w+)\}\}/g, (match, key) => {
@@ -296,44 +524,8 @@ function getOutputFilename(templateFilename) {
   }
   return templateFilename;
 }
-function isInteractive() {
-  return process.stdout.isTTY === true && process.env["TERM"] !== "dumb";
-}
-function readPackageInfo(targetDir) {
-  const packageJsonPath = join2(targetDir, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return {};
-  }
-  try {
-    const content = readFileSync2(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const name = parsed["name"];
-    const resolvedName = typeof name === "string" && name.length > 0 ? name : undefined;
-    const bin = parsed["bin"];
-    let resolvedBin;
-    if (typeof bin === "string") {
-      resolvedBin = bin.length > 0 ? bin : undefined;
-    } else if (typeof bin === "object" && bin !== null) {
-      const entries = Object.entries(bin).filter(([, value]) => typeof value === "string");
-      const keys = entries.map(([key]) => key);
-      if (keys.length > 0) {
-        const derived = resolvedName ? deriveBinName(resolvedName) : undefined;
-        if (derived && keys.includes(derived)) {
-          resolvedBin = derived;
-        } else if (resolvedName && keys.includes(resolvedName)) {
-          resolvedBin = resolvedName;
-        } else {
-          resolvedBin = keys[0];
-        }
-      }
-    }
-    return {
-      ...resolvedName ? { name: resolvedName } : {},
-      ...resolvedBin ? { bin: resolvedBin } : {}
-    };
-  } catch {
-    return {};
-  }
+function hasPackageJson(targetDir) {
+  return existsSync3(join3(targetDir, "package.json"));
 }
 function deriveProjectName(packageName) {
   if (packageName.startsWith("@")) {
@@ -344,95 +536,14 @@ function deriveProjectName(packageName) {
   }
   return packageName;
 }
-function deriveBinName(projectName) {
-  if (projectName.startsWith("@")) {
-    const parts = projectName.split("/");
-    if (parts.length > 1 && parts[1]) {
-      return parts[1];
-    }
-  }
-  return projectName;
+function resolvePackageName(options, resolvedTargetDir) {
+  return options.name ?? basename(resolvedTargetDir);
 }
-async function resolvePackageName(options, resolvedTargetDir, packageInfo) {
-  if (options.name) {
-    return Result.ok(options.name);
-  }
-  const detectedName = packageInfo.name;
-  const fallbackName = basename(resolvedTargetDir);
-  if (!isInteractive()) {
-    return Result.ok(detectedName ?? fallbackName);
-  }
-  const suggested = detectedName ?? fallbackName;
-  const custom = await text({
-    message: "Package name",
-    placeholder: suggested
-  });
-  if (isCancel(custom)) {
-    return Result.err(new InitError("Initialization cancelled."));
-  }
-  const trimmed = String(custom).trim();
-  return Result.ok(trimmed.length > 0 ? trimmed : suggested);
-}
-async function resolveBinName(options, projectName, packageInfo) {
-  if (options.bin) {
-    return Result.ok(options.bin);
-  }
-  const derived = deriveBinName(projectName);
-  const detected = packageInfo.bin;
-  if (!isInteractive()) {
-    return Result.ok(detected ?? derived);
-  }
-  if (detected) {
-    const useDetected = await confirm({
-      message: `Detected package binary name "${detected}". Use this as the binary name?`
-    });
-    if (isCancel(useDetected)) {
-      return Result.err(new InitError("Initialization cancelled."));
-    }
-    if (useDetected) {
-      return Result.ok(detected);
-    }
-  }
-  const useDerived = await confirm({
-    message: `Use "${derived}" as the binary name?`
-  });
-  if (isCancel(useDerived)) {
-    return Result.err(new InitError("Initialization cancelled."));
-  }
-  if (useDerived) {
-    return Result.ok(derived);
-  }
-  const custom = await text({
-    message: "Binary name",
-    placeholder: derived
-  });
-  if (isCancel(custom)) {
-    return Result.err(new InitError("Initialization cancelled."));
-  }
-  const trimmed = String(custom).trim();
-  return Result.ok(trimmed.length > 0 ? trimmed : derived);
+function resolveBinName(options, projectName) {
+  return options.bin ?? deriveProjectName(projectName);
 }
-async function resolveTemplateName(options) {
-  if (options.template) {
-    return Result.ok(options.template);
-  }
-  if (!isInteractive()) {
-    return Result.ok("basic");
-  }
-  const selection = await select({
-    message: "Select a template",
-    options: [
-      { value: "basic", label: "basic", hint: "Minimal starter" },
-      { value: "cli", label: "cli", hint: "CLI application" },
-      { value: "mcp", label: "mcp", hint: "MCP server" },
-      { value: "daemon", label: "daemon", hint: "Daemon + CLI" }
-    ]
-  });
-  if (isCancel(selection)) {
-    return Result.err(new InitError("Initialization cancelled."));
-  }
-  const value = String(selection).trim();
-  return Result.ok(value.length > 0 ? value : "basic");
+function resolveTemplateName(options) {
+  return options.template ?? "basic";
 }
 function resolveAuthor() {
   const fromEnv = process.env["GIT_AUTHOR_NAME"] ?? process.env["GIT_COMMITTER_NAME"] ?? process.env["AUTHOR"] ?? process.env["USER"] ?? process.env["USERNAME"];
@@ -454,41 +565,51 @@ function resolveAuthor() {
 function resolveYear() {
   return String(new Date().getFullYear());
 }
+function resolveBlocks(options) {
+  if (options.noTooling) {
+    return;
+  }
+  if (options.with) {
+    const blocks = options.with.split(",").map((b) => b.trim()).filter(Boolean);
+    return blocks.length > 0 ? blocks : undefined;
+  }
+  return ["scaffolding"];
+}
 function copyTemplateFiles(templateDir, targetDir, values, force, allowOverwrite = false) {
   try {
-    if (!existsSync2(targetDir)) {
-      mkdirSync(targetDir, { recursive: true });
+    if (!existsSync3(targetDir)) {
+      mkdirSync2(targetDir, { recursive: true });
     }
     const entries = readdirSync(templateDir);
     for (const entry of entries) {
-      const sourcePath = join2(templateDir, entry);
+      const sourcePath = join3(templateDir, entry);
       const stat = statSync(sourcePath);
       if (stat.isDirectory()) {
-        const targetSubDir = join2(targetDir, entry);
+        const targetSubDir = join3(targetDir, entry);
         const result = copyTemplateFiles(sourcePath, targetSubDir, values, force, allowOverwrite);
         if (result.isErr()) {
           return result;
         }
       } else if (stat.isFile()) {
         const outputFilename = getOutputFilename(entry);
-        const targetPath = join2(targetDir, outputFilename);
-        if (existsSync2(targetPath) && !force && !allowOverwrite) {
-          return Result.err(new InitError(`File '${targetPath}' already exists. Use --force to overwrite.`));
+        const targetPath = join3(targetDir, outputFilename);
+        if (existsSync3(targetPath) && !force && !allowOverwrite) {
+          return Result2.err(new InitError(`File '${targetPath}' already exists. Use --force to overwrite.`));
         }
         if (isBinaryFile(outputFilename)) {
-          const buffer = readFileSync2(sourcePath);
-          writeFileSync(targetPath, buffer);
+          const buffer = readFileSync3(sourcePath);
+          writeFileSync2(targetPath, buffer);
         } else {
-          const content = readFileSync2(sourcePath, "utf-8");
+          const content = readFileSync3(sourcePath, "utf-8");
           const processedContent = replacePlaceholders(content, values);
-          writeFileSync(targetPath, processedContent, "utf-8");
+          writeFileSync2(targetPath, processedContent, "utf-8");
         }
       }
     }
-    return Result.ok(undefined);
+    return Result2.ok(undefined);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    return Result.err(new InitError(`Failed to copy template files: ${message}`));
+    return Result2.err(new InitError(`Failed to copy template files: ${message}`));
   }
 }
 var DEPENDENCY_SECTIONS = [
@@ -498,12 +619,12 @@ var DEPENDENCY_SECTIONS = [
   "optionalDependencies"
 ];
 function rewriteLocalDependencies(targetDir) {
-  const packageJsonPath = join2(targetDir, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return Result.ok(undefined);
+  const packageJsonPath = join3(targetDir, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return Result2.ok(undefined);
   }
   try {
-    const content = readFileSync2(packageJsonPath, "utf-8");
+    const content = readFileSync3(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     let updated = false;
     for (const section of DEPENDENCY_SECTIONS) {
@@ -520,60 +641,50 @@ function rewriteLocalDependencies(targetDir) {
       }
     }
     if (updated) {
-      writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+      writeFileSync2(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
     }
-    return Result.ok(undefined);
+    return Result2.ok(undefined);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    return Result.err(new InitError(`Failed to update local dependencies: ${message}`));
+    return Result2.err(new InitError(`Failed to update local dependencies: ${message}`));
   }
 }
 function injectSharedConfig(targetDir) {
-  const packageJsonPath = join2(targetDir, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return Result.ok(undefined);
+  const packageJsonPath = join3(targetDir, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return Result2.ok(undefined);
   }
   try {
-    const content = readFileSync2(packageJsonPath, "utf-8");
+    const content = readFileSync3(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     const existingDevDeps = parsed["devDependencies"] ?? {};
     parsed["devDependencies"] = { ...SHARED_DEV_DEPS, ...existingDevDeps };
     const existingScripts = parsed["scripts"] ?? {};
     parsed["scripts"] = { ...SHARED_SCRIPTS, ...existingScripts };
-    writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
+    writeFileSync2(packageJsonPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf-8");
-    return Result.ok(undefined);
+    return Result2.ok(undefined);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    return Result.err(new InitError(`Failed to inject shared config: ${message}`));
+    return Result2.err(new InitError(`Failed to inject shared config: ${message}`));
   }
 }
 async function runInit(options) {
   const { targetDir, force } = options;
-  const resolvedTargetDir = resolve2(targetDir);
-  const templateNameResult = await resolveTemplateName(options);
-  if (templateNameResult.isErr()) {
-    return templateNameResult;
+  const resolvedTargetDir = resolve3(targetDir);
+  if (hasPackageJson(resolvedTargetDir) && !force) {
+    return Result2.err(new InitError(`Directory '${resolvedTargetDir}' already has a package.json. ` + `Use --force to overwrite, or use 'outfitter add' to add tooling to an existing project.`));
   }
-  const templateName = templateNameResult.value;
+  const templateName = resolveTemplateName(options);
   const templateResult = validateTemplate(templateName);
   if (templateResult.isErr()) {
     return templateResult;
   }
   const templatePath = templateResult.value;
-  const packageInfo = readPackageInfo(resolvedTargetDir);
-  const packageNameResult = await resolvePackageName(options, resolvedTargetDir, packageInfo);
-  if (packageNameResult.isErr()) {
-    return packageNameResult;
-  }
-  const packageName = packageNameResult.value;
+  const packageName = resolvePackageName(options, resolvedTargetDir);
   const projectName = deriveProjectName(packageName);
-  const binNameResult = await resolveBinName(options, projectName, packageInfo);
-  if (binNameResult.isErr()) {
-    return binNameResult;
-  }
-  const binName = binNameResult.value;
+  const binName = resolveBinName(options, projectName);
   const author = resolveAuthor();
   const year = resolveYear();
   const values = {
@@ -586,33 +697,17 @@ async function runInit(options) {
     author,
     year
   };
-  if (existsSync2(resolvedTargetDir) && !force) {
-    try {
-      const entries = readdirSync(resolvedTargetDir);
-      const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".gitignore");
-      if (significantEntries.length > 0) {
-        for (const entry of significantEntries) {
-          const templateEntry = `${entry}.template`;
-          const templateFilePath = join2(templatePath, templateEntry);
-          const plainFilePath = join2(templatePath, entry);
-          if (existsSync2(templateFilePath) || existsSync2(plainFilePath)) {
-            return Result.err(new InitError(`Directory '${resolvedTargetDir}' already exists with files that would be overwritten. Use --force to overwrite.`));
-          }
-        }
-      }
-    } catch {}
-  }
   try {
-    if (!existsSync2(resolvedTargetDir)) {
-      mkdirSync(resolvedTargetDir, { recursive: true });
+    if (!existsSync3(resolvedTargetDir)) {
+      mkdirSync2(resolvedTargetDir, { recursive: true });
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
-    return Result.err(new InitError(`Failed to create target directory: ${message}`));
+    return Result2.err(new InitError(`Failed to create target directory: ${message}`));
   }
   const templatesDir = getTemplatesDir();
-  const basePath = join2(templatesDir, "_base");
-  if (existsSync2(basePath)) {
+  const basePath = join3(templatesDir, "_base");
+  if (existsSync3(basePath)) {
     const baseResult = copyTemplateFiles(basePath, resolvedTargetDir, values, force);
     if (baseResult.isErr()) {
       return baseResult;
@@ -632,7 +727,36 @@ async function runInit(options) {
       return rewriteResult;
     }
   }
-  return Result.ok(undefined);
+  const blocks = resolveBlocks(options);
+  let blocksAdded;
+  if (blocks && blocks.length > 0) {
+    const mergedResult = {
+      created: [],
+      skipped: [],
+      overwritten: [],
+      dependencies: {},
+      devDependencies: {}
+    };
+    for (const blockName of blocks) {
+      const addResult = await runAdd({
+        block: blockName,
+        force,
+        dryRun: false,
+        cwd: resolvedTargetDir
+      });
+      if (addResult.isErr()) {
+        return Result2.err(new InitError(`Failed to add block '${blockName}': ${addResult.error.message}`));
+      }
+      const blockResult = addResult.value;
+      mergedResult.created.push(...blockResult.created);
+      mergedResult.skipped.push(...blockResult.skipped);
+      mergedResult.overwritten.push(...blockResult.overwritten);
+      Object.assign(mergedResult.dependencies, blockResult.dependencies);
+      Object.assign(mergedResult.devDependencies, blockResult.devDependencies);
+    }
+    blocksAdded = mergedResult;
+  }
+  return Result2.ok({ blocksAdded });
 }
 function initCommand(program) {
   const init = program.command("init").description("Scaffold a new Outfitter project");
@@ -643,7 +767,42 @@ function initCommand(program) {
     return typeof flags.opts === "function" ? flags.opts() : flags;
   };
   const resolveLocal = (flags) => Boolean(flags.local || flags.workspace);
-  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("-f, --force", "Overwrite existing files", false).option("--local", "Use workspace:* for @outfitter dependencies", false).option("--workspace", "Alias for --local", false);
+  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("-f, --force", "Overwrite existing files", false).option("--local", "Use workspace:* for @outfitter dependencies", false).option("--workspace", "Alias for --local", false).option("--with <blocks>", "Tooling to add (comma-separated: scaffolding, claude, biome, lefthook, bootstrap)").option("--no-tooling", "Skip tooling setup");
+  const printInitResult = (targetDir, result) => {
+    console.log(`Project initialized successfully in ${resolve3(targetDir)}`);
+    if (result.blocksAdded) {
+      const { created, skipped, dependencies, devDependencies } = result.blocksAdded;
+      if (created.length > 0) {
+        console.log(`
+Added ${created.length} tooling file(s):`);
+        for (const file of created) {
+          console.log(`  ✓ ${file}`);
+        }
+      }
+      if (skipped.length > 0) {
+        console.log(`
+Skipped ${skipped.length} existing file(s):`);
+        for (const file of skipped) {
+          console.log(`  - ${file}`);
+        }
+      }
+      const depCount = Object.keys(dependencies).length + Object.keys(devDependencies).length;
+      if (depCount > 0) {
+        console.log(`
+Added ${depCount} package(s) to package.json:`);
+        for (const [name, version] of Object.entries(dependencies)) {
+          console.log(`  + ${name}@${version}`);
+        }
+        for (const [name, version] of Object.entries(devDependencies)) {
+          console.log(`  + ${name}@${version} (dev)`);
+        }
+      }
+    }
+    console.log(`
+Next steps:`);
+    console.log("  bun install");
+    console.log("  bun run dev");
+  };
   withCommonOptions(init.argument("[directory]").option("-t, --template <template>", "Template to use")).action(async (directory, flags, command) => {
     const targetDir = directory ?? process.cwd();
     const resolvedFlags = resolveFlags(flags, command);
@@ -654,13 +813,15 @@ function initCommand(program) {
       template: resolvedFlags.template,
       local,
       force: resolvedFlags.force ?? false,
+      with: resolvedFlags.with,
+      noTooling: resolvedFlags.noTooling,
       ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
     });
     if (result.isErr()) {
       console.error(`Error: ${result.error.message}`);
       process.exit(1);
     }
-    console.log(`Project initialized successfully in ${resolve2(targetDir)}`);
+    printInitResult(targetDir, result.value);
   });
   withCommonOptions(init.command("cli [directory]").description("Scaffold a new CLI project")).action(async (directory, flags, command) => {
     const targetDir = directory ?? process.cwd();
@@ -672,13 +833,15 @@ function initCommand(program) {
       template: "cli",
       local,
       force: resolvedFlags.force ?? false,
+      with: resolvedFlags.with,
+      noTooling: resolvedFlags.noTooling,
       ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
     });
     if (result.isErr()) {
       console.error(`Error: ${result.error.message}`);
       process.exit(1);
     }
-    console.log(`Project initialized successfully in ${resolve2(targetDir)}`);
+    printInitResult(targetDir, result.value);
   });
   withCommonOptions(init.command("mcp [directory]").description("Scaffold a new MCP server")).action(async (directory, flags, command) => {
     const targetDir = directory ?? process.cwd();
@@ -690,13 +853,15 @@ function initCommand(program) {
       template: "mcp",
       local,
       force: resolvedFlags.force ?? false,
+      with: resolvedFlags.with,
+      noTooling: resolvedFlags.noTooling,
       ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
     });
     if (result.isErr()) {
       console.error(`Error: ${result.error.message}`);
       process.exit(1);
     }
-    console.log(`Project initialized successfully in ${resolve2(targetDir)}`);
+    printInitResult(targetDir, result.value);
   });
   withCommonOptions(init.command("daemon [directory]").description("Scaffold a new daemon project")).action(async (directory, flags, command) => {
     const targetDir = directory ?? process.cwd();
@@ -708,31 +873,33 @@ function initCommand(program) {
       template: "daemon",
       local,
       force: resolvedFlags.force ?? false,
+      with: resolvedFlags.with,
+      noTooling: resolvedFlags.noTooling,
       ...resolvedFlags.bin !== undefined ? { bin: resolvedFlags.bin } : {}
     });
     if (result.isErr()) {
       console.error(`Error: ${result.error.message}`);
       process.exit(1);
     }
-    console.log(`Project initialized successfully in ${resolve2(targetDir)}`);
+    printInitResult(targetDir, result.value);
   });
 }
 
 // src/actions.ts
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 import {
   createActionRegistry,
   defineAction,
   InternalError,
-  Result as Result2
+  Result as Result3
 } from "@outfitter/contracts";
 import { z } from "zod";
 
 // src/commands/demo.ts
-import { isCancel as isCancel2, select as select2 } from "@clack/prompts";
+import { isCancel, select } from "@clack/prompts";
 import { createTheme as createTheme3, renderTable as renderTable2, SPINNERS } from "@outfitter/cli/render";
 import { ANSI } from "@outfitter/cli/streaming";
-import { isInteractive as isInteractive2 } from "@outfitter/cli/terminal";
+import { isInteractive } from "@outfitter/cli/terminal";
 
 // src/commands/demo/index.ts
 import {
@@ -951,7 +1118,7 @@ async function runDemo(options) {
   if (options.section) {
     return runSectionByName(options.section);
   }
-  if (isInteractive2()) {
+  if (isInteractive()) {
     const selectedSection = await selectSection();
     if (selectedSection === null) {
       return { output: "", exitCode: 130 };
@@ -985,11 +1152,11 @@ async function selectSection() {
       hint: s.description
     }))
   ];
-  const selection = await select2({
+  const selection = await select({
     message: "Select a demo section",
     options
   });
-  if (isCancel2(selection)) {
+  if (isCancel(selection)) {
     return null;
   }
   return String(selection);
@@ -1165,13 +1332,13 @@ function createInitAction(options) {
     handler: async (input) => {
       const result = await runInit(input);
       if (result.isErr()) {
-        return Result2.err(new InternalError({
+        return Result3.err(new InternalError({
           message: result.error.message,
           context: { action: options.id }
         }));
       }
-      console.log(`Project initialized successfully in ${resolve3(input.targetDir)}`);
-      return Result2.ok({ ok: true });
+      console.log(`Project initialized successfully in ${resolve4(input.targetDir)}`);
+      return Result3.ok({ ok: true });
     }
   });
 }
@@ -1212,7 +1379,7 @@ var demoAction = defineAction({
     if (result.exitCode !== 0) {
       process.exit(result.exitCode);
     }
-    return Result2.ok(result);
+    return Result3.ok(result);
   }
 });
 var doctorAction = defineAction({
@@ -1231,7 +1398,79 @@ var doctorAction = defineAction({
     if (result.exitCode !== 0) {
       process.exit(result.exitCode);
     }
-    return Result2.ok(result);
+    return Result3.ok(result);
+  }
+});
+var addInputSchema = z.object({
+  block: z.string(),
+  force: z.boolean(),
+  dryRun: z.boolean(),
+  cwd: z.string().optional()
+});
+var addAction = defineAction({
+  id: "add",
+  description: "Add a block from the registry to your project",
+  surfaces: ["cli"],
+  input: addInputSchema,
+  cli: {
+    group: "add",
+    command: "<block>",
+    description: "Add a block from the registry (claude, biome, lefthook, bootstrap, scaffolding)",
+    options: [
+      {
+        flags: "-f, --force",
+        description: "Overwrite existing files",
+        defaultValue: false
+      },
+      {
+        flags: "--dry-run",
+        description: "Show what would be added without making changes",
+        defaultValue: false
+      }
+    ],
+    mapInput: (context) => ({
+      block: context.args[0],
+      force: Boolean(context.flags["force"]),
+      dryRun: Boolean(context.flags["dry-run"] ?? context.flags["dryRun"]),
+      cwd: process.cwd()
+    })
+  },
+  handler: async (input) => {
+    const result = await runAdd(input);
+    if (result.isErr()) {
+      return Result3.err(new InternalError({
+        message: result.error.message,
+        context: { action: "add" }
+      }));
+    }
+    printAddResults(result.value, input.dryRun);
+    return Result3.ok(result.value);
+  }
+});
+var listBlocksAction = defineAction({
+  id: "add.list",
+  description: "List available blocks",
+  surfaces: ["cli"],
+  input: z.object({}),
+  cli: {
+    group: "add",
+    command: "list",
+    description: "List available blocks",
+    mapInput: () => ({})
+  },
+  handler: () => {
+    const result = listBlocks();
+    if (result.isErr()) {
+      return Result3.err(new InternalError({
+        message: result.error.message,
+        context: { action: "add.list" }
+      }));
+    }
+    console.log("Available blocks:");
+    for (const block of result.value) {
+      console.log(`  - ${block}`);
+    }
+    return Result3.ok({ blocks: result.value });
   }
 });
 var outfitterActions = createActionRegistry().add(createInitAction({
@@ -1254,6 +1493,6 @@ var outfitterActions = createActionRegistry().add(createInitAction({
   description: "Scaffold a new daemon project",
   command: "daemon [directory]",
   templateOverride: "daemon"
-})).add(demoAction).add(doctorAction);
+})).add(demoAction).add(doctorAction).add(addAction).add(listBlocksAction);
 
 export { runDoctor, printDoctorResults, doctorCommand, InitError, runInit, initCommand, outfitterActions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "outfitter",
   "description": "Outfitter umbrella CLI for scaffolding and project management",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0",
   "type": "module",
   "files": [
     "dist",
@@ -10,28 +10,28 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    },
     "./commands/demo/errors": {
       "import": {
         "types": "./dist/commands/demo/errors.d.ts",
         "default": "./dist/commands/demo/errors.js"
       }
     },
+    "./commands/demo": {
+      "import": {
+        "types": "./dist/commands/demo.d.ts",
+        "default": "./dist/commands/demo.js"
+      }
+    },
     "./actions": {
       "import": {
         "types": "./dist/actions.d.ts",
         "default": "./dist/actions.js"
       }
     },
-    "./commands/shared-deps": {
+    ".": {
       "import": {
-        "types": "./dist/commands/shared-deps.d.ts",
-        "default": "./dist/commands/shared-deps.js"
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
       }
     },
     "./commands/doctor": {
@@ -46,10 +46,16 @@
         "default": "./dist/commands/init.js"
       }
     },
-    "./commands/demo": {
+    "./commands/shared-deps": {
+      "import": {
+        "types": "./dist/commands/shared-deps.d.ts",
+        "default": "./dist/commands/shared-deps.js"
+      }
+    },
+    "./commands/add": {
       "import": {
-        "types": "./dist/commands/demo/index.d.ts",
-        "default": "./dist/commands/demo/index.js"
+        "types": "./dist/commands/add.d.ts",
+        "default": "./dist/commands/add.js"
       }
     },
     "./package.json": "./package.json"
@@ -74,9 +80,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "@outfitter/cli": "0.1.0-rc.3",
-    "@outfitter/config": "0.1.0-rc.3",
-    "@outfitter/contracts": "0.1.0-rc.2",
+    "@outfitter/cli": "0.1.0",
+    "@outfitter/config": "0.1.0",
+    "@outfitter/contracts": "0.1.0",
+    "@outfitter/tooling": "0.1.0",
     "commander": "^14.0.2",
     "zod": "^4.3.5"
   },