@outfitter/presets 0.2.0 → 0.3.0

package/presets/daemon/package.json.template

@@ -1,49 +1,52 @@
 {
-	"name": "{{packageName}}",
-	"version": "{{version}}",
-	"description": "{{description}}",
-	"type": "module",
-	"bin": {
-		"{{binName}}": "./dist/cli.js",
-		"{{binName}}d": "./dist/daemon.js"
-	},
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
-		}
-	},
-	"scripts": {
-		"build": "bun build src/cli.ts src/daemon.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
-		"dev": "bun --watch src/daemon.ts -- --foreground",
-		"dev:daemon": "bun --watch src/daemon.ts -- --foreground",
-		"typecheck": "tsc --noEmit",
-		"check": "ultracite check",
-		"verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
-		"test": "bun test",
-		"test:watch": "bun test --watch",
-		"lint": "biome check .",
-		"lint:fix": "biome check . --write",
-		"format": "biome format --write .",
-		"clean:artifacts": "rm -rf dist .turbo"
-	},
-	"dependencies": {
-		"@outfitter/contracts": "workspace:*",
-		"@outfitter/types": "workspace:*",
-		"@outfitter/daemon": "workspace:*",
-		"@outfitter/cli": "workspace:*",
-		"@outfitter/logging": "workspace:*",
-		"commander": "^14.0.2"
-	},
-	"devDependencies": {},
-	"outfitter": {
-		"template": {
-			"kind": "runnable",
-			"placement": "apps",
-			"surfaces": ["cli", "daemon"]
-		}
-	},
-	"license": "MIT"
+  "name": "{{packageName}}",
+  "version": "{{version}}",
+  "description": "{{description}}",
+  "license": "MIT",
+  "bin": {
+    "{{binName}}": "./dist/cli.js",
+    "{{binName}}d": "./dist/daemon.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts src/daemon.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
+    "dev": "bun --watch src/daemon.ts -- --foreground",
+    "dev:daemon": "bun --watch src/daemon.ts -- --foreground",
+    "typecheck": "tsc --noEmit",
+    "check": "ultracite check",
+    "verify:ci": "bun run typecheck && bun run check && bun run build && bun run test",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "format": "oxfmt --write .",
+    "clean:artifacts": "rm -rf dist .turbo"
+  },
+  "dependencies": {
+    "@outfitter/cli": "workspace:*",
+    "@outfitter/contracts": "workspace:*",
+    "@outfitter/daemon": "workspace:*",
+    "@outfitter/logging": "workspace:*",
+    "@outfitter/types": "workspace:*",
+    "commander": "catalog:"
+  },
+  "devDependencies": {},
+  "outfitter": {
+    "template": {
+      "kind": "runnable",
+      "placement": "apps",
+      "surfaces": [
+        "cli",
+        "daemon"
+      ]
+    }
+  }
 }

package/presets/daemon/src/cli.ts.template

@@ -2,13 +2,14 @@
 /**
  * {{projectName}} CLI entry point
  *
- * Commands: start, stop, restart, status
+ * Commands: start, stop, status
  */
 
-import { createCLI, command } from "@outfitter/cli";
-import { createLogger } from "@outfitter/logging";
 import { spawn } from "node:child_process";
+
+import { createCLI, command } from "@outfitter/cli/command";
 import { getSocketPath, getLockPath, isDaemonAlive } from "@outfitter/daemon";
+import { createLogger } from "@outfitter/logging";
 
 const logger = createLogger({ name: "{{binName}}" });
 
