@donkeylabs/server 0.1.0

package/mcp/donkeylabs-mcp

@@ -0,0 +1,3238 @@
+#!/usr/bin/env bun
+/**
+ * @donkeylabs/server MCP Server
+ *
+ * Provides tools for AI assistants to create and manage plugins,
+ * routes, and server code following project conventions.
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  type Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { mkdir, writeFile, readFile, readdir } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { existsSync } from "node:fs";
+
+// ============================================
+// Tool Definitions
+// ============================================
+
+const tools: Tool[] = [
+  {
+    name: "init_project",
+    description: `Initialize a new @donkeylabs/server project. Creates the basic structure with:
+- src/index.ts (server entry point)
+- src/db.ts (SQLite database setup)
+- donkeylabs.config.ts (project config)
+- package.json with dependencies
+- tsconfig.json
+
+Run this first before creating plugins or routes.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectName: {
+          type: "string",
+          description: "Name for the project (used in package.json)",
+        },
+        useDatabase: {
+          type: "boolean",
+          description: "Set up SQLite database (default: true)",
+          default: true,
+        },
+      },
+    },
+  },
+  {
+    name: "create_plugin",
+    description: `Create a new plugin with correct directory structure.
+
+AVAILABLE IN PLUGIN SERVICE CONTEXT (ctx):
+- ctx.db: Kysely database with your schema types
+- ctx.deps: Access to dependency plugin services (e.g., ctx.deps.auth)
+- ctx.core.logger: Structured logging (info, warn, error, debug)
+- ctx.core.cache: In-memory caching with TTL
+- ctx.core.events: Pub/sub event system
+- ctx.core.jobs: Background job processing
+- ctx.core.cron: Scheduled tasks (cron expressions)
+- ctx.core.sse: Server-sent events for real-time updates
+- ctx.core.rateLimiter: Rate limiting per IP/key
+- ctx.errors: Error factories (BadRequest, Unauthorized, NotFound, etc.)
+
+Use these services to build robust, production-ready plugins.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Plugin name (lowercase, alphanumeric with dashes). Example: 'notifications' or 'user-preferences'",
+        },
+        hasSchema: {
+          type: "boolean",
+          description: "Whether this plugin needs a database schema and migrations",
+          default: false,
+        },
+        dependencies: {
+          type: "array",
+          items: { type: "string" },
+          description: "Names of other plugins this depends on. Example: ['auth', 'notifications']",
+          default: [],
+        },
+        serviceMethods: {
+          type: "array",
+          items: { type: "string" },
+          description: "Names of service methods to scaffold. Example: ['sendEmail', 'getNotifications']",
+          default: [],
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "add_route",
+    description:
+      "Add a new route to an existing router file. Generates properly typed route with input/output schemas.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        routerFile: {
+          type: "string",
+          description: "Path to the router file (relative to project root). Example: 'src/index.ts'",
+        },
+        routeName: {
+          type: "string",
+          description: "Name of the route (will be prefixed with router namespace). Example: 'getUser'",
+        },
+        handlerType: {
+          type: "string",
+          enum: ["typed", "raw"],
+          description: "Handler type: 'typed' for JSON-RPC style, 'raw' for direct Request/Response",
+          default: "typed",
+        },
+        inputFields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string", enum: ["string", "number", "boolean", "object", "array"] },
+              optional: { type: "boolean", default: false },
+            },
+          },
+          description: "Input schema fields for typed handlers",
+        },
+        outputFields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string", enum: ["string", "number", "boolean", "object", "array"] },
+            },
+          },
+          description: "Output schema fields for typed handlers",
+        },
+        description: {
+          type: "string",
+          description: "Description of what this route does",
+        },
+      },
+      required: ["routerFile", "routeName"],
+    },
+  },
+  {
+    name: "add_migration",
+    description:
+      "Create a new migration file for a plugin with proper sequential numbering.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Name of the plugin to add migration to",
+        },
+        migrationName: {
+          type: "string",
+          description: "Name for the migration (snake_case). Example: 'add_email_column'",
+        },
+        upSql: {
+          type: "string",
+          description: "SQL or Kysely code for the 'up' migration",
+        },
+        downSql: {
+          type: "string",
+          description: "SQL or Kysely code for the 'down' migration",
+        },
+      },
+      required: ["pluginName", "migrationName"],
+    },
+  },
+  {
+    name: "generate_types",
+    description:
+      "Run type generation to update registry.d.ts and context.d.ts after making changes to plugins or handlers.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "list_plugins",
+    description:
+      "List all plugins in the project with their dependencies and service methods.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "get_project_info",
+    description:
+      "Get information about the project structure, available handlers, middleware, and configuration.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "add_service_method",
+    description:
+      "Add a new method to an existing plugin's service interface and implementation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Name of the plugin to add the method to",
+        },
+        methodName: {
+          type: "string",
+          description: "Name of the method (camelCase). Example: 'sendNotification'",
+        },
+        params: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string" },
+            },
+          },
+          description: "Method parameters",
+        },
+        returnType: {
+          type: "string",
+          description: "Return type. Example: 'Promise<boolean>'",
+        },
+        implementation: {
+          type: "string",
+          description: "Method implementation code (optional, will scaffold if not provided)",
+        },
+      },
+      required: ["pluginName", "methodName"],
+    },
+  },
+  {
+    name: "create_router",
+    description:
+      "Create a new router file with a namespace. Use this when you need to organize routes into separate files.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fileName: {
+          type: "string",
+          description: "Name for the router file (without extension). Example: 'users' creates 'src/routes/users.ts'",
+        },
+        namespace: {
+          type: "string",
+          description: "Router namespace (prefix for all routes). Example: 'users' means routes are 'users.list', 'users.get', etc.",
+        },
+        initialRoutes: {
+          type: "array",
+          items: { type: "string" },
+          description: "Names of initial routes to create. Example: ['list', 'get', 'create']",
+          default: [],
+        },
+      },
+      required: ["fileName", "namespace"],
+    },
+  },
+  {
+    name: "validate_project",
+    description:
+      "Check the project for common issues: missing dependencies, invalid plugin structure, import errors, etc.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+  },
+  {
+    name: "register_plugin",
+    description:
+      "Register a plugin in the server's index.ts file. Adds the import and registerPlugin call.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Name of the plugin to register (must exist in src/plugins/)",
+        },
+        configOptions: {
+          type: "object",
+          description: "Optional configuration object to pass to the plugin",
+        },
+      },
+      required: ["pluginName"],
+    },
+  },
+  {
+    name: "run_migrations",
+    description:
+      "Run database migrations for one or all plugins. Creates tables and applies schema changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Plugin name to run migrations for (optional - runs all if not specified)",
+        },
+        direction: {
+          type: "string",
+          enum: ["up", "down"],
+          description: "Migration direction: 'up' to apply, 'down' to rollback (default: up)",
+          default: "up",
+        },
+      },
+    },
+  },
+  {
+    name: "setup_database",
+    description:
+      "Initialize or check database setup. Creates the database file and verifies the connection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dbPath: {
+          type: "string",
+          description: "Path to SQLite database file (default: app.db)",
+          default: "app.db",
+        },
+      },
+    },
+  },
+  {
+    name: "list_routes",
+    description:
+      "List all routes in the project. Shows namespace, route name, handler type, and file path. Use to avoid duplicates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: "Filter by namespace (optional)",
+        },
+      },
+    },
+  },
+  {
+    name: "add_route_file",
+    description: `Create a new route with proper directory structure.
+
+ROUTE HANDLER CONTEXT (ctx) - Available in all handlers:
+- ctx.db: Kysely database with type-safe queries
+- ctx.plugins: All registered plugin services (e.g., ctx.plugins.auth, ctx.plugins.users)
+- ctx.core.logger: Structured logging
+- ctx.core.cache: Caching with TTL
+- ctx.core.events: Pub/sub events
+- ctx.core.jobs: Background job processing
+- ctx.core.cron: Scheduled tasks
+- ctx.core.sse: Server-sent events
+- ctx.core.rateLimiter: Rate limiting
+- ctx.errors: Error factories (BadRequest, NotFound, etc.)
+- ctx.ip: Client IP address
+- ctx.requestId: Request tracking ID
+- ctx.user: Authenticated user (if set by auth middleware)
+
+Creates /src/routes/<namespace>/<route>/handler.ts and optional test.ts.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: "Route namespace (e.g., 'users', 'posts'). Creates /src/routes/<namespace>/",
+        },
+        routeName: {
+          type: "string",
+          description: "Route name (e.g., 'get-by-id', 'create'). Creates /src/routes/<namespace>/<routeName>/",
+        },
+        handlerType: {
+          type: "string",
+          enum: ["typed", "raw"],
+          description: "Handler type: 'typed' for JSON-RPC, 'raw' for Request/Response",
+          default: "typed",
+        },
+        inputFields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string", enum: ["string", "number", "boolean", "object", "array"] },
+              optional: { type: "boolean", default: false },
+            },
+          },
+          description: "Input schema fields (for typed handlers)",
+        },
+        outputFields: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              type: { type: "string", enum: ["string", "number", "boolean", "object", "array"] },
+            },
+          },
+          description: "Output schema fields (for typed handlers)",
+        },
+        description: {
+          type: "string",
+          description: "Description of what this route does",
+        },
+        createTest: {
+          type: "boolean",
+          description: "Create a test file alongside the handler (default: true)",
+          default: true,
+        },
+      },
+      required: ["namespace", "routeName"],
+    },
+  },
+  {
+    name: "create_model",
+    description:
+      "Create a model class in /src/models/ for business logic separation. Models receive GlobalContext for testability.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Model name (PascalCase). Example: 'UserModel' creates /src/models/UserModel.ts",
+        },
+        methods: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              params: { type: "string" },
+              returnType: { type: "string" },
+            },
+          },
+          description: "Methods to scaffold on the model",
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "generate_client",
+    description:
+      "Generate a typed API client from routes. The client provides type-safe methods instead of raw fetch() calls. ALWAYS use this for frontend code.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        output: {
+          type: "string",
+          description: "Output path for generated client (default: src/client/api.ts)",
+          default: "src/client/api.ts",
+        },
+        baseUrl: {
+          type: "string",
+          description: "Default base URL for the client (default: empty, set at runtime)",
+        },
+      },
+    },
+  },
+  {
+    name: "add_unit_test",
+    description:
+      "Create a unit test file for a model or utility. Uses Bun test runner with mock context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetFile: {
+          type: "string",
+          description: "Path to the file being tested (e.g., 'src/models/UserModel.ts')",
+        },
+        testCases: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "Test case name" },
+              method: { type: "string", description: "Method being tested" },
+            },
+          },
+          description: "Test cases to scaffold",
+        },
+      },
+      required: ["targetFile"],
+    },
+  },
+  {
+    name: "add_integration_test",
+    description:
+      "Create an integration test for a route using the test harness. Tests the full request/response cycle with real plugins.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        namespace: {
+          type: "string",
+          description: "Route namespace (e.g., 'users')",
+        },
+        routeName: {
+          type: "string",
+          description: "Route name (e.g., 'create')",
+        },
+        testCases: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "Test case name" },
+              input: { type: "object", description: "Input data for the test" },
+              expectedStatus: { type: "number", description: "Expected HTTP status" },
+            },
+          },
+          description: "Test cases to scaffold",
+        },
+        plugins: {
+          type: "array",
+          items: { type: "string" },
+          description: "Plugins required for this test (e.g., ['auth', 'users'])",
+        },
+      },
+      required: ["namespace", "routeName"],
+    },
+  },
+  {
+    name: "add_middleware",
+    description:
+      "Add middleware to a plugin. Middleware runs before route handlers for auth, logging, rate limiting, etc.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Plugin to add middleware to",
+        },
+        middlewareName: {
+          type: "string",
+          description: "Name of the middleware (camelCase). Example: 'requireAuth'",
+        },
+        description: {
+          type: "string",
+          description: "What this middleware does",
+        },
+        modifiesContext: {
+          type: "boolean",
+          description: "Whether this middleware adds to context (e.g., ctx.user)",
+          default: false,
+        },
+      },
+      required: ["pluginName", "middlewareName"],
+    },
+  },
+  {
+    name: "add_custom_handler",
+    description:
+      "Add a custom handler type to a plugin. Custom handlers extend beyond 'typed' and 'raw' for specialized use cases.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Plugin to add the handler to",
+        },
+        handlerName: {
+          type: "string",
+          description: "Name of the handler (camelCase). Example: 'streaming'",
+        },
+        description: {
+          type: "string",
+          description: "What this handler type does",
+        },
+        signatureParams: {
+          type: "string",
+          description: "Handler function parameters. Example: 'data: T, ctx: ServerContext'",
+        },
+        signatureReturn: {
+          type: "string",
+          description: "Handler function return type. Example: 'Promise<Response>'",
+        },
+      },
+      required: ["pluginName", "handlerName"],
+    },
+  },
+  {
+    name: "create_custom_error",
+    description:
+      "Create a custom error type for a plugin. Custom errors extend HttpError with specific status codes and machine-readable error codes. Use for domain-specific errors like 'InsufficientFunds' or 'QuotaExceeded'.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pluginName: {
+          type: "string",
+          description: "Plugin to add the error to",
+        },
+        errorName: {
+          type: "string",
+          description: "Error name (PascalCase, no 'Error' suffix). E.g., 'InsufficientFunds'",
+        },
+        httpStatus: {
+          type: "number",
+          description: "HTTP status code (default: 400)",
+          default: 400,
+        },
+        defaultMessage: {
+          type: "string",
+          description: "Default error message shown to users",
+        },
+        errorCode: {
+          type: "string",
+          description: "Machine-readable code (UPPER_SNAKE_CASE). E.g., 'INSUFFICIENT_FUNDS'",
+        },
+      },
+      required: ["pluginName", "errorName"],
+    },
+  },
+  {
+    name: "validate_code",
+    description:
+      "Validate code against @donkeylabs/server conventions. Checks for common mistakes, missing patterns, and best practices. Use after writing code to ensure quality.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "Path to the file to validate (relative to project root)",
+        },
+        checkType: {
+          type: "string",
+          enum: ["plugin", "route", "model", "auto"],
+          description: "Type of validation: 'plugin', 'route', 'model', or 'auto' (detect from path). Default: auto",
+          default: "auto",
+        },
+      },
+      required: ["filePath"],
+    },
+  },
+];
+
+// ============================================
+// Tool Implementations
+// ============================================
+
+async function initProject(args: {
+  projectName?: string;
+  useDatabase?: boolean;
+}): Promise<string> {
+  const { projectName = "my-server", useDatabase = true } = args;
+  const root = process.cwd();
+
+  const createdFiles: string[] = [];
+
+  // Create directories
+  await mkdir(join(root, "src/plugins"), { recursive: true });
+  await mkdir(join(root, "src/routes"), { recursive: true });
+  await mkdir(join(root, ".@donkeylabs/server"), { recursive: true });
+
+  // Create donkeylabs.config.ts
+  const configContent = `import { defineConfig } from "@donkeylabs/server";
+
+export default defineConfig({
+  plugins: ["./src/plugins/**/index.ts"],
+  outDir: ".@donkeylabs/server",
+  routes: "./src/routes/**/handler.ts",
+});
+`;
+  await writeFile(join(root, "donkeylabs.config.ts"), configContent);
+  createdFiles.push("donkeylabs.config.ts");
+
+  // Create database setup if requested
+  if (useDatabase) {
+    const dbContent = `import { Kysely } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
+
+const dbPath = process.env.DATABASE_URL || "app.db";
+
+export const db = new Kysely<any>({
+  dialect: new BunSqliteDialect({
+    database: new Database(dbPath),
+  }),
+});
+
+export type DB = typeof db;
+`;
+    await writeFile(join(root, "src/db.ts"), dbContent);
+    createdFiles.push("src/db.ts");
+  }
+
+  // Create main index.ts
+  const indexContent = useDatabase
+    ? `import { db } from "./db";
+import { AppServer, createRouter } from "@donkeylabs/server";
+import { z } from "zod";
+
+// Create Server
+const server = new AppServer({
+  port: Number(process.env.PORT) || 3000,
+  db,
+  config: { env: process.env.NODE_ENV || "development" },
+});
+
+// Health check route
+const router = createRouter("api")
+  .route("health").raw({
+    handle: async () => {
+      return Response.json({ status: "ok", timestamp: new Date().toISOString() });
+    },
+  });
+
+server.use(router);
+
+// Start Server
+await server.start();
+console.log("Server running on http://localhost:3000");
+`
+    : `import { AppServer, createRouter } from "@donkeylabs/server";
+import { Kysely, DummyDriver, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import { z } from "zod";
+
+// Dummy database (no persistence)
+const db = new Kysely<any>({
+  dialect: {
+    createAdapter: () => new SqliteAdapter(),
+    createDriver: () => new DummyDriver(),
+    createIntrospector: (db) => new SqliteIntrospector(db),
+    createQueryCompiler: () => new SqliteQueryCompiler(),
+  },
+});
+
+// Create Server
+const server = new AppServer({
+  port: Number(process.env.PORT) || 3000,
+  db,
+  config: { env: process.env.NODE_ENV || "development" },
+});
+
+// Health check route
+const router = createRouter("api")
+  .route("health").raw({
+    handle: async () => {
+      return Response.json({ status: "ok", timestamp: new Date().toISOString() });
+    },
+  });
+
+server.use(router);
+
+// Start Server
+await server.start();
+console.log("Server running on http://localhost:3000");
+`;
+  await writeFile(join(root, "src/index.ts"), indexContent);
+  createdFiles.push("src/index.ts");
+
+  // Create/update package.json
+  const pkgPath = join(root, "package.json");
+  let pkg: any = { name: projectName, version: "1.0.0", type: "module", scripts: {} };
+
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      pkg.scripts = pkg.scripts || {};
+    } catch {}
+  }
+
+  pkg.name = pkg.name || projectName;
+  pkg.type = "module";
+  pkg.scripts.dev = "bun --watch src/index.ts";
+  pkg.scripts.start = "bun src/index.ts";
+  pkg.scripts["gen:types"] = "donkeylabs generate";
+
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\\n");
+  createdFiles.push("package.json");
+
+  // Create tsconfig.json
+  const tsconfigContent = `{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "*.ts", ".@donkeylabs/**/*"]
+}
+`;
+  if (!existsSync(join(root, "tsconfig.json"))) {
+    await writeFile(join(root, "tsconfig.json"), tsconfigContent);
+    createdFiles.push("tsconfig.json");
+  }
+
+  // Create .gitignore
+  const gitignoreContent = `node_modules/
+.@donkeylabs/
+*.db
+*.db-journal
+.env
+.env.local
+`;
+  if (!existsSync(join(root, ".gitignore"))) {
+    await writeFile(join(root, ".gitignore"), gitignoreContent);
+    createdFiles.push(".gitignore");
+  }
+
+  return `Project initialized successfully!
+
+Created files:
+${createdFiles.map((f) => "  - " + f).join("\\n")}
+
+Next steps:
+1. Install dependencies: bun install @donkeylabs/server kysely kysely-bun-sqlite zod
+2. Create a plugin: use create_plugin tool
+3. Add routes: use add_route_file tool
+4. Generate types: use generate_types tool
+5. Start server: bun run dev`;
+}
+
+async function findProjectRoot(): Promise<string> {
+  let dir = process.cwd();
+  while (dir !== "/") {
+    if (existsSync(join(dir, "donkeylabs.config.ts")) || existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = join(dir, "..");
+  }
+  return process.cwd();
+}
+
+async function getPluginsDir(): Promise<string> {
+  const root = await findProjectRoot();
+  // Check for src/plugins (user project) or examples/basic-server/src/plugins (dev)
+  const srcPlugins = join(root, "src/plugins");
+  if (existsSync(srcPlugins)) return srcPlugins;
+  return join(root, "src/plugins"); // Default to creating here
+}
+
+async function createPlugin(args: {
+  name: string;
+  hasSchema?: boolean;
+  dependencies?: string[];
+  serviceMethods?: string[];
+}): Promise<string> {
+  const { name, hasSchema = false, dependencies = [], serviceMethods = [] } = args;
+
+  // Validate name
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error("Plugin name must be lowercase alphanumeric with dashes, starting with a letter");
+  }
+
+  const pluginsDir = await getPluginsDir();
+  const pluginDir = join(pluginsDir, name);
+
+  if (existsSync(pluginDir)) {
+    throw new Error(`Plugin '${name}' already exists at ${pluginDir}`);
+  }
+
+  await mkdir(pluginDir, { recursive: true });
+
+  // Generate names
+  const camelName = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const pascalName = camelName.charAt(0).toUpperCase() + camelName.slice(1);
+
+  // Generate service interface
+  const serviceInterface = serviceMethods.length > 0
+    ? serviceMethods.map((m) => `  ${m}(): Promise<void>;`).join("\n")
+    : "  getData(): Promise<string>;";
+
+  // Generate service implementation
+  const serviceImpl = serviceMethods.length > 0
+    ? serviceMethods
+        .map(
+          (m) => `        ${m}: async () => {
+          // TODO: Implement ${m}
+        },`
+        )
+        .join("\n")
+    : `        getData: async () => {
+          return "Hello from ${name} plugin!";
+        },`;
+
+  // Generate dependencies line
+  const depsLine = dependencies.length > 0
+    ? `    dependencies: [${dependencies.map((d) => `"${d}"`).join(", ")}] as const,\n`
+    : "";
+
+  // Generate deps access comments
+  const depsComments = dependencies.length > 0
+    ? dependencies.map((d) => `      // Access ${d}: ctx.deps.${d}`).join("\n") + "\n"
+    : "";
+
+  const pluginContent = `import { createPlugin } from "@donkeylabs/server";
+${hasSchema ? `import type { DB as ${pascalName}Schema } from "./schema";\n` : ""}
+export interface ${pascalName}Service {
+${serviceInterface}
+}
+
+export const ${camelName}Plugin = createPlugin${hasSchema ? `\n  .withSchema<${pascalName}Schema>()` : ""}
+  .define({
+    name: "${name}",
+    version: "1.0.0",
+${depsLine}    service: async (ctx): Promise<${pascalName}Service> => {
+      // Available core services:
+      // - ctx.core.logger.info("message", { data }) - Structured logging
+      // - ctx.core.cache.set("key", value, { ttl: 60 }) - Caching with TTL
+      // - ctx.core.events.emit("event", data) - Pub/sub events
+      // - ctx.core.jobs.enqueue("job", payload) - Background jobs
+      // - ctx.core.cron.schedule("0 * * * *", handler) - Scheduled tasks
+      // - ctx.core.sse.broadcast("channel", data) - Real-time updates
+      // - ctx.core.rateLimiter.limit("key") - Rate limiting
+      //
+      // Error factories (throw these):
+      // - ctx.errors.BadRequest("message") - 400
+      // - ctx.errors.Unauthorized("message") - 401
+      // - ctx.errors.Forbidden("message") - 403
+      // - ctx.errors.NotFound("message") - 404
+      // - ctx.errors.Conflict("message") - 409
+      // - ctx.errors.TooManyRequests("message") - 429
+${depsComments}
+      return {
+${serviceImpl}
+      };
+    },
+  });
+`;
+
+  await writeFile(join(pluginDir, "index.ts"), pluginContent);
+
+  const createdFiles = [`src/plugins/${name}/index.ts`];
+
+  if (hasSchema) {
+    const schemaContent = `// Database schema types for ${name} plugin
+// Run type generation after adding migrations
+
+export interface DB {
+  // Define your table interfaces here
+  // ${name}: {
+  //   id: Generated<number>;
+  //   name: string;
+  //   created_at: Generated<string>;
+  // };
+}
+`;
+    await writeFile(join(pluginDir, "schema.ts"), schemaContent);
+    createdFiles.push(`src/plugins/${name}/schema.ts`);
+
+    await mkdir(join(pluginDir, "migrations"), { recursive: true });
+
+    const migrationContent = `import { Kysely, sql } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  // Create your tables here
+  // await db.schema
+  //   .createTable("${name}")
+  //   .ifNotExists()
+  //   .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+  //   .addColumn("created_at", "text", (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+  //   .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // await db.schema.dropTable("${name}").ifExists().execute();
+}
+`;
+    await writeFile(join(pluginDir, "migrations", "001_initial.ts"), migrationContent);
+    createdFiles.push(`src/plugins/${name}/migrations/001_initial.ts`);
+  }
+
+  return `Created plugin '${name}' with files:\n${createdFiles.map((f) => `  - ${f}`).join("\n")}\n\nNext steps:\n1. Implement your service methods\n${hasSchema ? "2. Define your database schema in migrations\n3. " : "2. "}Run 'donkeylabs generate' to update types`;
+}
+
+async function addMigration(args: {
+  pluginName: string;
+  migrationName: string;
+  upSql?: string;
+  downSql?: string;
+}): Promise<string> {
+  const { pluginName, migrationName, upSql, downSql } = args;
+
+  if (!/^[a-z0-9_]+$/.test(migrationName)) {
+    throw new Error("Migration name must be snake_case (lowercase with underscores)");
+  }
+
+  const pluginsDir = await getPluginsDir();
+  const migrationsDir = join(pluginsDir, pluginName, "migrations");
+
+  if (!existsSync(join(pluginsDir, pluginName))) {
+    throw new Error(`Plugin '${pluginName}' not found`);
+  }
+
+  await mkdir(migrationsDir, { recursive: true });
+
+  // Get next migration number
+  let nextNum = 1;
+  try {
+    const files = await readdir(migrationsDir);
+    const nums = files
+      .map((f) => parseInt(f.split("_")[0] || "", 10))
+      .filter((n) => !isNaN(n));
+    if (nums.length > 0) {
+      nextNum = Math.max(...nums) + 1;
+    }
+  } catch {}
+
+  const filename = `${String(nextNum).padStart(3, "0")}_${migrationName}.ts`;
+
+  const content = `import { Kysely, sql } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  ${upSql || "// Add your migration code here"}
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  ${downSql || "// Add your rollback code here"}
+}
+`;
+
+  await writeFile(join(migrationsDir, filename), content);
+
+  return `Created migration: src/plugins/${pluginName}/migrations/${filename}`;
+}
+
+async function listPlugins(): Promise<string> {
+  const pluginsDir = await getPluginsDir();
+
+  if (!existsSync(pluginsDir)) {
+    return "No plugins directory found. Run 'donkeylabs init' to set up a project.";
+  }
+
+  const entries = await readdir(pluginsDir, { withFileTypes: true });
+  const plugins: string[] = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      const indexPath = join(pluginsDir, entry.name, "index.ts");
+      if (existsSync(indexPath)) {
+        const content = await readFile(indexPath, "utf-8");
+
+        // Extract dependencies
+        const depsMatch = content.match(/dependencies:\s*\[([^\]]*)\]/);
+        const deps = depsMatch?.[1]
+          ? depsMatch[1].match(/"([^"]+)"/g)?.map((d) => d.replace(/"/g, "")) || []
+          : [];
+
+        // Extract service methods
+        const serviceMatch = content.match(/interface\s+\w+Service\s*\{([^}]+)\}/);
+        const methods = serviceMatch?.[1]
+          ? [...serviceMatch[1].matchAll(/(\w+)\s*\(/g)].map((m) => m[1])
+          : [];
+
+        // Check for schema
+        const hasSchema = existsSync(join(pluginsDir, entry.name, "schema.ts"));
+
+        plugins.push(
+          `${entry.name}${hasSchema ? " [has schema]" : ""}\n` +
+            (deps.length > 0 ? `  Dependencies: ${deps.join(", ")}\n` : "") +
+            (methods.length > 0 ? `  Methods: ${methods.join(", ")}` : "")
+        );
+      }
+    }
+  }
+
+  if (plugins.length === 0) {
+    return "No plugins found.";
+  }
+
+  return `Found ${plugins.length} plugin(s):\n\n${plugins.join("\n\n")}`;
+}
+
+async function getProjectInfo(): Promise<string> {
+  const root = await findProjectRoot();
+
+  const info: string[] = [`Project root: ${root}`];
+
+  // Check for config
+  const configPath = join(root, "donkeylabs.config.ts");
+  if (existsSync(configPath)) {
+    info.push("Config: donkeylabs.config.ts found");
+  } else {
+    info.push("Config: Not found (run 'donkeylabs init')");
+  }
+
+  // Check package.json
+  const pkgPath = join(root, "package.json");
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    info.push(`Package: ${pkg.name}@${pkg.version || "0.0.0"}`);
+  }
+
+  // List plugins
+  const pluginsDir = join(root, "src/plugins");
+  if (existsSync(pluginsDir)) {
+    const entries = await readdir(pluginsDir, { withFileTypes: true });
+    const pluginNames = entries
+      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+      .map((e) => e.name);
+    info.push(`Plugins: ${pluginNames.length > 0 ? pluginNames.join(", ") : "none"}`);
+  }
+
+  // Available handlers
+  info.push("\nBuilt-in handlers: typed, raw");
+
+  // Structure reminder
+  info.push(`
+Project structure:
+  src/
+    index.ts          # Server entry point
+    plugins/          # Plugin modules
+      <name>/
+        index.ts      # Plugin definition
+        schema.ts     # DB types (if needed)
+        migrations/   # SQL migrations
+  donkeylabs.config.ts`);
+
+  return info.join("\n");
+}
+
+async function generateTypes(): Promise<string> {
+  const root = await findProjectRoot();
+
+  // Try to run the generate command
+  const proc = Bun.spawn(["bun", "cli/index.ts", "generate"], {
+    cwd: root,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const output = await new Response(proc.stdout).text();
+  const error = await new Response(proc.stderr).text();
+  await proc.exited;
+
+  if (proc.exitCode !== 0) {
+    return `Type generation failed:\n${error || output}`;
+  }
+
+  return `Types generated successfully!\n${output}`;
+}
+
+async function addRoute(args: {
+  routerFile: string;
+  routeName: string;
+  handlerType?: string;
+  inputFields?: { name: string; type: string; optional?: boolean }[];
+  outputFields?: { name: string; type: string }[];
+  description?: string;
+}): Promise<string> {
+  const {
+    routerFile,
+    routeName,
+    handlerType = "typed",
+    inputFields = [],
+    outputFields = [],
+    description,
+  } = args;
+
+  const root = await findProjectRoot();
+  const filePath = join(root, routerFile);
+
+  if (!existsSync(filePath)) {
+    // Provide helpful guidance if file doesn't exist
+    const suggestion = routerFile.includes("routes/")
+      ? `Use 'create_router' tool first to create the router file.`
+      : `Check that the file path is correct. For a new router, use 'create_router' tool.`;
+    throw new Error(`File not found: ${routerFile}\n\n${suggestion}`);
+  }
+
+  const content = await readFile(filePath, "utf-8");
+
+  // Generate Zod schema for input
+  const inputSchema =
+    inputFields.length > 0
+      ? `z.object({\n      ${inputFields
+          .map((f) => `${f.name}: z.${f.type}()${f.optional ? ".optional()" : ""}`)
+          .join(",\n      ")}\n    })`
+      : "z.object({})";
+
+  // Generate Zod schema for output
+  const outputSchema =
+    outputFields.length > 0
+      ? `z.object({\n      ${outputFields.map((f) => `${f.name}: z.${f.type}()`).join(",\n      ")}\n    })`
+      : "z.object({ success: z.boolean() })";
+
+  // Generate route code
+  const routeCode =
+    handlerType === "typed"
+      ? `
+  .route("${routeName}").typed({${description ? `\n    // ${description}` : ""}
+    input: ${inputSchema},
+    output: ${outputSchema},
+    handle: async (input, ctx) => {
+      // TODO: Implement ${routeName}
+      return { success: true };
+    },
+  })`
+      : `
+  .route("${routeName}").raw({${description ? `\n    // ${description}` : ""}
+    handle: async (req, ctx) => {
+      // TODO: Implement ${routeName}
+      return new Response("OK");
+    },
+  })`;
+
+  // Find where to insert (before server.use or at end of router chain)
+  const insertPoint = content.lastIndexOf("server.use(");
+  if (insertPoint === -1) {
+    throw new Error("Could not find insertion point. Make sure the file has a router.");
+  }
+
+  const newContent = content.slice(0, insertPoint) + routeCode + "\n\n" + content.slice(insertPoint);
+
+  await writeFile(filePath, newContent);
+
+  return `Added route '${routeName}' to ${routerFile}\n\nRemember to implement the handler logic!`;
+}
+
+async function addServiceMethod(args: {
+  pluginName: string;
+  methodName: string;
+  params?: { name: string; type: string }[];
+  returnType?: string;
+  implementation?: string;
+}): Promise<string> {
+  const {
+    pluginName,
+    methodName,
+    params = [],
+    returnType = "Promise<void>",
+    implementation,
+  } = args;
+
+  const pluginsDir = await getPluginsDir();
+  const indexPath = join(pluginsDir, pluginName, "index.ts");
+
+  if (!existsSync(indexPath)) {
+    throw new Error(`Plugin '${pluginName}' not found`);
+  }
+
+  let content = await readFile(indexPath, "utf-8");
+
+  // Generate param string
+  const paramStr = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+
+  // Add to interface
+  const interfaceMatch = content.match(/(interface\s+\w+Service\s*\{)([^}]*)(})/);
+  if (!interfaceMatch) {
+    throw new Error("Could not find service interface in plugin");
+  }
+
+  const newInterfaceMethod = `\n  ${methodName}(${paramStr}): ${returnType};`;
+  content = content.replace(
+    interfaceMatch[0],
+    interfaceMatch[1] + interfaceMatch[2] + newInterfaceMethod + "\n" + interfaceMatch[3]
+  );
+
+  // Add to implementation
+  const returnMatch = content.match(/(return\s*\{)([^}]*)(};?\s*},?\s*}\s*\);?\s*$)/s);
+  if (!returnMatch) {
+    throw new Error("Could not find service implementation in plugin");
+  }
+
+  const impl = implementation || `// TODO: Implement ${methodName}`;
+  const newImplMethod = `\n        ${methodName}: async (${paramStr}) => {\n          ${impl}\n        },`;
+  content = content.replace(
+    returnMatch[0],
+    returnMatch[1] + returnMatch[2] + newImplMethod + "\n      " + returnMatch[3]
+  );
+
+  await writeFile(indexPath, content);
+
+  return `Added method '${methodName}' to ${pluginName} plugin`;
+}
+
+async function createRouter(args: {
+  fileName: string;
+  namespace: string;
+  initialRoutes?: string[];
+}): Promise<string> {
+  const { fileName, namespace, initialRoutes = [] } = args;
+
+  const root = await findProjectRoot();
+  const routesDir = join(root, "src/routes");
+  await mkdir(routesDir, { recursive: true });
+
+  const filePath = join(routesDir, `${fileName}.ts`);
+
+  if (existsSync(filePath)) {
+    throw new Error(`Router file already exists: src/routes/${fileName}.ts`);
+  }
+
+  // Generate initial routes
+  const routeDefinitions = initialRoutes.length > 0
+    ? initialRoutes.map((route) => `
+  .route("${route}").typed({
+    input: z.object({}),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      // TODO: Implement ${route}
+      return { success: true };
+    },
+  })`).join("")
+    : `
+  .route("hello").typed({
+    input: z.object({ name: z.string().optional() }),
+    output: z.object({ message: z.string() }),
+    handle: async (input) => {
+      return { message: \`Hello from ${namespace}!\` };
+    },
+  })`;
+
+  const content = `import { createRouter } from "@donkeylabs/server";
+import { z } from "zod";
+
+export const ${fileName}Router = createRouter("${namespace}")${routeDefinitions};
+`;
+
+  await writeFile(filePath, content);
+
+  return `Created router at src/routes/${fileName}.ts
+
+To use this router, add to your src/index.ts:
+
+  import { ${fileName}Router } from "./routes/${fileName}";
+  // ... after server.registerPlugin calls
+  server.use(${fileName}Router);`;
+}
+
+async function validateProject(): Promise<string> {
+  const root = await findProjectRoot();
+  const issues: string[] = [];
+  const warnings: string[] = [];
+
+  // Check for config file
+  if (!existsSync(join(root, "donkeylabs.config.ts"))) {
+    issues.push("Missing donkeylabs.config.ts - run 'donkeylabs init'");
+  }
+
+  // Check for package.json
+  const pkgPath = join(root, "package.json");
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // Check required dependencies
+    if (!deps["@donkeylabs/server"]) {
+      issues.push("Missing dependency: @donkeylabs/server");
+    }
+    if (!deps["kysely"]) {
+      issues.push("Missing dependency: kysely");
+    }
+    if (!deps["zod"]) {
+      issues.push("Missing dependency: zod");
+    }
+  } else {
+    issues.push("Missing package.json");
+  }
+
+  // Check for src/index.ts
+  const indexPath = join(root, "src/index.ts");
+  if (existsSync(indexPath)) {
+    const indexContent = await readFile(indexPath, "utf-8");
+
+    // Check for DummyDriver (bad)
+    if (indexContent.includes("DummyDriver")) {
+      warnings.push("src/index.ts uses DummyDriver - this is a placeholder, not a real database");
+    }
+
+    // Check for AppServer
+    if (!indexContent.includes("AppServer")) {
+      warnings.push("src/index.ts doesn't import AppServer");
+    }
+  } else {
+    issues.push("Missing src/index.ts - run 'donkeylabs init'");
+  }
+
+  // Check plugins directory
+  const pluginsDir = join(root, "src/plugins");
+  if (existsSync(pluginsDir)) {
+    const entries = await readdir(pluginsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const pluginIndex = join(pluginsDir, entry.name, "index.ts");
+
+        if (!existsSync(pluginIndex)) {
+          issues.push(`Plugin '${entry.name}' is missing index.ts`);
+          continue;
+        }
+
+        const content = await readFile(pluginIndex, "utf-8");
+
+        // Check for proper export
+        if (!content.includes("createPlugin")) {
+          warnings.push(`Plugin '${entry.name}' doesn't use createPlugin`);
+        }
+
+        // Check if plugin is registered in index.ts
+        if (existsSync(indexPath)) {
+          const indexContent = await readFile(indexPath, "utf-8");
+          if (!indexContent.includes(`${entry.name}Plugin`) && !indexContent.includes(`'./plugins/${entry.name}'`)) {
+            warnings.push(`Plugin '${entry.name}' exists but may not be registered in src/index.ts`);
+          }
+        }
+      }
+    }
+  }
+
+  // Check for generated types
+  const genDir = join(root, ".@donkeylabs/server");
+  if (!existsSync(genDir) || !existsSync(join(genDir, "registry.d.ts"))) {
+    warnings.push("Generated types not found - run 'donkeylabs generate'");
+  }
+
+  // Format output
+  if (issues.length === 0 && warnings.length === 0) {
+    return "Project validation passed. No issues found.";
+  }
+
+  let output = "";
+
+  if (issues.length > 0) {
+    output += `ERRORS (${issues.length}):\n${issues.map((i) => `  - ${i}`).join("\n")}\n\n`;
+  }
+
+  if (warnings.length > 0) {
+    output += `WARNINGS (${warnings.length}):\n${warnings.map((w) => `  - ${w}`).join("\n")}`;
+  }
+
+  return output;
+}
+
+async function registerPlugin(args: {
+  pluginName: string;
+  configOptions?: Record<string, any>;
+}): Promise<string> {
+  const { pluginName, configOptions } = args;
+
+  const root = await findProjectRoot();
+  const pluginsDir = join(root, "src/plugins");
+  const indexPath = join(root, "src/index.ts");
+
+  // Verify plugin exists
+  const pluginDir = join(pluginsDir, pluginName);
+  if (!existsSync(pluginDir)) {
+    throw new Error(`Plugin '${pluginName}' not found in src/plugins/`);
+  }
+
+  // Read plugin to get export name
+  const pluginIndexPath = join(pluginDir, "index.ts");
+  const pluginContent = await readFile(pluginIndexPath, "utf-8");
+  const exportMatch = pluginContent.match(/export\s+const\s+(\w+Plugin)\s*=/);
+  const exportName = exportMatch?.[1];
+
+  if (!exportName) {
+    throw new Error(`Could not find plugin export in ${pluginName}/index.ts`);
+  }
+
+  // Read index.ts
+  if (!existsSync(indexPath)) {
+    throw new Error("src/index.ts not found");
+  }
+
+  let content = await readFile(indexPath, "utf-8");
+
+  // Check if already imported
+  if (content.includes(`from "./plugins/${pluginName}"`) || content.includes(`from './plugins/${pluginName}'`)) {
+    return `Plugin '${pluginName}' is already imported in src/index.ts`;
+  }
+
+  // Add import after other plugin imports or after @donkeylabs/server import
+  const importLine = `import { ${exportName} } from "./plugins/${pluginName}";\n`;
+
+  // Find a good place to add the import
+  const lastPluginImport = content.lastIndexOf('from "./plugins/');
+  const serverImport = content.indexOf('from "@donkeylabs/server"');
+
+  if (lastPluginImport !== -1) {
+    // Add after last plugin import
+    const lineEnd = content.indexOf("\n", lastPluginImport);
+    content = content.slice(0, lineEnd + 1) + importLine + content.slice(lineEnd + 1);
+  } else if (serverImport !== -1) {
+    // Add after server import
+    const lineEnd = content.indexOf("\n", serverImport);
+    content = content.slice(0, lineEnd + 1) + importLine + content.slice(lineEnd + 1);
+  } else {
+    // Add at top
+    content = importLine + content;
+  }
+
+  // Add registerPlugin call
+  const configStr = configOptions ? JSON.stringify(configOptions, null, 2) : "";
+  const registerCall = configStr
+    ? `server.registerPlugin(${exportName}(${configStr}));\n`
+    : `server.registerPlugin(${exportName});\n`;
+
+  // Find where to add registration (after other registerPlugin calls or after new AppServer)
+  const lastRegister = content.lastIndexOf("server.registerPlugin(");
+  const serverCreate = content.indexOf("new AppServer(");
+
+  if (lastRegister !== -1) {
+    const lineEnd = content.indexOf("\n", lastRegister);
+    content = content.slice(0, lineEnd + 1) + registerCall + content.slice(lineEnd + 1);
+  } else if (serverCreate !== -1) {
+    // Find the end of the AppServer construction (closing brace and semicolon)
+    let braceCount = 0;
+    let pos = serverCreate;
+    while (pos < content.length) {
+      if (content[pos] === "{") braceCount++;
+      if (content[pos] === "}") braceCount--;
+      if (braceCount === 0 && content[pos] === ";") {
+        content = content.slice(0, pos + 1) + "\n\n" + registerCall + content.slice(pos + 1);
+        break;
+      }
+      pos++;
+    }
+  } else {
+    throw new Error("Could not find place to add registerPlugin call");
+  }
+
+  await writeFile(indexPath, content);
+
+  return `Registered plugin '${pluginName}' in src/index.ts\n\nAdded:\n  - import { ${exportName} } from "./plugins/${pluginName}"\n  - server.registerPlugin(${exportName}${configStr ? "(...)" : ""})`;
+}
+
+async function runMigrations(args: {
+  pluginName?: string;
+  direction?: string;
+}): Promise<string> {
+  const { pluginName, direction = "up" } = args;
+
+  const root = await findProjectRoot();
+  const pluginsDir = join(root, "src/plugins");
+
+  if (!existsSync(pluginsDir)) {
+    throw new Error("No plugins directory found");
+  }
+
+  const results: string[] = [];
+
+  // Get list of plugins to migrate
+  const pluginsToMigrate: string[] = [];
+  if (pluginName) {
+    if (!existsSync(join(pluginsDir, pluginName))) {
+      throw new Error(`Plugin '${pluginName}' not found`);
+    }
+    pluginsToMigrate.push(pluginName);
+  } else {
+    const entries = await readdir(pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        pluginsToMigrate.push(entry.name);
+      }
+    }
+  }
+
+  for (const plugin of pluginsToMigrate) {
+    const migrationsDir = join(pluginsDir, plugin, "migrations");
+
+    if (!existsSync(migrationsDir)) {
+      results.push(`${plugin}: No migrations directory`);
+      continue;
+    }
+
+    const files = await readdir(migrationsDir);
+    const migrationFiles = files
+      .filter((f) => f.endsWith(".ts") && !f.startsWith("."))
+      .sort();
+
+    if (migrationFiles.length === 0) {
+      results.push(`${plugin}: No migrations found`);
+      continue;
+    }
+
+    // If going down, reverse the order
+    if (direction === "down") {
+      migrationFiles.reverse();
+    }
+
+    results.push(`${plugin}: Found ${migrationFiles.length} migration(s)`);
+
+    for (const file of migrationFiles) {
+      const migrationPath = join(migrationsDir, file);
+      try {
+        const migration = await import(migrationPath);
+
+        if (direction === "up" && typeof migration.up === "function") {
+          results.push(`  - ${file}: Would run 'up' migration`);
+        } else if (direction === "down" && typeof migration.down === "function") {
+          results.push(`  - ${file}: Would run 'down' migration`);
+        } else {
+          results.push(`  - ${file}: No '${direction}' function found`);
+        }
+      } catch (err: any) {
+        results.push(`  - ${file}: Error loading - ${err.message}`);
+      }
+    }
+  }
+
+  results.push("");
+  results.push("Note: This tool shows what migrations are available.");
+  results.push("To actually run migrations, execute them in your server code:");
+  results.push("  await migration.up(db);  // or migration.down(db)");
+
+  return results.join("\n");
+}
+
+async function setupDatabase(args: {
+  dbPath?: string;
+}): Promise<string> {
+  const { dbPath = "app.db" } = args;
+  const root = await findProjectRoot();
+  const fullPath = join(root, dbPath);
+
+  const results: string[] = [];
+
+  // Check if src/db.ts exists
+  const dbSetupPath = join(root, "src/db.ts");
+  if (!existsSync(dbSetupPath)) {
+    results.push("WARNING: src/db.ts not found");
+    results.push("Run 'donkeylabs init' with SQLite enabled to create database setup.");
+    return results.join("\n");
+  }
+
+  results.push(`Database setup file: src/db.ts`);
+
+  // Check if database file exists
+  if (existsSync(fullPath)) {
+    results.push(`Database file exists: ${dbPath}`);
+
+    // Try to get some info about the database
+    try {
+      const { Database } = await import("bun:sqlite");
+      const db = new Database(fullPath, { readonly: true });
+      const tables = db.query("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all() as { name: string }[];
+      db.close();
+
+      if (tables.length > 0) {
+        results.push(`Tables: ${tables.map((t) => t.name).join(", ")}`);
+      } else {
+        results.push("No tables yet - run migrations to create them");
+      }
+    } catch (err: any) {
+      results.push(`Could not inspect database: ${err.message}`);
+    }
+  } else {
+    results.push(`Database file will be created at: ${dbPath}`);
+    results.push("The database is created automatically when your server starts.");
+  }
+
+  results.push("");
+  results.push("Database setup looks good!");
+
+  return results.join("\n");
+}
+
+async function listRoutes(args: { namespace?: string }): Promise<string> {
+  const root = await findProjectRoot();
+  const routesDir = join(root, "src/routes");
+
+  if (!existsSync(routesDir)) {
+    return "No routes directory found. Routes should be in src/routes/<namespace>/<route>/handler.ts";
+  }
+
+  const results: string[] = ["Routes found:\n"];
+  let routeCount = 0;
+
+  const namespaces = await readdir(routesDir, { withFileTypes: true });
+
+  for (const ns of namespaces) {
+    if (!ns.isDirectory() || ns.name.startsWith(".")) continue;
+    if (args.namespace && ns.name !== args.namespace) continue;
+
+    const nsDir = join(routesDir, ns.name);
+    const routeDirs = await readdir(nsDir, { withFileTypes: true });
+
+    results.push(`${ns.name}/`);
+
+    for (const routeDir of routeDirs) {
+      if (!routeDir.isDirectory() || routeDir.name.startsWith(".")) continue;
+
+      const handlerPath = join(nsDir, routeDir.name, "handler.ts");
+      const testPath = join(nsDir, routeDir.name, "test.ts");
+
+      if (!existsSync(handlerPath)) continue;
+
+      const content = await readFile(handlerPath, "utf-8");
+      const handlerType = content.includes(".raw(") ? "raw" : "typed";
+      const hasTest = existsSync(testPath);
+
+      results.push(`  ${routeDir.name}/ (${handlerType})${hasTest ? " [tested]" : ""}`);
+      routeCount++;
+    }
+  }
+
+  if (routeCount === 0) {
+    return "No routes found. Use 'add_route_file' to create routes.";
+  }
+
+  results.push(`\nTotal: ${routeCount} route(s)`);
+  return results.join("\n");
+}
+
+async function addRouteFile(args: {
+  namespace: string;
+  routeName: string;
+  handlerType?: string;
+  inputFields?: { name: string; type: string; optional?: boolean }[];
+  outputFields?: { name: string; type: string }[];
+  description?: string;
+  createTest?: boolean;
+}): Promise<string> {
+  const {
+    namespace,
+    routeName,
+    handlerType = "typed",
+    inputFields = [],
+    outputFields = [],
+    description,
+    createTest = true,
+  } = args;
+
+  const root = await findProjectRoot();
+  const routeDir = join(root, "src/routes", namespace, routeName);
+
+  if (existsSync(routeDir)) {
+    throw new Error(`Route already exists: src/routes/${namespace}/${routeName}/`);
+  }
+
+  await mkdir(routeDir, { recursive: true });
+
+  // Generate input schema
+  const inputSchema = inputFields.length > 0
+    ? `z.object({\n    ${inputFields.map((f) => `${f.name}: z.${f.type}()${f.optional ? ".optional()" : ""}`).join(",\n    ")}\n  })`
+    : "z.object({})";
+
+  // Generate output schema
+  const outputSchema = outputFields.length > 0
+    ? `z.object({\n    ${outputFields.map((f) => `${f.name}: z.${f.type}()`).join(",\n    ")}\n  })`
+    : "z.object({ success: z.boolean() })";
+
+  // Generate handler file
+  const handlerContent = handlerType === "typed"
+    ? `/**
+ * ${namespace}.${routeName}
+ * ${description || "TODO: Add description"}
+ */
+import { z } from "zod";
+import type { GlobalContext } from "../../../.@donkeylabs/server/context";
+
+export const input = ${inputSchema};
+export const output = ${outputSchema};
+
+export async function handler(
+  data: z.infer<typeof input>,
+  ctx: GlobalContext
+): Promise<z.infer<typeof output>> {
+  // Available in ctx:
+  // - ctx.db: Database queries (ctx.db.selectFrom("table")...)
+  // - ctx.plugins: Plugin services (ctx.plugins.auth, ctx.plugins.users, etc.)
+  // - ctx.core.logger: Logging (ctx.core.logger.info("message", { data }))
+  // - ctx.core.cache: Caching (ctx.core.cache.get("key"), ctx.core.cache.set("key", value))
+  // - ctx.errors: Error factories (throw ctx.errors.NotFound("User not found"))
+  // - ctx.user: Authenticated user (if auth middleware applied)
+
+  // TODO: Implement handler logic
+  return { success: true };
+}
+`
+    : `/**
+ * ${namespace}.${routeName}
+ * ${description || "TODO: Add description"}
+ */
+import type { GlobalContext } from "../../../.@donkeylabs/server/context";
+
+export async function handler(
+  req: Request,
+  ctx: GlobalContext
+): Promise<Response> {
+  // Available in ctx:
+  // - ctx.db: Database queries
+  // - ctx.plugins: Plugin services (ctx.plugins.auth, etc.)
+  // - ctx.core.logger/cache/events/jobs/cron/sse/rateLimiter
+  // - ctx.errors: Error factories
+  // - ctx.user: Authenticated user (if auth middleware applied)
+
+  // TODO: Implement handler logic
+  return new Response("OK");
+}
+`;
+
+  await writeFile(join(routeDir, "handler.ts"), handlerContent);
+
+  const createdFiles = [`src/routes/${namespace}/${routeName}/handler.ts`];
+
+  // Generate test file
+  if (createTest) {
+    const testContent = handlerType === "typed"
+      ? `import { describe, test, expect } from "bun:test";
+import { handler, input, output } from "./handler";
+
+describe("${namespace}.${routeName}", () => {
+  test("should return success", async () => {
+    // TODO: Create mock context
+    const mockCtx = {} as any;
+    const result = await handler({}, mockCtx);
+    expect(result.success).toBe(true);
+  });
+
+  test("should validate input", () => {
+    expect(() => input.parse({})).not.toThrow();
+  });
+});
+`
+      : `import { describe, test, expect } from "bun:test";
+import { handler } from "./handler";
+
+describe("${namespace}.${routeName}", () => {
+  test("should return OK", async () => {
+    const mockCtx = {} as any;
+    const req = new Request("http://localhost/${namespace}.${routeName}");
+    const response = await handler(req, mockCtx);
+    expect(response.status).toBe(200);
+  });
+});
+`;
+
+    await writeFile(join(routeDir, "test.ts"), testContent);
+    createdFiles.push(`src/routes/${namespace}/${routeName}/test.ts`);
+  }
+
+  return `Created route ${namespace}.${routeName}:\n${createdFiles.map((f) => `  - ${f}`).join("\n")}\n\nRun 'donkeylabs generate' to update types.`;
+}
+
+async function createModel(args: {
+  name: string;
+  methods?: { name: string; params: string; returnType: string }[];
+}): Promise<string> {
+  const { name, methods = [] } = args;
+
+  const root = await findProjectRoot();
+  const modelsDir = join(root, "src/models");
+  await mkdir(modelsDir, { recursive: true });
+
+  const filePath = join(modelsDir, `${name}.ts`);
+
+  if (existsSync(filePath)) {
+    throw new Error(`Model already exists: src/models/${name}.ts`);
+  }
+
+  // Generate method stubs
+  const methodStubs = methods.length > 0
+    ? methods.map((m) => `
+  async ${m.name}(${m.params}): ${m.returnType} {
+    // TODO: Implement ${m.name}
+    throw new Error("Not implemented");
+  }`).join("\n")
+    : `
+  async getData(): Promise<any> {
+    // TODO: Implement getData
+    return null;
+  }`;
+
+  const content = `/**
+ * ${name}
+ *
+ * Business logic model with dependency injection for testability.
+ */
+import type { GlobalContext } from "../.@donkeylabs/server/context";
+
+export class ${name} {
+  constructor(private ctx: GlobalContext) {}
+${methodStubs}
+}
+
+/**
+ * Factory function for creating ${name} instances.
+ * Use this in route handlers for clean dependency injection.
+ */
+export function create${name}(ctx: GlobalContext): ${name} {
+  return new ${name}(ctx);
+}
+`;
+
+  await writeFile(filePath, content);
+
+  return `Created model: src/models/${name}.ts
+
+Usage in route handler:
+  import { create${name} } from "../../models/${name}";
+
+  export async function handler(data, ctx) {
+    const model = create${name}(ctx);
+    return model.getData();
+  }`;
+}
+
+async function addUnitTest(args: {
+  targetFile: string;
+  testCases?: { name: string; method: string }[];
+}): Promise<string> {
+  const { targetFile, testCases = [] } = args;
+
+  const root = await findProjectRoot();
+  const fullPath = join(root, targetFile);
+
+  if (!existsSync(fullPath)) {
+    throw new Error(`File not found: ${targetFile}`);
+  }
+
+  // Determine test file path (sibling .test.ts file)
+  const testPath = targetFile.replace(/\.ts$/, ".test.ts");
+  const fullTestPath = join(root, testPath);
+
+  // Read target file to extract exports
+  const content = await readFile(fullPath, "utf-8");
+  const classMatch = content.match(/export\s+class\s+(\w+)/);
+  const functionMatch = content.match(/export\s+function\s+(\w+)/);
+
+  const exportName = classMatch?.[1] || functionMatch?.[1] || "module";
+  const isClass = !!classMatch;
+
+  // Generate test cases
+  const testCaseCode = testCases.length > 0
+    ? testCases.map((tc) => `
+  test("${tc.name}", async () => {
+    ${isClass ? `// const instance = new ${exportName}(mockCtx);` : ""}
+    // const result = ${isClass ? "instance" : exportName}.${tc.method}();
+    // expect(result).toBeDefined();
+    expect(true).toBe(true); // TODO: Implement test
+  });`).join("\n")
+    : `
+  test("should work correctly", async () => {
+    // TODO: Implement test
+    expect(true).toBe(true);
+  });`;
+
+  const testContent = `import { describe, test, expect, mock } from "bun:test";
+import { ${exportName} } from "./${targetFile.split("/").pop()?.replace(/\.ts$/, "")}";
+
+describe("${exportName}", () => {
+  // Mock GlobalContext for unit testing
+  const mockCtx = {
+    db: {} as any,
+    plugins: {} as any,
+    core: {} as any,
+    errors: {} as any,
+    ip: "127.0.0.1",
+  };
+${testCaseCode}
+});
+`;
+
+  await writeFile(fullTestPath, testContent);
+
+  return `Created unit test: ${testPath}
+
+Run tests with: bun test ${testPath}`;
+}
+
+async function addIntegrationTest(args: {
+  namespace: string;
+  routeName: string;
+  testCases?: { name: string; input?: any; expectedStatus?: number }[];
+  plugins?: string[];
+}): Promise<string> {
+  const { namespace, routeName, testCases = [], plugins = [] } = args;
+
+  const root = await findProjectRoot();
+  const testDir = join(root, "test/integration");
+  await mkdir(testDir, { recursive: true });
+
+  const testPath = join(testDir, `${namespace}.${routeName}.test.ts`);
+
+  // Generate plugin imports
+  const pluginImports = plugins.length > 0
+    ? plugins.map((p) => `import { ${p}Plugin } from "../src/plugins/${p}";`).join("\n")
+    : "// Import plugins as needed";
+
+  const pluginList = plugins.length > 0
+    ? plugins.map((p) => `${p}Plugin`).join(", ")
+    : "/* plugins */";
+
+  // Generate test cases
+  const testCaseCode = testCases.length > 0
+    ? testCases.map((tc) => `
+  test("${tc.name}", async () => {
+    const response = await harness.request("${namespace}.${routeName}", ${JSON.stringify(tc.input || {})});
+    expect(response.status).toBe(${tc.expectedStatus || 200});
+  });`).join("\n")
+    : `
+  test("should handle request successfully", async () => {
+    const response = await harness.request("${namespace}.${routeName}", {});
+    expect(response.status).toBe(200);
+  });
+
+  test("should handle invalid input", async () => {
+    // TODO: Test with invalid input
+    expect(true).toBe(true);
+  });`;
+
+  const content = `import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { createTestHarness } from "@donkeylabs/server/harness";
+${pluginImports}
+
+describe("${namespace}.${routeName} (Integration)", () => {
+  let harness: Awaited<ReturnType<typeof createTestHarness>>;
+
+  beforeAll(async () => {
+    harness = await createTestHarness(${pluginList});
+    await harness.manager.initialize();
+  });
+
+  afterAll(async () => {
+    // Cleanup if needed
+  });
+${testCaseCode}
+});
+`;
+
+  await writeFile(testPath, content);
+
+  return `Created integration test: test/integration/${namespace}.${routeName}.test.ts
+
+Run tests with: bun test test/integration/${namespace}.${routeName}.test.ts`;
+}
+
+async function generateClientTool(args: {
+  output?: string;
+  baseUrl?: string;
+}): Promise<string> {
+  const { output = "src/client/api.ts", baseUrl = "" } = args;
+
+  const root = await findProjectRoot();
+  const routesDir = join(root, "src/routes");
+  const outputPath = join(root, output);
+
+  // Collect routes
+  interface RouteInfo {
+    namespace: string;
+    name: string;
+    handlerType: "typed" | "raw";
+  }
+
+  const routes: RouteInfo[] = [];
+
+  if (existsSync(routesDir)) {
+    const namespaces = await readdir(routesDir, { withFileTypes: true });
+
+    for (const ns of namespaces) {
+      if (!ns.isDirectory() || ns.name.startsWith(".")) continue;
+
+      const nsDir = join(routesDir, ns.name);
+      const routeDirs = await readdir(nsDir, { withFileTypes: true });
+
+      for (const routeDir of routeDirs) {
+        if (!routeDir.isDirectory() || routeDir.name.startsWith(".")) continue;
+
+        const handlerPath = join(nsDir, routeDir.name, "handler.ts");
+        if (!existsSync(handlerPath)) continue;
+
+        const content = await readFile(handlerPath, "utf-8");
+        const handlerType = content.includes(".raw(") || content.includes("req: Request") ? "raw" : "typed";
+
+        routes.push({
+          namespace: ns.name,
+          name: routeDir.name,
+          handlerType,
+        });
+      }
+    }
+  }
+
+  if (routes.length === 0) {
+    return "No routes found. Create routes first with 'add_route_file' tool.";
+  }
+
+  // Group by namespace
+  const byNamespace = new Map<string, RouteInfo[]>();
+  for (const route of routes) {
+    if (!byNamespace.has(route.namespace)) {
+      byNamespace.set(route.namespace, []);
+    }
+    byNamespace.get(route.namespace)!.push(route);
+  }
+
+  // Generate namespace methods
+  const namespaceBlocks: string[] = [];
+
+  for (const [namespace, nsRoutes] of byNamespace) {
+    const methods = nsRoutes.map((r) => {
+      const methodName = r.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      if (r.handlerType === "typed") {
+        return `    /** Call ${namespace}.${r.name} */
+    ${methodName}: <TInput, TOutput>(input: TInput): Promise<TOutput> =>
+      this.request("${namespace}.${r.name}", input)`;
+      } else {
+        return `    /** Call ${namespace}.${r.name} (raw) */
+    ${methodName}: (init?: RequestInit): Promise<Response> =>
+      this.rawRequest("${namespace}.${r.name}", init)`;
+      }
+    });
+
+    namespaceBlocks.push(`  ${namespace} = {\n${methods.join(",\n\n")}\n  };`);
+  }
+
+  const content = `/**
+ * Auto-generated API Client
+ * Generated by: donkeylabs generate_client
+ *
+ * Usage:
+ *   import { api } from "./client/api";
+ *   const result = await api.users.create({ email: "test@example.com" });
+ *
+ * DO NOT use raw fetch() - use this typed client instead!
+ */
+
+export interface ApiClientOptions {
+  baseUrl: string;
+  credentials?: RequestCredentials;
+  headers?: HeadersInit;
+}
+
+export class ApiClient {
+  constructor(private options: ApiClientOptions) {}
+
+  private async request<TInput, TOutput>(
+    route: string,
+    input: TInput
+  ): Promise<TOutput> {
+    const response = await fetch(\`\${this.options.baseUrl}/\${route}\`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.options.headers,
+      },
+      credentials: this.options.credentials || "include",
+      body: JSON.stringify(input),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      throw new ApiError(response.status, error.message || "Request failed", error);
+    }
+
+    return response.json();
+  }
+
+  private async rawRequest(route: string, init?: RequestInit): Promise<Response> {
+    return fetch(\`\${this.options.baseUrl}/\${route}\`, {
+      credentials: this.options.credentials || "include",
+      ...init,
+    });
+  }
+
+${namespaceBlocks.join("\n\n")}
+}
+
+export class ApiError extends Error {
+  constructor(
+    public status: number,
+    message: string,
+    public data?: any
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+/**
+ * Create API client instance
+ *
+ * @example
+ * const api = createApiClient({ baseUrl: "http://localhost:3000" });
+ * const user = await api.users.create({ email: "test@example.com" });
+ */
+export function createApiClient(options: ApiClientOptions): ApiClient {
+  return new ApiClient(options);
+}
+
+${baseUrl ? `// Pre-configured client instance\nexport const api = createApiClient({ baseUrl: "${baseUrl}" });\n` : "// Configure and export: export const api = createApiClient({ baseUrl: 'http://localhost:3000' });"}
+`;
+
+  await mkdir(join(root, "src/client"), { recursive: true });
+  await writeFile(outputPath, content);
+
+  return `Generated API client: ${output}
+
+Routes included:
+${routes.map((r) => `  - ${r.namespace}.${r.name} (${r.handlerType})`).join("\n")}
+
+Usage:
+  import { createApiClient } from "./${output.replace(/\.ts$/, "")}";
+
+  const api = createApiClient({ baseUrl: "http://localhost:3000" });
+
+  // Type-safe API calls (NOT raw fetch!)
+  const result = await api.${routes[0]?.namespace || "namespace"}.${routes[0]?.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase()) || "method"}({ ... });`;
+}
+
+async function addMiddleware(args: {
+  pluginName: string;
+  middlewareName: string;
+  description?: string;
+  modifiesContext?: boolean;
+}): Promise<string> {
+  const { pluginName, middlewareName, description, modifiesContext = false } = args;
+
+  const pluginsDir = await getPluginsDir();
+  const indexPath = join(pluginsDir, pluginName, "index.ts");
+
+  if (!existsSync(indexPath)) {
+    throw new Error(`Plugin '${pluginName}' not found`);
+  }
+
+  let content = await readFile(indexPath, "utf-8");
+
+  // Check if middleware already exists
+  if (content.includes(`${middlewareName}:`)) {
+    throw new Error(`Middleware '${middlewareName}' already exists in plugin`);
+  }
+
+  // Create middleware definition
+  const middlewareCode = `
+// ${description || `${middlewareName} middleware`}
+export const ${middlewareName}Middleware = createMiddleware({
+  name: "${middlewareName}",
+  handler: async (ctx, next) => {
+    // TODO: Implement middleware logic
+    ${modifiesContext ? "// Example: ctx.user = await validateToken(ctx);" : ""}
+    return next();
+  },
+});
+`;
+
+  // Check if createMiddleware is imported
+  if (!content.includes("createMiddleware")) {
+    content = content.replace(
+      /from "@donkeylabs\/server"/,
+      'from "@donkeylabs/server";\nimport { createMiddleware } from "@donkeylabs/server"'
+    );
+  }
+
+  // Add to plugin definition's middleware object
+  const middlewareMatch = content.match(/middleware:\s*\{([^}]*)\}/);
+  if (middlewareMatch) {
+    // Add to existing middleware object
+    const insertPos = middlewareMatch.index! + middlewareMatch[0].length - 1;
+    const existingMiddleware = middlewareMatch[1].trim();
+    const separator = existingMiddleware ? ",\n      " : "\n      ";
+    content = content.slice(0, insertPos) + separator + `${middlewareName}: ${middlewareName}Middleware` + content.slice(insertPos);
+  } else {
+    // Add middleware object to plugin definition
+    const defineMatch = content.match(/\.define\s*\(\s*\{/);
+    if (defineMatch) {
+      const insertPos = defineMatch.index! + defineMatch[0].length;
+      content = content.slice(0, insertPos) + `\n    middleware: {\n      ${middlewareName}: ${middlewareName}Middleware,\n    },` + content.slice(insertPos);
+    }
+  }
+
+  // Add middleware definition before the plugin export
+  const exportMatch = content.match(/export const \w+Plugin/);
+  if (exportMatch) {
+    content = content.slice(0, exportMatch.index) + middlewareCode + "\n" + content.slice(exportMatch.index);
+  }
+
+  await writeFile(indexPath, content);
+
+  return `Added middleware '${middlewareName}' to ${pluginName} plugin.
+
+Usage in routes:
+  router.route("protected").${middlewareName}().typed({ ... })
+
+Remember to run 'donkeylabs generate' to update types!`;
+}
+
+async function addCustomHandler(args: {
+  pluginName: string;
+  handlerName: string;
+  description?: string;
+  signatureParams?: string;
+  signatureReturn?: string;
+}): Promise<string> {
+  const {
+    pluginName,
+    handlerName,
+    description,
+    signatureParams = "data: any, ctx: ServerContext",
+    signatureReturn = "Promise<any>",
+  } = args;
+
+  const pluginsDir = await getPluginsDir();
+  const indexPath = join(pluginsDir, pluginName, "index.ts");
+
+  if (!existsSync(indexPath)) {
+    throw new Error(`Plugin '${pluginName}' not found`);
+  }
+
+  let content = await readFile(indexPath, "utf-8");
+
+  // Check if handler already exists
+  if (content.includes(`${handlerName}:`)) {
+    throw new Error(`Handler '${handlerName}' already exists in plugin`);
+  }
+
+  // Create handler type and definition
+  const handlerCode = `
+// ${description || `${handlerName} handler`}
+type ${handlerName.charAt(0).toUpperCase() + handlerName.slice(1)}Fn = (${signatureParams}) => ${signatureReturn};
+
+export const ${handlerName.charAt(0).toUpperCase() + handlerName.slice(1)}Handler = createHandler<${handlerName.charAt(0).toUpperCase() + handlerName.slice(1)}Fn>(
+  async (req, def, handle, ctx) => {
+    // TODO: Implement handler wrapper
+    const data = await req.json();
+    const result = await handle(data, ctx);
+    return Response.json(result);
+  }
+);
+`;
+
+  // Check if createHandler is imported
+  if (!content.includes("createHandler")) {
+    content = content.replace(
+      /from "@donkeylabs\/server"/,
+      ', createHandler } from "@donkeylabs/server"'
+    );
+    content = content.replace("{ createPlugin, createHandler }", "{ createPlugin, createHandler }");
+  }
+
+  // Add to plugin definition's handlers object
+  const handlersMatch = content.match(/handlers:\s*\{([^}]*)\}/);
+  if (handlersMatch) {
+    // Add to existing handlers object
+    const insertPos = handlersMatch.index! + handlersMatch[0].length - 1;
+    const existingHandlers = handlersMatch[1].trim();
+    const separator = existingHandlers ? ",\n      " : "\n      ";
+    content = content.slice(0, insertPos) + separator + `${handlerName}: ${handlerName.charAt(0).toUpperCase() + handlerName.slice(1)}Handler` + content.slice(insertPos);
+  } else {
+    // Add handlers object to plugin definition
+    const defineMatch = content.match(/\.define\s*\(\s*\{/);
+    if (defineMatch) {
+      const insertPos = defineMatch.index! + defineMatch[0].length;
+      content = content.slice(0, insertPos) + `\n    handlers: {\n      ${handlerName}: ${handlerName.charAt(0).toUpperCase() + handlerName.slice(1)}Handler,\n    },` + content.slice(insertPos);
+    }
+  }
+
+  // Add handler definition before the plugin export
+  const exportMatch = content.match(/export const \w+Plugin/);
+  if (exportMatch) {
+    content = content.slice(0, exportMatch.index) + handlerCode + "\n" + content.slice(exportMatch.index);
+  }
+
+  await writeFile(indexPath, content);
+
+  return `Added custom handler '${handlerName}' to ${pluginName} plugin.
+
+Usage in routes:
+  router.route("data").${handlerName}({
+    handle: async (${signatureParams.split(",")[0]}) => {
+      // Return type: ${signatureReturn}
+    }
+  })
+
+Remember to run 'donkeylabs generate' to update types!`;
+}
+
+async function createCustomError(args: {
+  pluginName: string;
+  errorName: string;
+  httpStatus?: number;
+  defaultMessage?: string;
+  errorCode?: string;
+}): Promise<string> {
+  const {
+    pluginName,
+    errorName,
+    httpStatus = 400,
+    defaultMessage,
+    errorCode,
+  } = args;
+
+  const pluginsDir = await getPluginsDir();
+  const pluginDir = join(pluginsDir, pluginName);
+
+  if (!existsSync(pluginDir)) {
+    throw new Error(`Plugin '${pluginName}' not found`);
+  }
+
+  // Generate error code from name if not provided
+  const code = errorCode || errorName.replace(/([A-Z])/g, "_$1").toUpperCase().slice(1);
+  const message = defaultMessage || errorName.replace(/([A-Z])/g, " $1").trim();
+  const className = `${errorName}Error`;
+
+  const errorsPath = join(pluginDir, "errors.ts");
+  let content: string;
+
+  if (existsSync(errorsPath)) {
+    // Append to existing errors file
+    const existing = await readFile(errorsPath, "utf-8");
+
+    if (existing.includes(`class ${className}`)) {
+      throw new Error(`Error '${className}' already exists in ${pluginName}/errors.ts`);
+    }
+
+    const newError = `
+export class ${className} extends HttpError {
+  constructor(message = "${message}") {
+    super(${httpStatus}, message, "${code}");
+    this.name = "${className}";
+  }
+}
+`;
+    content = existing + newError;
+  } else {
+    // Create new errors file
+    content = `import { HttpError } from "@donkeylabs/server";
+
+export class ${className} extends HttpError {
+  constructor(message = "${message}") {
+    super(${httpStatus}, message, "${code}");
+    this.name = "${className}";
+  }
+}
+`;
+  }
+
+  await writeFile(errorsPath, content);
+
+  return `Created custom error '${className}' in ${pluginName}/errors.ts
+
+Usage:
+  import { ${className} } from "./errors";
+
+  // In service or handler:
+  throw new ${className}();
+  // or with custom message:
+  throw new ${className}("Custom message here");
+
+HTTP Response:
+  Status: ${httpStatus}
+  Body: { "error": "${code}", "message": "${message}" }`;
+}
+
+async function validateCode(args: {
+  filePath: string;
+  checkType?: string;
+}): Promise<string> {
+  const { filePath, checkType = "auto" } = args;
+
+  const root = await findProjectRoot();
+  const fullPath = join(root, filePath);
+
+  if (!existsSync(fullPath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const content = await readFile(fullPath, "utf-8");
+  const issues: string[] = [];
+  const warnings: string[] = [];
+  const suggestions: string[] = [];
+
+  // Detect check type from path if auto
+  let type = checkType;
+  if (type === "auto") {
+    if (filePath.includes("/plugins/")) type = "plugin";
+    else if (filePath.includes("/routes/")) type = "route";
+    else if (filePath.includes("/models/")) type = "model";
+    else type = "general";
+  }
+
+  // Common checks for all files
+  if (content.includes("fetch(") && !filePath.includes("client")) {
+    warnings.push("Uses raw fetch() - consider using generated API client instead");
+  }
+
+  if (content.includes("console.log(") && !content.includes("// debug")) {
+    warnings.push("Contains console.log() - use ctx.core.logger instead");
+  }
+
+  // Plugin-specific checks
+  if (type === "plugin") {
+    if (!content.includes("createPlugin")) {
+      issues.push("Missing createPlugin import - required for plugin definition");
+    }
+
+    if (!content.includes("export const") || !content.includes("Plugin")) {
+      issues.push("No plugin export found - export should be named <name>Plugin");
+    }
+
+    if (content.includes("service:") && !content.includes("async (ctx)") && !content.includes("async(ctx)")) {
+      warnings.push("Service function should be async and receive ctx parameter");
+    }
+
+    if (content.includes("dependencies:") && !content.includes("as const")) {
+      warnings.push("Dependencies array should use 'as const' for type safety");
+    }
+
+    if (!content.includes("version:")) {
+      suggestions.push("Consider adding 'version' field to plugin definition");
+    }
+  }
+
+  // Route-specific checks
+  if (type === "route") {
+    if (!content.includes("z.object") && !content.includes(".raw(")) {
+      warnings.push("Typed routes should have Zod input/output schemas");
+    }
+
+    if (!content.includes("async function handler") && !content.includes("async (") && !content.includes("handle:")) {
+      issues.push("Handler function should be async");
+    }
+
+    if (!content.includes("GlobalContext") && !content.includes("ServerContext")) {
+      warnings.push("Handler should use GlobalContext or ServerContext type for ctx parameter");
+    }
+
+    const hasInputSchema = content.includes("export const input") || content.includes("input:");
+    const hasOutputSchema = content.includes("export const output") || content.includes("output:");
+
+    if (content.includes(".typed(") && (!hasInputSchema || !hasOutputSchema)) {
+      warnings.push("Typed handlers should define both input and output schemas");
+    }
+  }
+
+  // Model-specific checks
+  if (type === "model") {
+    if (!content.includes("constructor(") || !content.includes("ctx")) {
+      warnings.push("Model constructor should accept GlobalContext for dependency injection");
+    }
+
+    if (!content.includes("private ctx") && !content.includes("readonly ctx")) {
+      suggestions.push("Consider storing ctx as private/readonly class property");
+    }
+
+    if (!content.includes("export function create") && !content.includes("export const create")) {
+      suggestions.push("Consider adding a factory function (e.g., createUserModel) for convenience");
+    }
+
+    if (content.includes("this.db") || content.includes("this.plugins")) {
+      warnings.push("Access db/plugins via this.ctx.db and this.ctx.plugins instead");
+    }
+  }
+
+  // Format output
+  const results: string[] = [`Validation results for ${filePath} (${type}):\n`];
+
+  if (issues.length === 0 && warnings.length === 0 && suggestions.length === 0) {
+    results.push("All checks passed. Code follows conventions.");
+    return results.join("\n");
+  }
+
+  if (issues.length > 0) {
+    results.push(`ERRORS (${issues.length}):`);
+    issues.forEach((i) => results.push(`  - ${i}`));
+    results.push("");
+  }
+
+  if (warnings.length > 0) {
+    results.push(`WARNINGS (${warnings.length}):`);
+    warnings.forEach((w) => results.push(`  - ${w}`));
+    results.push("");
+  }
+
+  if (suggestions.length > 0) {
+    results.push(`SUGGESTIONS (${suggestions.length}):`);
+    suggestions.forEach((s) => results.push(`  - ${s}`));
+  }
+
+  return results.join("\n");
+}
+
+// ============================================
+// Server Setup
+// ============================================
+
+// ============================================
+// Resource: Project Context (like CLAUDE.md)
+// ============================================
+
+const PROJECT_CONTEXT = `# @donkeylabs/server - AI Development Guide
+
+## Project Structure
+
+\`\`\`
+src/
+  index.ts              # Server entry point
+  db.ts                 # Database setup (Kysely + SQLite)
+  routes/               # Route handlers (preferred structure)
+    <namespace>/
+      <route-name>/
+        handler.ts      # Route handler
+        test.ts         # Unit tests
+  models/               # Business logic models
+    UserModel.ts        # Model with GlobalContext injection
+  plugins/              # Plugin modules
+    <name>/
+      index.ts          # Plugin definition
+      schema.ts         # DB types (optional)
+      errors.ts         # Custom errors (optional)
+      migrations/       # SQL migrations
+test/
+  integration/          # Integration tests
+.@donkeylabs/server/    # Generated types (gitignored)
+  registry.d.ts
+  context.d.ts
+  routes.d.ts
+\`\`\`
+
+## GlobalContext (CRITICAL - Use This!)
+
+The \`GlobalContext\` type provides access to ALL services. ALWAYS use ctx instead of creating your own instances!
+
+\`\`\`typescript
+import type { GlobalContext } from "./@donkeylabs/server/context";
+
+interface GlobalContext {
+  db: Kysely<DatabaseSchema>;      // Type-safe database
+  plugins: {                       // Plugin services
+    auth: AuthService;
+    users: UsersService;
+    // ... all registered plugins
+  };
+  core: CoreServices;              // Logger, cache, events, jobs, cron, sse, rateLimiter
+  errors: Errors;                  // Error factories
+  ip: string;                      // Client IP address
+  requestId?: string;              // Request tracking ID
+  user?: any;                      // Authenticated user (set by auth middleware)
+}
+\`\`\`
+
+## Core Services (ctx.core) - Full Reference
+
+### Logger
+\`\`\`typescript
+// Structured logging with levels
+ctx.core.logger.info("User created", { userId: "123", email: "..." });
+ctx.core.logger.warn("Rate limit approaching", { remaining: 5 });
+ctx.core.logger.error("Payment failed", { error, orderId });
+ctx.core.logger.debug("Cache hit", { key, ttl });
+\`\`\`
+
+### Cache
+\`\`\`typescript
+// Set with TTL (seconds)
+await ctx.core.cache.set("user:123", userData, { ttl: 300 });
+
+// Get (returns undefined if expired/missing)
+const user = await ctx.core.cache.get("user:123");
+
+// Delete
+await ctx.core.cache.delete("user:123");
+
+// Check existence
+const exists = await ctx.core.cache.has("user:123");
+\`\`\`
+
+### Events (Pub/Sub)
+\`\`\`typescript
+// Emit event (fire-and-forget)
+ctx.core.events.emit("user.created", { userId: "123", email: "..." });
+ctx.core.events.emit("order.completed", { orderId, total });
+
+// Subscribe to events (in plugin service)
+ctx.core.events.on("user.created", async (data) => {
+  await sendWelcomeEmail(data.email);
+});
+
+// One-time listener
+ctx.core.events.once("server.ready", () => console.log("Server started"));
+\`\`\`
+
+### Jobs (Background Processing)
+\`\`\`typescript
+// Register job handler (in plugin initialization)
+ctx.core.jobs.register("sendEmail", async (payload) => {
+  await mailer.send(payload.to, payload.subject, payload.body);
+});
+
+// Enqueue job from anywhere
+await ctx.core.jobs.enqueue("sendEmail", {
+  to: "user@example.com",
+  subject: "Welcome!",
+  body: "Welcome to our service!",
+});
+
+// Enqueue with delay
+await ctx.core.jobs.enqueue("reminder", data, { delay: 60 * 60 * 1000 }); // 1 hour
+\`\`\`
+
+### Cron (Scheduled Tasks)
+\`\`\`typescript
+// Schedule recurring task (cron expression)
+ctx.core.cron.schedule("0 0 * * *", async () => {
+  // Runs daily at midnight
+  await cleanupExpiredSessions();
+});
+
+// Schedule with options
+ctx.core.cron.schedule("*/5 * * * *", handler, {
+  name: "cleanup",
+  runOnStart: false,
+});
+
+// Common patterns:
+// "0 * * * *"     - Every hour
+// "*/5 * * * *"   - Every 5 minutes
+// "0 0 * * *"     - Daily at midnight
+// "0 0 * * 0"     - Weekly on Sunday
+// "0 0 1 * *"     - Monthly on 1st
+\`\`\`
+
+### SSE (Server-Sent Events)
+\`\`\`typescript
+// In raw handler - create SSE connection
+const client = ctx.core.sse.addClient(userId);
+return client.response;  // Return this Response directly
+
+// Broadcast to all connected clients
+ctx.core.sse.broadcast("notifications", { message: "New update!" });
+
+// Send to specific client
+ctx.core.sse.send(userId, "private", { data: "Personal message" });
+
+// Remove client on disconnect
+ctx.core.sse.removeClient(userId);
+\`\`\`
+
+### Rate Limiter
+\`\`\`typescript
+// Check rate limit
+const result = await ctx.core.rateLimiter.limit(\`api:\${ctx.ip}\`, {
+  window: "1m",  // Time window
+  max: 100,      // Max requests in window
+});
+
+if (!result.allowed) {
+  throw ctx.errors.TooManyRequests(\`Try again in \${result.retryAfter}s\`);
+}
+
+// Rate limit by user
+const userLimit = await ctx.core.rateLimiter.limit(\`user:\${ctx.user.id}\`, {
+  window: "1h",
+  max: 1000,
+});
+\`\`\`
+
+## Error Factories (ctx.errors)
+
+| Factory | HTTP Status | Use Case |
+|---------|-------------|----------|
+| \`BadRequest(msg)\` | 400 | Invalid input data |
+| \`Unauthorized(msg)\` | 401 | Not logged in |
+| \`Forbidden(msg)\` | 403 | No permission |
+| \`NotFound(msg)\` | 404 | Resource doesn't exist |
+| \`MethodNotAllowed(msg)\` | 405 | Wrong HTTP method |
+| \`Conflict(msg)\` | 409 | Resource already exists |
+| \`Gone(msg)\` | 410 | Resource permanently deleted |
+| \`UnprocessableEntity(msg)\` | 422 | Semantic/business logic error |
+| \`TooManyRequests(msg)\` | 429 | Rate limit exceeded |
+| \`InternalServerError(msg)\` | 500 | Unexpected server error |
+| \`NotImplemented(msg)\` | 501 | Feature not ready |
+| \`ServiceUnavailable(msg)\` | 503 | Maintenance mode |
+
+Usage:
+\`\`\`typescript
+// Throw errors in handlers
+if (!user) throw ctx.errors.NotFound("User not found");
+if (!canAccess) throw ctx.errors.Forbidden("Access denied");
+if (exists) throw ctx.errors.Conflict("Email already registered");
+\`\`\`
+
+## Custom Errors
+
+Create domain-specific errors using the \`create_custom_error\` tool:
+\`\`\`typescript
+// plugins/payments/errors.ts
+import { HttpError } from "@donkeylabs/server";
+
+export class InsufficientFundsError extends HttpError {
+  constructor(message = "Insufficient funds") {
+    super(400, message, "INSUFFICIENT_FUNDS");
+  }
+}
+\`\`\`
+
+## Route Structure (Preferred)
+
+Routes go in \`src/routes/<namespace>/<route-name>/handler.ts\`:
+
+\`\`\`typescript
+// src/routes/users/create/handler.ts
+import { z } from "zod";
+import type { GlobalContext } from "../../../.@donkeylabs/server/context";
+
+export const input = z.object({
+  email: z.string().email(),
+  name: z.string(),
+});
+
+export const output = z.object({
+  user: z.object({ id: z.string() }),
+});
+
+export async function handler(
+  data: z.infer<typeof input>,
+  ctx: GlobalContext
+): Promise<z.infer<typeof output>> {
+  const user = await ctx.plugins.users.create(data);
+  return { user };
+}
+\`\`\`
+
+## Models for Testability
+
+Create models in \`src/models/\` for business logic separation:
+
+\`\`\`typescript
+// src/models/UserModel.ts
+import type { GlobalContext } from "../.@donkeylabs/server/context";
+
+export class UserModel {
+  constructor(private ctx: GlobalContext) {}
+
+  async create(data: { email: string; name: string }) {
+    // Access ctx.db, ctx.plugins, ctx.core, ctx.errors
+    return this.ctx.db.insertInto("users")
+      .values(data)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+  }
+}
+
+export function createUserModel(ctx: GlobalContext) {
+  return new UserModel(ctx);
+}
+\`\`\`
+
+Usage in route:
+\`\`\`typescript
+import { createUserModel } from "../../models/UserModel";
+
+export async function handler(data, ctx) {
+  const model = createUserModel(ctx);
+  return model.create(data);
+}
+\`\`\`
+
+## Testing
+
+### Unit Tests (with mock context)
+Place test files next to handlers: \`handler.ts\` + \`test.ts\`
+
+\`\`\`typescript
+import { describe, test, expect } from "bun:test";
+import { handler } from "./handler";
+
+describe("users.create", () => {
+  const mockCtx = {
+    db: { insertInto: () => ({ values: () => ({ returningAll: () => ({ executeTakeFirstOrThrow: async () => ({ id: "123" }) }) }) }) } as any,
+    plugins: {} as any,
+    core: {} as any,
+    errors: {} as any,
+    ip: "127.0.0.1",
+  };
+
+  test("creates user", async () => {
+    const result = await handler({ email: "test@example.com", name: "Test" }, mockCtx);
+    expect(result.user.id).toBe("123");
+  });
+});
+\`\`\`
+
+### Integration Tests (with real plugins)
+Use \`createTestHarness\` for full integration tests:
+
+\`\`\`typescript
+import { describe, test, expect, beforeAll } from "bun:test";
+import { createTestHarness } from "@donkeylabs/server/harness";
+import { authPlugin } from "../src/plugins/auth";
+import { usersPlugin } from "../src/plugins/users";
+
+describe("users.create (Integration)", () => {
+  let harness: Awaited<ReturnType<typeof createTestHarness>>;
+
+  beforeAll(async () => {
+    harness = await createTestHarness(authPlugin, usersPlugin);
+    await harness.manager.initialize();
+  });
+
+  test("creates user with real database", async () => {
+    const response = await harness.request("users.create", {
+      email: "test@example.com",
+      name: "Test User",
+    });
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.user.id).toBeDefined();
+  });
+});
+\`\`\`
+
+## Database
+- Uses Kysely with BunSqliteDialect for SQLite
+- Each plugin manages its own tables via migrations
+- Migrations are numbered: \`001_create_users.ts\`, \`002_add_email.ts\`
+
+## Error Handling
+Use \`ctx.errors\` factories:
+- \`ctx.errors.BadRequest(message)\`
+- \`ctx.errors.Unauthorized(message)\`
+- \`ctx.errors.Forbidden(message)\`
+- \`ctx.errors.NotFound(message)\`
+- \`ctx.errors.Conflict(message)\`
+
+## API Client (Frontend)
+
+ALWAYS use the generated API client instead of raw \`fetch()\` calls!
+
+Generate the client:
+\`\`\`bash
+donkeylabs generate  # or use generate_client MCP tool
+\`\`\`
+
+Usage:
+\`\`\`typescript
+// DON'T do this:
+const res = await fetch("http://localhost:3000/users.create", { ... });
+
+// DO this instead:
+import { createApiClient } from "./client/api";
+
+const api = createApiClient({ baseUrl: "http://localhost:3000" });
+const user = await api.users.create({ email: "test@example.com" });
+\`\`\`
+
+## Middleware
+
+Add middleware to plugins for cross-cutting concerns (auth, logging, rate limiting):
+
+\`\`\`typescript
+// In plugin index.ts
+import { createMiddleware } from "@donkeylabs/server";
+
+const requireAuthMiddleware = createMiddleware({
+  name: "requireAuth",
+  handler: async (ctx, next) => {
+    const token = ctx.headers.get("Authorization");
+    if (!token) throw ctx.errors.Unauthorized("No token");
+    ctx.user = await validateToken(token);
+    return next();
+  },
+});
+
+export const authPlugin = createPlugin.define({
+  name: "auth",
+  middleware: {
+    requireAuth: requireAuthMiddleware,
+  },
+  // ...
+});
+\`\`\`
+
+Usage in routes:
+\`\`\`typescript
+router.route("profile")
+  .requireAuth()  // Apply middleware
+  .typed({
+    handle: async (input, ctx) => {
+      return ctx.user; // User is now available
+    },
+  });
+\`\`\`
+
+## Custom Handlers
+
+Create custom handler types beyond \`typed\` and \`raw\`:
+
+\`\`\`typescript
+import { createHandler } from "@donkeylabs/server";
+
+type StreamingFn = (data: any, ctx: ServerContext) => AsyncGenerator<string>;
+
+const StreamingHandler = createHandler<StreamingFn>(
+  async (req, def, handle, ctx) => {
+    const data = await req.json();
+    const stream = handle(data, ctx);
+
+    return new Response(
+      new ReadableStream({
+        async start(controller) {
+          for await (const chunk of stream) {
+            controller.enqueue(new TextEncoder().encode(chunk));
+          }
+          controller.close();
+        },
+      })
+    );
+  }
+);
+
+export const myPlugin = createPlugin.define({
+  handlers: {
+    streaming: StreamingHandler,
+  },
+  // ...
+});
+\`\`\`
+
+Usage:
+\`\`\`typescript
+router.route("stream").streaming({
+  handle: async function* (data, ctx) {
+    yield "Starting...";
+    yield "Processing...";
+    yield "Done!";
+  },
+});
+\`\`\`
+
+## After Making Changes
+Always run \`donkeylabs generate\` to update types after:
+- Adding/modifying plugins
+- Adding routes in src/routes/
+- Adding custom handlers
+- Adding middleware
+
+## Common Patterns
+
+### Creating a Plugin with Database
+\`\`\`typescript
+import { createPlugin } from "@donkeylabs/server";
+import type { DB as MySchema } from "./schema";
+
+export const myPlugin = createPlugin
+  .withSchema<MySchema>()
+  .define({
+    name: "my-plugin",
+    version: "1.0.0",
+    service: async (ctx) => ({
+      getData: async () => {
+        return ctx.db.selectFrom("my_table").selectAll().execute();
+      }
+    }),
+  });
+\`\`\`
+
+### Creating a Typed Route
+\`\`\`typescript
+router.route("getUser").typed({
+  input: z.object({ id: z.string() }),
+  output: z.object({ user: userSchema }),
+  handle: async (input, ctx) => {
+    const user = await ctx.plugins.users.getById(input.id);
+    if (!user) throw ctx.errors.NotFound("User not found");
+    return { user };
+  },
+});
+\`\`\`
+
+### Plugin Dependencies
+\`\`\`typescript
+export const statsPlugin = createPlugin.define({
+  name: "stats",
+  dependencies: ["auth", "counter"] as const,
+  service: async (ctx) => ({
+    getStats: async () => {
+      // Access dependencies via ctx.deps
+      const user = ctx.deps.auth.getCurrentUser();
+      const count = ctx.deps.counter.get("visits");
+      return { user, count };
+    }
+  }),
+});
+\`\`\`
+
+## Error Handling
+Use \`ctx.errors\` factories:
+- \`ctx.errors.BadRequest(message)\`
+- \`ctx.errors.Unauthorized(message)\`
+- \`ctx.errors.Forbidden(message)\`
+- \`ctx.errors.NotFound(message)\`
+- \`ctx.errors.Conflict(message)\`
+
+## After Making Changes
+Always run \`donkeylabs generate\` to update types after:
+- Adding/modifying plugins
+- Adding custom handlers
+- Adding middleware
+`;
+
+const server = new Server(
+  {
+    name: "donkeylabs-server",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+// Resource handlers
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: [
+    {
+      uri: "donkeylabs://context",
+      name: "Project Development Guide",
+      description: "Conventions, patterns, and best practices for @donkeylabs/server development",
+      mimeType: "text/markdown",
+    },
+  ],
+}));
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  if (uri === "donkeylabs://context") {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/markdown",
+          text: PROJECT_CONTEXT,
+        },
+      ],
+    };
+  }
+
+  throw new Error(`Unknown resource: ${uri}`);
+});
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: string;
+
+    switch (name) {
+      case "init_project":
+        result = await initProject(args as any);
+        break;
+      case "create_plugin":
+        result = await createPlugin(args as any);
+        break;
+      case "add_route":
+        result = await addRoute(args as any);
+        break;
+      case "add_migration":
+        result = await addMigration(args as any);
+        break;
+      case "generate_types":
+        result = await generateTypes();
+        break;
+      case "list_plugins":
+        result = await listPlugins();
+        break;
+      case "get_project_info":
+        result = await getProjectInfo();
+        break;
+      case "add_service_method":
+        result = await addServiceMethod(args as any);
+        break;
+      case "create_router":
+        result = await createRouter(args as any);
+        break;
+      case "validate_project":
+        result = await validateProject();
+        break;
+      case "register_plugin":
+        result = await registerPlugin(args as any);
+        break;
+      case "run_migrations":
+        result = await runMigrations(args as any);
+        break;
+      case "setup_database":
+        result = await setupDatabase(args as any);
+        break;
+      case "list_routes":
+        result = await listRoutes(args as any);
+        break;
+      case "add_route_file":
+        result = await addRouteFile(args as any);
+        break;
+      case "create_model":
+        result = await createModel(args as any);
+        break;
+      case "add_unit_test":
+        result = await addUnitTest(args as any);
+        break;
+      case "add_integration_test":
+        result = await addIntegrationTest(args as any);
+        break;
+      case "generate_client":
+        result = await generateClientTool(args as any);
+        break;
+      case "add_middleware":
+        result = await addMiddleware(args as any);
+        break;
+      case "add_custom_handler":
+        result = await addCustomHandler(args as any);
+        break;
+      case "create_custom_error":
+        result = await createCustomError(args as any);
+        break;
+      case "validate_code":
+        result = await validateCode(args as any);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error: any) {
+    return {
+      content: [{ type: "text", text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("@donkeylabs/server MCP server running on stdio");
+}
+
+main().catch(console.error);