@donkeylabs/cli 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",

package/src/commands/init.ts

@@ -8,6 +8,7 @@ import { mkdir, writeFile, readFile, readdir, copyFile, stat } from "node:fs/pro
 import { join, resolve, dirname, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
 import pc from "picocolors";
 import prompts from "prompts";
 
@@ -38,21 +39,45 @@ const RENAME_MAP: Record<string, string> = {
 
 export async function initCommand(args: string[]) {
   // Parse --type flag if provided
-  let projectDir = ".";
+  let projectDir: string | null = null;
   let typeArg: string | null = null;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--type" && args[i + 1]) {
       typeArg = args[i + 1];
       i++; // skip next arg
-    } else if (!args[i].startsWith("-")) {
-      projectDir = args[i];
+    } else if (!args[i]?.startsWith("-")) {
+      projectDir = args[i] ?? null;
     }
   }
 
-  const targetDir = resolve(process.cwd(), projectDir);
+  console.log(pc.bold("\n🚀 Create a new @donkeylabs/server project\n"));
+
+  // If no project directory provided, prompt for it
+  if (!projectDir) {
+    const { name } = await prompts({
+      type: "text",
+      name: "name",
+      message: "Project name:",
+      initial: "my-donkeylabs-app",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+        if (!/^[a-zA-Z0-9-_]+$/.test(value)) {
+          return "Project name can only contain letters, numbers, dashes, and underscores";
+        }
+        return true;
+      },
+    });
+
+    if (!name) {
+      console.log(pc.yellow("Cancelled."));
+      return;
+    }
 
-  console.log(pc.bold("\nInitializing @donkeylabs/server project...\n"));
+    projectDir = name;
+  }
+
+  const targetDir = resolve(process.cwd(), projectDir!);
 
   let projectType: ProjectType;
 
@@ -130,45 +155,140 @@ export async function initCommand(args: string[]) {
     await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   }
 
-  // Print success message
-  if (projectType === "server") {
-    console.log(`
-${pc.bold(pc.green("Success!"))} Server project initialized.
+  console.log(pc.green("\n✓ Project files created\n"));
 
-${pc.bold("Next steps:")}
-  1. Install dependencies:
-     ${pc.cyan("bun install")}
+  // Auto-install dependencies
+  console.log(pc.cyan("Installing dependencies...\n"));
+  const installSuccess = await runCommand("bun", ["install"], targetDir);
 
-  2. Start development:
-     ${pc.cyan("bun run dev")}
-
-  3. Generate types after adding plugins:
-     ${pc.cyan("bun run gen:types")}
-`);
+  if (!installSuccess) {
+    console.log(pc.yellow("\n⚠ Dependency installation failed."));
+    console.log(pc.dim("  Run 'bun install' manually to install dependencies.\n"));
   } else {
-    console.log(`
-${pc.bold(pc.green("Success!"))} SvelteKit project initialized.
+    console.log(pc.green("\n✓ Dependencies installed\n"));
+  }
 
-${pc.bold("Next steps:")}
-  1. Install dependencies:
-     ${pc.cyan("bun install")}
+  // Ask about MCP setup
+  const { setupMcp } = await prompts({
+    type: "confirm",
+    name: "setupMcp",
+    message: `Setup MCP for AI-assisted development? ${pc.dim("(Highly recommended)")}`,
+    initial: true,
+  });
+
+  if (setupMcp) {
+    // Ask which IDE
+    const { ide } = await prompts({
+      type: "select",
+      name: "ide",
+      message: "Which AI IDE are you using?",
+      choices: [
+        { title: "Claude Code", value: "claude", description: "Anthropic's Claude Code CLI" },
+        { title: "Cursor", value: "cursor", description: "Cursor AI IDE" },
+        { title: "Windsurf", value: "windsurf", description: "Codeium Windsurf" },
+        { title: "Other / Skip instructions", value: "skip" },
+      ],
+    });
 
-  2. Start development:
-     ${pc.cyan("bun run dev")}
+    // Install @donkeylabs/mcp
+    console.log(pc.cyan("\nInstalling @donkeylabs/mcp...\n"));
+    const mcpInstallSuccess = await runCommand("bun", ["add", "-d", "@donkeylabs/mcp"], targetDir);
+
+    if (mcpInstallSuccess) {
+      console.log(pc.green("✓ Installed @donkeylabs/mcp\n"));
+    }
+
+    // Create .mcp.json
+    const mcpConfig = {
+      mcpServers: {
+        donkeylabs: {
+          command: "bunx",
+          args: ["@donkeylabs/mcp"],
+          cwd: "${workspaceFolder}",
+        },
+      },
+    };
+
+    await writeFile(join(targetDir, ".mcp.json"), JSON.stringify(mcpConfig, null, 2) + "\n");
+    console.log(pc.green("✓ Created .mcp.json\n"));
+
+    // Show IDE-specific instructions
+    if (ide === "claude") {
+      console.log(pc.cyan("Claude Code Setup:"));
+      console.log(pc.dim("─".repeat(40)));
+      console.log(`
+The .mcp.json file has been created in your project.
+Claude Code will automatically detect and use this configuration.
+
+${pc.bold("To verify:")}
+  1. Open Claude Code in this project directory
+  2. The MCP tools should be available automatically
+  3. Try asking Claude to "list plugins" or "get project info"
+`);
+    } else if (ide === "cursor") {
+      console.log(pc.cyan("Cursor 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 from .mcp.json
+  4. Restart Cursor to apply changes
+`);
+    } else if (ide === "windsurf") {
+      console.log(pc.cyan("Windsurf 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 from .mcp.json
+`);
+    }
+  }
 
-  3. Build for production:
-     ${pc.cyan("bun run build")}
+  // Print final success message
+  console.log(pc.bold(pc.green("\n🎉 Project ready!\n")));
 
-  4. Preview production build:
-     ${pc.cyan("bun run preview")}
+  if (projectType === "server") {
+    console.log(`${pc.bold("Start development:")}
+  ${pc.cyan("cd " + (projectDir !== "." ? projectDir : ""))}
+  ${pc.cyan("bun run dev")}
+`);
+  } else {
+    console.log(`${pc.bold("Start development:")}
+  ${projectDir !== "." ? pc.cyan("cd " + projectDir) + "\n  " : ""}${pc.cyan("bun run dev")}
 
 ${pc.bold("Project structure:")}
-  src/server/index.ts    - Your @donkeylabs/server API
-  src/lib/api.ts         - Typed API client
-  src/routes/            - SvelteKit pages
-  src/hooks.server.ts    - Server hooks for SSR
+  src/server/          - @donkeylabs/server API
+  src/lib/api.ts       - Typed API client
+  src/routes/          - SvelteKit pages
 `);
   }
+
+  if (setupMcp) {
+    console.log(pc.dim("MCP is configured. Your AI assistant can now help you build!"));
+  }
+}
+
+/**
+ * Run a command and return success status
+ */
+async function runCommand(cmd: string, args: string[], cwd: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      stdio: "inherit",
+      cwd,
+    });
+
+    child.on("close", (code) => {
+      resolve(code === 0);
+    });
+
+    child.on("error", () => {
+      resolve(false);
+    });
+  });
 }
 
 /**

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/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.2",
+    "@donkeylabs/adapter-sveltekit": "^0.4.2",
+    "@donkeylabs/server": "^0.4.2",
     "bits-ui": "^2.15.4",
     "clsx": "^2.1.1",
     "kysely": "^0.27.6",