@@ -17,80 +18,86 @@ const socketPath = getSocketPath(TOOL_NAME);
 const lockPath = getLockPath(TOOL_NAME);
 
 const program = createCLI({
-	name: "{{binName}}",
-	version: "{{version}}",
-	description: "{{description}}",
+  name: "{{binName}}",
+  version: "{{version}}",
+  description: "{{description}}",
 });
 
 program.register(
-	command("start")
-		.description("Start the daemon")
-		.option("-f, --foreground", "Run in foreground")
-		.action(async ({ flags }) => {
-			const foreground = Boolean((flags as { foreground?: boolean }).foreground);
+  command("start")
+    .description("Start the daemon")
+    .option("-f, --foreground", "Run in foreground")
+    .action(async ({ flags }) => {
+      const foreground = Boolean(
+        (flags as { foreground?: boolean }).foreground
+      );
 
-			if (await isDaemonAlive(lockPath)) {
-				logger.warn`Daemon is already running`;
-				process.exit(1);
-			}
+      if (await isDaemonAlive(lockPath)) {
+        logger.warn("Daemon is already running");
+        process.exit(1);
+      }
 
-			if (foreground) {
-				// Run in foreground - import and run daemon directly
-				const { runDaemon } = await import("./daemon-main.js");
-				await runDaemon();
-			} else {
-				// Spawn daemon in background
-				const daemon = spawn(process.execPath, [import.meta.dir + "/daemon.js"], {
-					detached: true,
-					stdio: "ignore",
-				});
-				daemon.unref();
-				logger.info`Daemon started with PID ${daemon.pid}`;
-			}
-		}),
+      if (foreground) {
+        // Run in foreground - import and run daemon directly
+        const { runDaemon } = await import("./daemon-main.js");
+        await runDaemon();
+      } else {
+        // Spawn daemon in background
+        const daemon = spawn(
+          process.execPath,
+          [import.meta.dir + "/daemon.js"],
+          {
+            detached: true,
+            stdio: "ignore",
+          }
+        );
+        daemon.unref();
+        logger.info(`Daemon started with PID ${daemon.pid}`);
+      }
+    })
 );
 
 program.register(
-	command("stop")
-		.description("Stop the daemon")
-		.action(async () => {
-			if (!(await isDaemonAlive(lockPath))) {
-				logger.warn`Daemon is not running`;
-				process.exit(1);
-			}
-			// Signal daemon to stop via HTTP
-			try {
-				const response = await fetch(`http://unix:${socketPath}:/shutdown`, {
-					method: "POST",
-				});
-				if (response.ok) {
-					logger.info`Daemon stopped`;
-				}
-			} catch {
-				logger.error`Failed to stop daemon`;
-				process.exit(1);
-			}
-		}),
+  command("stop")
+    .description("Stop the daemon")
+    .action(async () => {
+      if (!(await isDaemonAlive(lockPath))) {
+        logger.warn("Daemon is not running");
+        process.exit(1);
+      }
+      // Signal daemon to stop via HTTP
+      try {
+        const response = await fetch(`http://unix:${socketPath}:/shutdown`, {
+          method: "POST",
+        });
+        if (response.ok) {
+          logger.info("Daemon stopped");
+        }
+      } catch {
+        logger.error("Failed to stop daemon");
+        process.exit(1);
+      }
+    })
 );
 
 program.register(
-	command("status")
-		.description("Check daemon status")
-		.action(async () => {
-			if (await isDaemonAlive(lockPath)) {
-				logger.info`Daemon is running`;
-				// Fetch health info
-				try {
-					const response = await fetch(`http://unix:${socketPath}:/health`);
-					const health = await response.json();
-					console.log(JSON.stringify(health, null, 2));
-				} catch {
-					logger.warn`Could not fetch health info`;
-				}
-			} else {
-				logger.info`Daemon is not running`;
-			}
-		}),
+  command("status")
+    .description("Check daemon status")
+    .action(async () => {
+      if (await isDaemonAlive(lockPath)) {
+        logger.info("Daemon is running");
+        // Fetch health info
+        try {
+          const response = await fetch(`http://unix:${socketPath}:/health`);
+          const health = await response.json();
+          console.log(JSON.stringify(health, null, 2));
+        } catch {
+          logger.warn("Could not fetch health info");
+        }
+      } else {
+        logger.info("Daemon is not running");
+      }
+    })
 );
 
 program.parse(process.argv);

package/presets/daemon/src/daemon-main.ts.template

@@ -2,15 +2,16 @@
  * {{projectName}} daemon main logic
  */
 
-import { createLogger } from "@outfitter/logging";
+import { mkdir } from "node:fs/promises";
+
 import {
-	getSocketPath,
-	getLockPath,
-	getDaemonDir,
-	acquireDaemonLock,
-	releaseDaemonLock,
+  getSocketPath,
+  getLockPath,
+  getDaemonDir,
+  acquireDaemonLock,
+  releaseDaemonLock,
 } from "@outfitter/daemon";
-import { mkdir } from "node:fs/promises";
+import { createLogger } from "@outfitter/logging";
 
 const logger = createLogger({ name: "{{binName}}d" });
 
