@donkeylabs/cli 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "description": "CLI for @donkeylabs/server - project scaffolding and code generation",
   "main": "./src/index.ts",
@@ -24,6 +24,9 @@
     "typecheck": "bun --bun tsc --noEmit"
   },
   "dependencies": {
+    "kysely": "^0.27.0",
+    "kysely-bun-sqlite": "^0.3.0",
+    "kysely-codegen": "^0.17.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2"
   },

package/src/commands/generate.ts

@@ -1,8 +1,12 @@
-import { readdir, writeFile, readFile, mkdir } from "node:fs/promises";
+import { readdir, writeFile, readFile, mkdir, unlink } from "node:fs/promises";
 import { join, relative, dirname, basename } from "node:path";
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import pc from "picocolors";
+import { Kysely, Migrator, FileMigrationProvider } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
+import { generate, KyselyBunSqliteDialect } from "kysely-codegen";
 
 interface DonkeylabsConfig {
   plugins: string[];
@@ -325,6 +329,8 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     return [];
   }
 
+  const TIMEOUT_MS = 10000; // 10 second timeout
+
   return new Promise((resolve) => {
     const child = spawn("bun", [fullPath], {
       env: { ...process.env, DONKEYLABS_GENERATE: "1" },
@@ -334,6 +340,16 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
 
     let stdout = "";
     let stderr = "";
+    let timedOut = false;
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      console.warn(pc.yellow(`Route extraction timed out after ${TIMEOUT_MS / 1000}s`));
+      console.warn(pc.dim("Make sure your entry file handles DONKEYLABS_GENERATE=1 and calls process.exit(0)"));
+      resolve([]);
+    }, TIMEOUT_MS);
 
     child.stdout?.on("data", (data) => {
       stdout += data.toString();
@@ -344,6 +360,9 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     });
 
     child.on("close", (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return; // Already resolved
+
       if (code !== 0) {
         console.warn(pc.yellow(`Failed to extract routes from server (exit code ${code})`));
         if (stderr) console.warn(pc.dim(stderr));
@@ -374,12 +393,105 @@ async function extractRoutesFromServer(entryPath: string): Promise<RouteInfo[]>
     });
 
     child.on("error", (err) => {
+      clearTimeout(timeout);
       console.warn(pc.yellow(`Failed to run entry file: ${err.message}`));
       resolve([]);
     });
   });
 }
 
+/**
+ * Generate schema.ts from plugin migrations using kysely-codegen
+ */
+async function generatePluginSchemas(
+  plugins: { name: string; path: string; exportName: string }[]
+): Promise<string[]> {
+  const generated: string[] = [];
+
+  for (const plugin of plugins) {
+    const pluginDir = dirname(join(process.cwd(), plugin.path));
+    const migrationsDir = join(pluginDir, "migrations");
+
+    // Skip plugins without migrations folder
+    if (!existsSync(migrationsDir)) {
+      continue;
+    }
+
+    // Check if there are any migration files
+    const migrationFiles = await readdir(migrationsDir);
+    const hasMigrations = migrationFiles.some(
+      (f) => f.endsWith(".ts") && !f.endsWith(".d.ts")
+    );
+
+    if (!hasMigrations) {
+      continue;
+    }
+
+    console.log(pc.dim(`  Generating schema for ${plugin.name}...`));
+
+    const dbPath = join(process.cwd(), `.temp_schema_${plugin.name}.db`);
+
+    try {
+      // Create temp SQLite database
+      const db = new Kysely<any>({
+        dialect: new BunSqliteDialect({
+          database: new Database(dbPath),
+        }),
+      });
+
+      // Run migrations using Kysely's FileMigrationProvider
+      const migrator = new Migrator({
+        db,
+        provider: new FileMigrationProvider({
+          fs: await import("node:fs/promises"),
+          path: await import("node:path"),
+          migrationFolder: migrationsDir,
+        }),
+      });
+
+      const { error } = await migrator.migrateToLatest();
+
+      if (error) {
+        console.warn(
+          pc.yellow(`  Warning: Migration failed for ${plugin.name}: ${error}`)
+        );
+        await db.destroy();
+        try {
+          await unlink(dbPath);
+        } catch {}
+        continue;
+      }
+
+      // Generate schema.ts using kysely-codegen
+      const schemaPath = join(pluginDir, "schema.ts");
+
+      await generate({
+        db,
+        outFile: schemaPath,
+        dialect: new KyselyBunSqliteDialect(),
+      });
+
+      generated.push(plugin.name);
+
+      // Cleanup
+      await db.destroy();
+      try {
+        await unlink(dbPath);
+      } catch {}
+    } catch (err: any) {
+      console.warn(
+        pc.yellow(`  Warning: Schema generation failed for ${plugin.name}: ${err.message}`)
+      );
+      // Cleanup on error
+      try {
+        await unlink(dbPath);
+      } catch {}
+    }
+  }
+
+  return generated;
+}
+
 export async function generateCommand(_args: string[]): Promise<void> {
   const config = await loadConfig();
   const outDir = config.outDir || ".@donkeylabs/server";
@@ -390,6 +502,15 @@ export async function generateCommand(_args: string[]): Promise<void> {
   const plugins = await findPlugins(config.plugins);
   const fileRoutes = await findRoutes(config.routes || "./src/routes/**/schema.ts");
 
+  // Generate schema.ts from migrations for plugins that have them
+  const schemaPlugins = await generatePluginSchemas(plugins);
+  if (schemaPlugins.length > 0) {
+    console.log(
+      pc.green("Generated schemas:"),
+      schemaPlugins.map((p) => pc.dim(p)).join(", ")
+    );
+  }
+
   // Extract routes by running the server with DONKEYLABS_GENERATE=1
   const entryPath = config.entry || "./src/index.ts";
   const serverRoutes = await extractRoutesFromServer(entryPath);

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;
+    }
+
+    projectDir = name;
+  }
 
