@outfitter/presets 0.2.1 → 0.3.0

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": "oxlint .",
-		"lint:fix": "oxlint --fix .",
-		"format": "oxfmt --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": {}
 }

package/presets/full-stack/apps/cli/src/cli.ts.template

@@ -1,24 +1,25 @@
-import { createContext } from "@outfitter/contracts";
 import { output } from "@outfitter/cli";
+import { createContext } from "@outfitter/contracts";
 import { createGreeting } from "{{packageName}}-core";
 
-export async function runCli(argv: readonly string[] = process.argv): Promise<void> {
-	const args = argv.slice(2);
-	const name =
-		args.find((arg) => !arg.startsWith("-")) ?? "World";
-	const excited = args.includes("--excited");
-	const result = await createGreeting(
-		{ name, excited },
-		createContext({ cwd: process.cwd(), env: process.env })
-	);
+export async function runCli(
+  argv: readonly string[] = process.argv
+): Promise<void> {
+  const args = argv.slice(2);
+  const name = args.find((arg) => !arg.startsWith("-")) ?? "World";
+  const excited = args.includes("--excited");
+  const result = await createGreeting(
+    { name, excited },
+    createContext({ cwd: process.cwd(), env: process.env })
+  );
 
-	if (result.isErr()) {
-		throw result.error;
-	}
+  if (result.isErr()) {
+    throw result.error;
+  }
 
-	await output(result.value.message, { mode: "human" });
+  await output(result.value.message, { mode: "human" });
 }
 
 if (import.meta.main) {
-	await runCli();
+  await runCli();
 }

package/presets/full-stack/apps/cli/src/index.test.ts.template

@@ -1,18 +1,19 @@
 import { describe, expect, test } from "bun:test";
+
 import { createContext } from "@outfitter/contracts";
 import { createGreeting } from "{{packageName}}-core";
 
 describe("cli surface", () => {
-	test("can use shared core handler", async () => {
-		const result = await createGreeting(
-			{ name: "CLI", excited: true },
-			createContext({ cwd: process.cwd(), env: process.env })
-		);
+  test("can use shared core handler", async () => {
+    const result = await createGreeting(
+      { name: "CLI", excited: true },
+      createContext({ cwd: process.cwd(), env: process.env })
+    );
 
-		expect(result.isOk()).toBe(true);
-		if (result.isErr()) {
-			return;
-		}
-		expect(result.value.message).toBe("Hello, CLI!");
-	});
+    expect(result.isOk()).toBe(true);
+    if (result.isErr()) {
+      return;
+    }
+    expect(result.value.message).toBe("Hello, CLI!");
+  });
 });