@@ -18,62 +19,62 @@ const TOOL_NAME = "{{binName}}";
 const startTime = Date.now();
 
 export async function runDaemon(): Promise<void> {
-	const socketPath = getSocketPath(TOOL_NAME);
-	const lockPath = getLockPath(TOOL_NAME);
-	const daemonDir = getDaemonDir(TOOL_NAME);
+  const socketPath = getSocketPath(TOOL_NAME);
+  const lockPath = getLockPath(TOOL_NAME);
+  const daemonDir = getDaemonDir(TOOL_NAME);
 
-	// Ensure daemon directory exists
-	await mkdir(daemonDir, { recursive: true });
+  // Ensure daemon directory exists
+  await mkdir(daemonDir, { recursive: true });
 
-	// Acquire lock
-	const lockResult = await acquireDaemonLock(lockPath);
-	if (!lockResult.isOk()) {
-		logger.error`Failed to acquire lock: ${lockResult.error.message}`;
-		process.exit(1);
-	}
-	const lock = lockResult.value;
+  // Acquire lock
+  const lockResult = await acquireDaemonLock(lockPath);
+  if (!lockResult.isOk()) {
+    logger.error(`Failed to acquire lock: ${lockResult.error.message}`);
+    process.exit(1);
+  }
+  const lock = lockResult.value;
 
-	logger.info`Daemon starting on ${socketPath}`;
+  logger.info(`Daemon starting on ${socketPath}`);
 
-	// Create HTTP server on Unix socket
-	const server = Bun.serve({
-		unix: socketPath,
-		fetch(request) {
-			const url = new URL(request.url);
+  // Create HTTP server on Unix socket
+  const server = Bun.serve({
+    unix: socketPath,
+    fetch(request) {
+      const url = new URL(request.url);
 
-			if (url.pathname === "/health") {
-				return Response.json({
-					status: "ok",
-					uptime: Date.now() - startTime,
-					version: "{{version}}",
-				});
-			}
+      if (url.pathname === "/health") {
+        return Response.json({
+          status: "ok",
+          uptime: Date.now() - startTime,
+          version: "{{version}}",
+        });
+      }
 
-			if (url.pathname === "/shutdown" && request.method === "POST") {
-				logger.info`Shutdown requested`;
-				// Schedule shutdown
-				setTimeout(async () => {
-					await releaseDaemonLock(lock);
-					server.stop();
-					process.exit(0);
-				}, 100);
-				return new Response("Shutting down");
-			}
+      if (url.pathname === "/shutdown" && request.method === "POST") {
+        logger.info("Shutdown requested");
+        // Schedule shutdown
+        setTimeout(async () => {
+          await releaseDaemonLock(lock);
+          server.stop();
+          process.exit(0);
+        }, 100);
+        return new Response("Shutting down");
+      }
 
-			return new Response("Not found", { status: 404 });
-		},
-	});
+      return new Response("Not found", { status: 404 });
+    },
+  });
 
-	// Handle signals
-	const shutdown = async () => {
-		logger.info`Received shutdown signal`;
-		await releaseDaemonLock(lock);
-		server.stop();
-		process.exit(0);
-	};
+  // Handle signals
+  const shutdown = async () => {
+    logger.info("Received shutdown signal");
+    await releaseDaemonLock(lock);
+    server.stop();
+    process.exit(0);
+  };
 
-	process.on("SIGTERM", shutdown);
-	process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
 
-	logger.info`Daemon running`;
+  logger.info("Daemon running");
 }

package/presets/daemon/src/daemon.ts.template

@@ -3,9 +3,13 @@
  * {{projectName}} daemon entry point
  */
 
+import { createLogger } from "@outfitter/logging";
+
 import { runDaemon } from "./daemon-main.js";
 