-  console.log(pc.bold("\nInitializing @donkeylabs/server project...\n"));
+  const targetDir = resolve(process.cwd(), projectDir!);
 
   let projectType: ProjectType;
 
@@ -130,45 +155,143 @@ 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.
-
-${pc.bold("Next steps:")}
-  1. Install dependencies:
-     ${pc.cyan("bun install")}
+  console.log(pc.green("\n✓ Project files created\n"));
 
-  2. Start development:
-     ${pc.cyan("bun run dev")}
+  // Auto-install dependencies
+  console.log(pc.cyan("Installing dependencies...\n"));
+  const installSuccess = await runCommand("bun", ["install"], targetDir);
 
-  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")}
+    // Copy CLAUDE.md and docs/ from @donkeylabs/server to project root
+    await copyDocsFromServer(targetDir);
+  }
 
-  2. Start development:
-     ${pc.cyan("bun run dev")}
+  // 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" },
+      ],
+    });
+
+    // Install @donkeylabs/mcp
+    console.log(pc.cyan("\nInstalling @donkeylabs/mcp...\n"));
+    const mcpInstallSuccess = await runCommand("bun", ["add", "-d", "@donkeylabs/mcp"], targetDir);
 
-  3. Build for production:
-     ${pc.cyan("bun run build")}
+    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
+`);
+    }
+  }
 
-  4. Preview production build:
-     ${pc.cyan("bun run preview")}
+  // Print final success message
+  console.log(pc.bold(pc.green("\n🎉 Project ready!\n")));
+
+  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);
+    });
+  });
 }
 
 /**
@@ -199,3 +322,31 @@ async function copyDirectory(src: string, dest: string): Promise<void> {
     }
   }
 }
+
+/**
+ * Copy CLAUDE.md and docs/ from @donkeylabs/server to project root
+ * for AI-assisted development
+ */
+async function copyDocsFromServer(targetDir: string): Promise<void> {
+  const serverPkgPath = join(targetDir, "node_modules", "@donkeylabs", "server");
+
+  if (!existsSync(serverPkgPath)) {
+    return; // Server package not installed
+  }
+
+  // Copy CLAUDE.md
+  const claudeMdSrc = join(serverPkgPath, "CLAUDE.md");
+  if (existsSync(claudeMdSrc)) {
+    const claudeMdDest = join(targetDir, "CLAUDE.md");
+    await copyFile(claudeMdSrc, claudeMdDest);
+    console.log(pc.green("  Created:"), "CLAUDE.md (AI instructions)");
+  }
+
+  // Copy docs/ directory
+  const docsSrc = join(serverPkgPath, "docs");
+  if (existsSync(docsSrc)) {
+    const docsDest = join(targetDir, "docs");
+    await copyDirectory(docsSrc, docsDest);
+    console.log(pc.green("  Created:"), "docs/ (detailed documentation)");
+  }
+}