@donkeylabs/cli 0.4.1 → 0.4.3

package/src/commands/mcp.ts

@@ -0,0 +1,305 @@
+/**
+ * MCP (Model Context Protocol) setup command
+ *
+ * Sets up the @donkeylabs/mcp server for AI-assisted development
+ */
+
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+import prompts from "prompts";
+
+interface McpConfig {
+  mcpServers?: Record<string, {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+  }>;
+}
+
+async function detectPackageManager(): Promise<"bun" | "npm" | "pnpm" | "yarn"> {
+  if (existsSync("bun.lockb") || existsSync("bun.lock")) return "bun";
+  if (existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (existsSync("yarn.lock")) return "yarn";
+  return "npm";
+}
+
+async function installPackage(pkg: string, dev: boolean = true): Promise<boolean> {
+  const pm = await detectPackageManager();
+
+  const args: string[] = [];
+  switch (pm) {
+    case "bun":
+      args.push("add", dev ? "-d" : "", pkg);
+      break;
+    case "pnpm":
+      args.push("add", dev ? "-D" : "", pkg);
+      break;
+    case "yarn":
+      args.push("add", dev ? "-D" : "", pkg);
+      break;
+    default:
+      args.push("install", dev ? "--save-dev" : "--save", pkg);
+  }
+
+  console.log(pc.dim(`$ ${pm} ${args.filter(Boolean).join(" ")}`));
+
+  return new Promise((resolve) => {
+    const child = spawn(pm, args.filter(Boolean), {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+
+async function readMcpConfig(): Promise<McpConfig> {
+  const configPath = join(process.cwd(), ".mcp.json");
+
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+async function writeMcpConfig(config: McpConfig): Promise<void> {
+  const configPath = join(process.cwd(), ".mcp.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+async function setupClaudeCode(): Promise<void> {
+  console.log(pc.cyan("\nClaude Code Setup:"));
+  console.log(pc.dim("─".repeat(40)));
+  console.log(`
+The .mcp.json file has been created in your project root.
+Claude Code will automatically detect and use this configuration.
+
+${pc.bold("To verify:")}
+  1. Open Claude Code in this project
+  2. The MCP tools should be available automatically
+  3. Try asking Claude to "list plugins" or "get project info"
+
+${pc.bold("Manual setup (if needed):")}
+  Add to your Claude Code settings:
+  ${pc.dim(JSON.stringify({
+    "mcpServers": {
+      "donkeylabs": {
+        "command": "bunx",
+        "args": ["@donkeylabs/mcp"],
+        "cwd": "${workspaceFolder}"
+      }
+    }
+  }, null, 2))}
+`);
+}
+
+async function setupCursor(): Promise<void> {
+  console.log(pc.cyan("\nCursor Setup:"));
+  console.log(pc.dim("─".repeat(40)));
+  console.log(`
+${pc.bold("To configure Cursor:")}
+  1. Open Cursor Settings (Cmd/Ctrl + ,)
+  2. Search for "MCP" or "Model Context Protocol"
+  3. Add the donkeylabs server configuration:
+
+${pc.dim(JSON.stringify({
+    "donkeylabs": {
+      "command": "bunx",
+      "args": ["@donkeylabs/mcp"],
+      "cwd": "${workspaceFolder}"
+    }
+  }, null, 2))}
+
+  4. Restart Cursor to apply changes
+`);
+}
+
+async function setupWindsurf(): Promise<void> {
+  console.log(pc.cyan("\nWindsurf Setup:"));
+  console.log(pc.dim("─".repeat(40)));
+  console.log(`
+${pc.bold("To configure Windsurf:")}
+  1. Open Windsurf settings
+  2. Navigate to AI / MCP configuration
+  3. Add the donkeylabs server:
+
+${pc.dim(JSON.stringify({
+    "donkeylabs": {
+      "command": "bunx",
+      "args": ["@donkeylabs/mcp"],
+      "cwd": "${workspaceFolder}"
+    }
+  }, null, 2))}
+`);
+}
+
+export async function mcpCommand(args: string[]): Promise<void> {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === "setup") {
+    await setupMcp(args.slice(1));
+  } else if (subcommand === "help" || subcommand === "--help") {
+    printMcpHelp();
+  } else {
+    console.error(pc.red(`Unknown mcp subcommand: ${subcommand}`));
+    printMcpHelp();
+    process.exit(1);
+  }
+}
+
+function printMcpHelp(): void {
+  console.log(`
+${pc.bold("donkeylabs mcp")} - Setup MCP server for AI-assisted development
+
+${pc.bold("Usage:")}
+  donkeylabs mcp                  Interactive MCP setup
+  donkeylabs mcp setup            Setup MCP (interactive)
+  donkeylabs mcp setup --claude   Setup for Claude Code
+  donkeylabs mcp setup --cursor   Setup for Cursor
+  donkeylabs mcp setup --all      Setup for all IDEs
+
+${pc.bold("Options:")}
+  --claude      Configure for Claude Code
+  --cursor      Configure for Cursor
+  --windsurf    Configure for Windsurf
+  --all         Show setup for all IDEs
+  --skip-install  Skip installing @donkeylabs/mcp package
+
+${pc.bold("What this does:")}
+  1. Installs @donkeylabs/mcp as a dev dependency
+  2. Creates/updates .mcp.json in your project
+  3. Provides IDE-specific setup instructions
+
+${pc.bold("MCP Tools Available:")}
+  - get_project_info    - View project structure and routes
+  - create_plugin       - Create new plugins
+  - add_service_method  - Add methods to plugin services
+  - add_migration       - Create database migrations
+  - create_router       - Create new routers
+  - add_route           - Add routes to routers
+  - add_cron            - Schedule cron jobs
+  - add_event           - Register events
+  - add_async_job       - Register background jobs
+  - generate_types      - Regenerate types
+  - generate_client     - Generate API client
+`);
+}
+
+async function setupMcp(args: string[]): Promise<void> {
+  console.log(pc.bold("\n🔧 Setting up @donkeylabs/mcp\n"));
+
+  // Check if we're in a donkeylabs project
+  const configPath = join(process.cwd(), "donkeylabs.config.ts");
+  const hasConfig = existsSync(configPath);
+
+  if (!hasConfig) {
+    console.log(pc.yellow("⚠ No donkeylabs.config.ts found in current directory."));
+    console.log(pc.dim("  The MCP server works best in a @donkeylabs/server project."));
+    console.log(pc.dim("  Run 'donkeylabs init' to create a new project first.\n"));
+
+    const { proceed } = await prompts({
+      type: "confirm",
+      name: "proceed",
+      message: "Continue anyway?",
+      initial: false,
+    });
+
+    if (!proceed) {
+      console.log(pc.dim("Aborted."));
+      return;
+    }
+  }
+
+  // Parse args for flags
+  const skipInstall = args.includes("--skip-install");
+  const forClaude = args.includes("--claude");
+  const forCursor = args.includes("--cursor");
+  const forWindsurf = args.includes("--windsurf");
+  const forAll = args.includes("--all");
+
+  // Install @donkeylabs/mcp if not skipped
+  if (!skipInstall) {
+    console.log(pc.cyan("Installing @donkeylabs/mcp..."));
+    const success = await installPackage("@donkeylabs/mcp");
+
+    if (!success) {
+      console.log(pc.yellow("\n⚠ Package installation failed, but continuing with config setup."));
+      console.log(pc.dim("  You can manually install with: bun add -d @donkeylabs/mcp\n"));
+    } else {
+      console.log(pc.green("✓ Installed @donkeylabs/mcp\n"));
+    }
+  }
+
+  // Create/update .mcp.json
+  console.log(pc.cyan("Configuring .mcp.json..."));
+
+  const config = await readMcpConfig();
+  config.mcpServers = config.mcpServers || {};
+
+  config.mcpServers.donkeylabs = {
+    command: "bunx",
+    args: ["@donkeylabs/mcp"],
+    cwd: "${workspaceFolder}",
+  };
+
+  await writeMcpConfig(config);
+  console.log(pc.green("✓ Created .mcp.json\n"));
+
+  // Show IDE-specific instructions
+  if (forAll || (!forClaude && !forCursor && !forWindsurf)) {
+    // Interactive mode or --all
+    if (!forClaude && !forCursor && !forWindsurf && !forAll) {
+      const { ide } = await prompts({
+        type: "select",
+        name: "ide",
+        message: "Which IDE are you using?",
+        choices: [
+          { title: "Claude Code", value: "claude" },
+          { title: "Cursor", value: "cursor" },
+          { title: "Windsurf", value: "windsurf" },
+          { title: "Show all", value: "all" },
+        ],
+      });
+
+      if (ide === "claude") await setupClaudeCode();
+      else if (ide === "cursor") await setupCursor();
+      else if (ide === "windsurf") await setupWindsurf();
+      else {
+        await setupClaudeCode();
+        await setupCursor();
+        await setupWindsurf();
+      }
+    } else {
+      await setupClaudeCode();
+      await setupCursor();
+      await setupWindsurf();
+    }
+  } else {
+    if (forClaude) await setupClaudeCode();
+    if (forCursor) await setupCursor();
+    if (forWindsurf) await setupWindsurf();
+  }
+
+  console.log(pc.green("\n✓ MCP setup complete!\n"));
+  console.log(pc.dim("The AI assistant can now help you with:"));
+  console.log(pc.dim("  - Creating plugins, routes, and handlers"));
+  console.log(pc.dim("  - Adding migrations and service methods"));
+  console.log(pc.dim("  - Setting up cron jobs and background tasks"));
+  console.log(pc.dim("  - Generating types and API clients\n"));
+}

package/src/index.ts

@@ -35,6 +35,7 @@ ${pc.bold("Commands:")}
   ${pc.cyan("init")}         Initialize a new project
   ${pc.cyan("generate")}     Generate types (registry, context, client)
   ${pc.cyan("plugin")}       Plugin management
+  ${pc.cyan("mcp")}          Setup MCP server for AI-assisted development
 
 ${pc.bold("Options:")}
   -h, --help              Show this help message
@@ -95,6 +96,11 @@ async function main() {
       await pluginCommand(positionals.slice(1));
       break;
 
+    case "mcp":
+      const { mcpCommand } = await import("./commands/mcp");
+      await mcpCommand(positionals.slice(1));
+      break;
+
     default:
       console.error(pc.red(`Unknown command: ${command}`));
       console.log(`Run ${pc.cyan("donkeylabs --help")} for available commands.`);

package/templates/starter/src/index.ts

@@ -1,8 +1,15 @@
-import { db } from "./db";
 import { AppServer, createRouter } from "@donkeylabs/server";
+import { Kysely } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
 import { healthRouter } from "./routes/health";
 import { statsPlugin } from "./plugins/stats";
 
+// Simple in-memory database
+const db = new Kysely<{}>({
+  dialect: new BunSqliteDialect({ database: new Database(":memory:") }),
+});
+
 const server = new AppServer({
   port: Number(process.env.PORT) || 3000,
   db,
@@ -26,12 +33,22 @@ export function createApi(baseUrl: string, options?: ApiClientOptions) {
 // Register plugins
 server.registerPlugin(statsPlugin);
 
-const api = createRouter("api")
+const api = createRouter("api");
 // Register routes
 api.router(healthRouter);
 
+server.use(api);
 
+// Handle DONKEYLABS_GENERATE mode for CLI type generation
+if (process.env.DONKEYLABS_GENERATE === "1") {
+  const routes = api.getRoutes().map((route) => ({
+    name: route.name,
+    handler: route.handler || "typed",
+    inputType: route.input ? "(generated)" : undefined,
+    outputType: route.output ? "(generated)" : undefined,
+  }));
+  console.log(JSON.stringify({ routes }));
+  process.exit(0);
+}
 
-
-server.use(api);
 await server.start();

package/templates/sveltekit-app/package.json

@@ -24,9 +24,9 @@
     "vite": "^7.2.6"
   },
   "dependencies": {
-    "@donkeylabs/cli": "^0.4.0",
-    "@donkeylabs/adapter-sveltekit": "^0.4.0",
-    "@donkeylabs/server": "^0.4.0",
+    "@donkeylabs/cli": "^0.4.3",
+    "@donkeylabs/adapter-sveltekit": "^0.4.3",
+    "@donkeylabs/server": "^0.4.3",
     "bits-ui": "^2.15.4",
     "clsx": "^2.1.1",
     "kysely": "^0.27.6",

package/templates/sveltekit-app/src/server/index.ts

@@ -4,17 +4,7 @@ import { Kysely } from "kysely";
 import { BunSqliteDialect } from "kysely-bun-sqlite";
 import { Database } from "bun:sqlite";
 import { demoPlugin } from "./plugins/demo";
-
-// Import routes
-import {
-  counterRoutes,
-  cacheRoutes,
-  jobsRoutes,
-  cronRoutes,
-  ratelimitRoutes,
-  eventsRoutes,
-  sseRoutes,
-} from "./routes";
+import demoRoutes from "./routes/demo";
 
 // Simple in-memory database
 const db = new Kysely<{}>({
@@ -33,13 +23,17 @@ export const server = new AppServer({
 // Register plugin
 server.registerPlugin(demoPlugin);
 
-// Register all routes
-server.use(counterRoutes);
-server.use(cacheRoutes);
-server.use(jobsRoutes);
-server.use(cronRoutes);
-server.use(ratelimitRoutes);
-server.use(eventsRoutes);
-server.use(sseRoutes);
-
+// Register routes
+server.use(demoRoutes);
 
+// Handle DONKEYLABS_GENERATE mode for CLI type generation
+if (process.env.DONKEYLABS_GENERATE === "1") {
+  const routes = demoRoutes.getRoutes().map((route) => ({
+    name: route.name,
+    handler: route.handler || "typed",
+    inputType: route.input ? "(generated)" : undefined,
+    outputType: route.output ? "(generated)" : undefined,
+  }));
+  console.log(JSON.stringify({ routes }));
+  process.exit(0);
+}

package/templates/sveltekit-app/src/server/routes/demo.ts

@@ -0,0 +1,268 @@
+/**
+ * Demo Router - Showcases @donkeylabs/server core features
+ *
+ * This single router demonstrates:
+ * - Counter: Basic state management via plugin service
+ * - Cache: In-memory caching with TTL
+ * - SSE: Server-sent events broadcasting
+ * - Jobs: Background job queue
+ * - Events: Pub/sub event system
+ * - Rate Limiting: Request throttling
+ * - Cron: Scheduled tasks
+ */
+
+import { createRouter, defineRoute } from "@donkeylabs/server";
+import { z } from "zod";
+
+const demo = createRouter("api");
+
+// =============================================================================
+// COUNTER - Uses plugin service for state
+// =============================================================================
+
+demo.route("counter.get").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.getCount() };
+    },
+  })
+);
+
+demo.route("counter.increment").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.increment() };
+    },
+  })
+);
+
+demo.route("counter.decrement").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      return { count: ctx.plugins.demo.decrement() };
+    },
+  })
+);
+
+demo.route("counter.reset").typed(
+  defineRoute({
+    output: z.object({ count: z.number() }),
+    handle: async (_, ctx) => {
+      ctx.plugins.demo.reset();
+      return { count: 0 };
+    },
+  })
+);
+
+// =============================================================================
+// CACHE - In-memory caching
+// =============================================================================
+
+demo.route("cache.set").typed(
+  defineRoute({
+    input: z.object({
+      key: z.string(),
+      value: z.any(),
+      ttl: z.number().optional(),
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      ctx.core.cache.set(input.key, input.value, input.ttl);
+      return { success: true };
+    },
+  })
+);
+
+demo.route("cache.get").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ value: z.any().optional(), exists: z.boolean() }),
+    handle: async (input, ctx) => {
+      const value = ctx.core.cache.get(input.key);
+      return { value, exists: value !== undefined };
+    },
+  })
+);
+
+demo.route("cache.delete").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      ctx.core.cache.delete(input.key);
+      return { success: true };
+    },
+  })
+);
+
+demo.route("cache.keys").typed(
+  defineRoute({
+    output: z.object({ keys: z.array(z.string()) }),
+    handle: async (_, ctx) => {
+      return { keys: ctx.core.cache.keys() };
+    },
+  })
+);
+
+// =============================================================================
+// SSE - Server-Sent Events
+// =============================================================================
+
+demo.route("sse.broadcast").typed(
+  defineRoute({
+    input: z.object({
+      channel: z.string().default("events"),
+      event: z.string().default("manual"),
+      data: z.any(),
+    }),
+    output: z.object({ success: z.boolean(), recipients: z.number() }),
+    handle: async (input, ctx) => {
+      const count = ctx.core.sse.broadcast(input.channel, input.event, input.data);
+      return { success: true, recipients: count };
+    },
+  })
+);
+
+demo.route("sse.clients").typed(
+  defineRoute({
+    output: z.object({ total: z.number(), byChannel: z.number() }),
+    handle: async (_, ctx) => {
+      const stats = ctx.core.sse.getStats();
+      return { total: stats.totalClients, byChannel: stats.clientsByChannel.events || 0 };
+    },
+  })
+);
+
+// =============================================================================
+// JOBS - Background job queue
+// =============================================================================
+
+demo.route("jobs.enqueue").typed(
+  defineRoute({
+    input: z.object({
+      name: z.string().default("demo-job"),
+      data: z.record(z.any()).optional(),
+      delay: z.number().optional(),
+    }),
+    output: z.object({ success: z.boolean(), jobId: z.string() }),
+    handle: async (input, ctx) => {
+      const jobId = await ctx.core.jobs.enqueue(input.name, input.data || {}, { delay: input.delay });
+      return { success: true, jobId };
+    },
+  })
+);
+
+demo.route("jobs.stats").typed(
+  defineRoute({
+    output: z.object({
+      pending: z.number(),
+      running: z.number(),
+      completed: z.number(),
+      failed: z.number(),
+    }),
+    handle: async (_, ctx) => {
+      const stats = ctx.core.jobs.getStats();
+      return {
+        pending: stats.pending,
+        running: stats.processing,
+        completed: stats.completed,
+        failed: stats.failed,
+      };
+    },
+  })
+);
+
+// =============================================================================
+// EVENTS - Pub/sub system
+// =============================================================================
+
+demo.route("events.emit").typed(
+  defineRoute({
+    input: z.object({
+      event: z.string(),
+      data: z.record(z.any()).optional(),
+    }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      await ctx.core.events.emit(input.event, input.data || {});
+      return { success: true };
+    },
+  })
+);
+
+// =============================================================================
+// RATE LIMITING
+// =============================================================================
+
+demo.route("ratelimit.check").typed(
+  defineRoute({
+    input: z.object({
+      key: z.string(),
+      limit: z.number().default(10),
+      window: z.number().default(60),
+    }),
+    output: z.object({
+      allowed: z.boolean(),
+      remaining: z.number(),
+      resetAt: z.string(),
+    }),
+    handle: async (input, ctx) => {
+      const result = ctx.core.rateLimiter.check(input.key, input.limit, input.window * 1000);
+      return {
+        allowed: result.allowed,
+        remaining: result.remaining,
+        resetAt: new Date(result.resetAt).toISOString(),
+      };
+    },
+  })
+);
+
+demo.route("ratelimit.reset").typed(
+  defineRoute({
+    input: z.object({ key: z.string() }),
+    output: z.object({ success: z.boolean() }),
+    handle: async (input, ctx) => {
+      ctx.core.rateLimiter.reset(input.key);
+      return { success: true };
+    },
+  })
+);
+
+// =============================================================================
+// CRON - Scheduled tasks info
+// =============================================================================
+
+demo.route("cron.list").typed(
+  defineRoute({
+    output: z.object({
+      tasks: z.array(
+        z.object({
+          id: z.string(),
+          name: z.string(),
+          expression: z.string(),
+          enabled: z.boolean(),
+          lastRun: z.string().optional(),
+          nextRun: z.string().optional(),
+        })
+      ),
+    }),
+    handle: async (_, ctx) => {
+      const jobs = ctx.core.cron.list();
+      return {
+        tasks: jobs.map((j, i) => ({
+          id: `cron-${i}`,
+          name: j.name,
+          expression: j.schedule,
+          enabled: true,
+          lastRun: j.lastRun?.toISOString(),
+          nextRun: j.nextRun?.toISOString(),
+        })),
+      };
+    },
+  })
+);
+
+export default demo;