-runDaemon().catch((error) => {
-	console.error("Daemon failed:", error);
-	process.exit(1);
+const logger = createLogger({ name: "{{binName}}d" });
+
+runDaemon().catch((error: unknown) => {
+  logger.error("Daemon failed", { error });
+  process.exit(1);
 });

package/presets/daemon/src/index.test.ts.template

@@ -0,0 +1,9 @@
+import { describe, expect, test } from "bun:test";
+
+import { runDaemon } from "./index.js";
+
+describe("daemon", () => {
+  test("exports the daemon entrypoint", () => {
+    expect(typeof runDaemon).toBe("function");
+  });
+});

package/presets/daemon/tsconfig.json.template

@@ -1,23 +1,23 @@
 {
-	"compilerOptions": {
-		"target": "ESNext",
-		"module": "ESNext",
-		"moduleResolution": "bundler",
-		"strict": true,
-		"esModuleInterop": true,
-		"verbatimModuleSyntax": true,
-		"skipLibCheck": true,
-		"declaration": true,
-		"declarationDir": "dist",
-		"outDir": "dist",
-		"rootDir": "src",
-		"types": ["bun-types"],
-		"noImplicitAny": true,
-		"strictNullChecks": true,
-		"noUncheckedIndexedAccess": true,
-		"exactOptionalPropertyTypes": true,
-		"noPropertyAccessFromIndexSignature": true
-	},
-	"include": ["src"],
-	"exclude": ["node_modules", "dist"]
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationDir": "dist",
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["bun-types"],
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
 }

package/presets/full-stack/CLAUDE.md.template

@@ -0,0 +1,66 @@
+# CLAUDE.md
+
+Bun-first TypeScript monorepo. Tests before code. Result types, not exceptions.
+
+## Commands
+
+```bash
+# Root (all packages)
+bun run build        # Build all packages (Bun workspaces)
+bun run dev          # Dev mode for all packages
+bun run test         # Test all packages
+bun run typecheck    # TypeScript validation
+bun run check        # Lint checks (all packages)
+bun run lint:fix     # Auto-fix lint issues (all packages)
+bun run format       # Auto-fix formatting (all packages)
+bun run verify:ci    # Full CI validation (typecheck + check + build + test)
+
+# Single package
+bun run --filter={{packageName}}-core build
+bun run --filter={{packageName}}-core test
+cd packages/core && bun test
+```
+
+## Architecture
+
+Monorepo with shared core library, CLI app, and MCP server.
+
+### Project Structure
+
+- `packages/core/` — Shared handlers and types (library)
+- `apps/cli/` — CLI application (thin adapter over core handlers)
+- `apps/mcp/` — MCP server (thin adapter over core handlers)
+
+### Handler Contract
+
+All domain logic lives in `packages/core/` as transport-agnostic handlers returning `Result<T, E>`:
+
+```typescript
+async function handler(
+  input: unknown,
+  ctx: HandlerContext
+): Promise<Result<Output, ValidationError>>;
+```
+
+CLI and MCP are thin adapters over shared handlers. Write the handler once in core, expose it everywhere.
+
+### Adding a Feature
+
+1. Define types and Zod schema in `packages/core/src/types.ts`
+2. Implement handler in `packages/core/src/handlers.ts` returning `Result<T, E>`
+3. Add tests in `packages/core/src/<name>.test.ts`
+4. Wire CLI command in `apps/cli/src/` using CommandBuilder
+5. Wire MCP tool in `apps/mcp/src/` using `defineTool()`
+
+## Development Principles
+
+- **TDD-First** — Write the test before the code (Red / Green / Refactor)
+- **Result Types** — Handlers return `Result<T, E>`, not exceptions
+- **Bun-First** — Use Bun-native APIs before npm packages
+- **Strict TypeScript** — No `any`, no `as` casts; narrow instead of assert
+
+## Testing
+
+- Runner: Bun test runner
+- Files: `src/*.test.ts` within each package
+- Run: `bun test` (per package) or `bun run test` (all packages from root)

package/presets/full-stack/apps/cli/package.json.template

@@ -1,35 +1,36 @@
 {
-	"name": "{{packageName}}-cli",
-	"version": "{{version}}",
-	"description": "CLI surface for {{projectName}}",
-	"type": "module",
-	"bin": {
-		"{{projectName}}": "./dist/cli.js"
-	},
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
-		}
-	},
-	"scripts": {
-		"build": "bun build src/cli.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
-		"dev": "bun --watch src/cli.ts",
-		"test": "bun test",
-		"test:watch": "bun test --watch",
-		"typecheck": "tsc --noEmit",
-		"lint": "biome check .",
-		"lint:fix": "biome check . --write",
-		"format": "biome format --write .",
-		"clean:artifacts": "rm -rf dist .turbo"
-	},
-	"dependencies": {
-		"{{packageName}}-core": "workspace:*",
-		"@outfitter/cli": "workspace:*",
-		"@outfitter/contracts": "workspace:*"
-	},
-	"devDependencies": {},
-	"license": "MIT"
+  "name": "{{packageName}}-cli",
+  "version": "{{version}}",
+  "description": "CLI surface for {{projectName}}",
+  "license": "MIT",
+  "bin": {
+    "{{projectName}}": "./dist/cli.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --outdir dist --target bun && bun build src/index.ts --outdir dist --target bun --sourcemap",
+    "dev": "bun --watch src/cli.ts",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "format": "oxfmt --write .",
+    "check": "ultracite check",
+    "clean:artifacts": "rm -rf dist .turbo"
+  },
+  "dependencies": {
+    "@outfitter/cli": "workspace:*",
+    "@outfitter/contracts": "workspace:*",
+    "{{packageName}}-core": "workspace:*"
+  },
+  "devDependencies": {}
 }