@donkeylabs/cli 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/cli",
-  "version": "0.4.0",
+  "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/bun.lock

@@ -4,9 +4,9 @@
     "": {
       "name": "my-sveltekit-app",
       "dependencies": {
-        "@donkeylabs/adapter-sveltekit": "0.1.2",
-        "@donkeylabs/cli": "0.1.1",
-        "@donkeylabs/server": "0.3.1",
+        "@donkeylabs/adapter-sveltekit": "^0.4.0",
+        "@donkeylabs/cli": "^0.4.0",
+        "@donkeylabs/server": "^0.4.0",
         "bits-ui": "^2.15.4",
         "clsx": "^2.1.1",
         "kysely": "^0.27.6",
@@ -28,11 +28,11 @@
     },
   },
   "packages": {
-    "@donkeylabs/adapter-sveltekit": ["@donkeylabs/adapter-sveltekit@0.1.2", "", { "peerDependencies": { "@donkeylabs/server": "*", "@sveltejs/kit": "^2.0.0" } }, "sha512-VvjRQ8XZQw6T+DYLjq5Sjz+u1k8LqkcZOTVZuB4SfC6TdGxGD7CkU/7NQ7gwlk/2pDNP7tqwMD3yGfP86A6j4Q=="],
+    "@donkeylabs/adapter-sveltekit": ["@donkeylabs/adapter-sveltekit@0.4.0", "", { "peerDependencies": { "@donkeylabs/server": "^0.4.0", "@sveltejs/kit": "^2.0.0" } }, "sha512-J1kcwhp8X0egAhjC/HyxEizR3aEP7ea08rfAh0++C31UldM3ahAjO3Ux0QYp+fAV76lh8mKrDNAWIsKTyPmqNg=="],
 
-    "@donkeylabs/cli": ["@donkeylabs/cli@0.1.1", "", { "dependencies": { "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "@donkeylabs/server": "*" }, "bin": { "donkeylabs": "src/index.ts" } }, "sha512-lMGXz/KGCoN15siUf05Sl3NxoR5Qn0h44gXqRocHr51SLV8R/o2On2ELF4iHdTNV9hPJp3sjhNmcO3mMzQex2A=="],
+    "@donkeylabs/cli": ["@donkeylabs/cli@0.4.0", "", { "dependencies": { "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "@donkeylabs/server": "^0.4.0" }, "bin": { "donkeylabs": "src/index.ts" } }, "sha512-5Y5oXOzFrhdPMAprij5d/D1r9tcjDRuZo1Ud3zSkGTvVxfejMQjbzrB8KmxFM4+7TBJdjuduvhNewL5V6XnUlA=="],
 
-    "@donkeylabs/server": ["@donkeylabs/server@0.3.1", "", { "dependencies": { "@modelcontextprotocol/sdk": "^1.25.2", "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "kysely": "^0.27.0 || ^0.28.0", "typescript": "^5", "zod": "^3.20.0" }, "bin": { "donkeylabs-mcp": "mcp/server.ts" } }, "sha512-rpYKD7dKNwpcw51aO/pL1Zh1r6FlAqp0UIUJ+9nV1Cm/4hKq6WQHM/AtmPhM25ZRvnSbriB4X8o28UVJR8dN2w=="],
+    "@donkeylabs/server": ["@donkeylabs/server@0.4.0", "", { "dependencies": { "@modelcontextprotocol/sdk": "^1.25.2", "picocolors": "^1.1.1", "prompts": "^2.4.2" }, "peerDependencies": { "kysely": "^0.27.0 || ^0.28.0", "typescript": "^5", "zod": "^3.20.0" } }, "sha512-Nr7kgKtyqM5EDFTmUL2kyEqCW/NeJiQgYQL4Y3DnphM9rgHz07Qi2mgPs8McYFvrWGUVFRMvzXa6CZILY896bw=="],
 
     "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.27.2", "", { "os": "aix", "cpu": "ppc64" }, "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw=="],
 

package/templates/sveltekit-app/package.json

@@ -24,9 +24,9 @@
     "vite": "^7.2.6"
   },
   "dependencies": {
-    "@donkeylabs/cli": "0.1.1",
-    "@donkeylabs/adapter-sveltekit": "0.1.2",
-    "@donkeylabs/server": "0.3.2",
+    "@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",

package/templates/sveltekit-app/src/lib/api.ts

@@ -27,101 +27,112 @@ export { type ServerContext as AppContext } from "@donkeylabs/server";
 // ============================================
 
 export namespace Routes {
-  export namespace Counter {
-    export namespace get {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+  export namespace Api {
+    export namespace Counter {
+      export namespace Get {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   count: number;
 }>;
-    }
+      }
+      export type Get = { Input: Get.Input; Output: Get.Output };
 
-    export namespace increment {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Increment {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   count: number;
 }>;
-    }
+      }
+      export type Increment = { Input: Increment.Input; Output: Increment.Output };
 
-    export namespace decrement {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Decrement {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   count: number;
 }>;
-    }
+      }
+      export type Decrement = { Input: Decrement.Input; Output: Decrement.Output };
 
-    export namespace reset {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Reset {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   count: number;
 }>;
+      }
+      export type Reset = { Input: Reset.Input; Output: Reset.Output };
     }
-  }
 
-  export namespace Cache {
-    export namespace set {
-      export type Input = Expand<{
+    export namespace Cache {
+      export namespace Set {
+        export type Input = Expand<{
   key: string;
   value: any;
   ttl?: number;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   success: boolean;
 }>;
-    }
+      }
+      export type Set = { Input: Set.Input; Output: Set.Output };
 
-    export namespace get {
-      export type Input = Expand<{
+      export namespace Get {
+        export type Input = Expand<{
   key: string;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   value?: any;
   exists: boolean;
 }>;
-    }
+      }
+      export type Get = { Input: Get.Input; Output: Get.Output };
 
-    export namespace delete {
-      export type Input = Expand<{
+      export namespace Delete {
+        export type Input = Expand<{
   key: string;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   success: boolean;
 }>;
-    }
+      }
+      export type Delete = { Input: Delete.Input; Output: Delete.Output };
 
-    export namespace keys {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Keys {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   keys: string[];
 }>;
+      }
+      export type Keys = { Input: Keys.Input; Output: Keys.Output };
     }
-  }
 
-  export namespace Jobs {
-    export namespace enqueue {
-      export type Input = Expand<{
+    export namespace Jobs {
+      export namespace Enqueue {
+        export type Input = Expand<{
   name: string;
   data: any;
   delay?: number;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   jobId: string;
 }>;
-    }
+      }
+      export type Enqueue = { Input: Enqueue.Input; Output: Enqueue.Output };
 
-    export namespace stats {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Stats {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   pending: number;
   running: number;
   completed: number;
 }>;
+      }
+      export type Stats = { Input: Stats.Input; Output: Stats.Output };
     }
-  }
 
-  export namespace Cron {
-    export namespace list {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+    export namespace Cron {
+      export namespace List {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   tasks: {
   id: string;
   name: string;
@@ -131,64 +142,71 @@ export namespace Routes {
   nextRun?: string;
 }[];
 }>;
+      }
+      export type List = { Input: List.Input; Output: List.Output };
     }
-  }
 
-  export namespace Ratelimit {
-    export namespace check {
-      export type Input = Expand<{
+    export namespace Ratelimit {
+      export namespace Check {
+        export type Input = Expand<{
   key: string;
   limit: number;
   window: number;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   allowed: boolean;
   remaining: number;
   resetAt: Date;
 }>;
-    }
+      }
+      export type Check = { Input: Check.Input; Output: Check.Output };
 
-    export namespace reset {
-      export type Input = Expand<{
+      export namespace Reset {
+        export type Input = Expand<{
   key: string;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   success: boolean;
 }>;
+      }
+      export type Reset = { Input: Reset.Input; Output: Reset.Output };
     }
-  }
 
-  export namespace Events {
-    export namespace emit {
-      export type Input = Expand<{
+    export namespace Events {
+      export namespace Emit {
+        export type Input = Expand<{
   event: string;
   data: any;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   success: boolean;
 }>;
+      }
+      export type Emit = { Input: Emit.Input; Output: Emit.Output };
     }
-  }
 
-  export namespace Sse {
-    export namespace broadcast {
-      export type Input = Expand<{
+    export namespace Sse {
+      export namespace Broadcast {
+        export type Input = Expand<{
   channel: string;
   event: string;
   data: any;
 }>;
-      export type Output = Expand<{
+        export type Output = Expand<{
   success: boolean;
   recipients: number;
 }>;
-    }
+      }
+      export type Broadcast = { Input: Broadcast.Input; Output: Broadcast.Output };
 
-    export namespace clients {
-      export type Input = Expand<Record<string, never>>;
-      export type Output = Expand<{
+      export namespace Clients {
+        export type Input = Expand<Record<string, never>>;
+        export type Output = Expand<{
   total: number;
   byChannel: number;
 }>;
+      }
+      export type Clients = { Input: Clients.Input; Output: Clients.Output };
     }
   }
 }
@@ -202,41 +220,37 @@ export class ApiClient extends UnifiedApiClientBase {
     super(options);
   }
 
-  counter = {
-    get: (input: Routes.Counter.get.Input): Promise<Routes.Counter.get.Output> => this.request("api.counter.get", input),
-    increment: (input: Routes.Counter.increment.Input): Promise<Routes.Counter.increment.Output> => this.request("api.counter.increment", input),
-    decrement: (input: Routes.Counter.decrement.Input): Promise<Routes.Counter.decrement.Output> => this.request("api.counter.decrement", input),
-    reset: (input: Routes.Counter.reset.Input): Promise<Routes.Counter.reset.Output> => this.request("api.counter.reset", input)
-  };
-
-  cache = {
-    set: (input: Routes.Cache.set.Input): Promise<Routes.Cache.set.Output> => this.request("api.cache.set", input),
-    get: (input: Routes.Cache.get.Input): Promise<Routes.Cache.get.Output> => this.request("api.cache.get", input),
-    delete: (input: Routes.Cache.delete.Input): Promise<Routes.Cache.delete.Output> => this.request("api.cache.delete", input),
-    keys: (input: Routes.Cache.keys.Input): Promise<Routes.Cache.keys.Output> => this.request("api.cache.keys", input)
-  };
-
-  jobs = {
-    enqueue: (input: Routes.Jobs.enqueue.Input): Promise<Routes.Jobs.enqueue.Output> => this.request("api.jobs.enqueue", input),
-    stats: (input: Routes.Jobs.stats.Input): Promise<Routes.Jobs.stats.Output> => this.request("api.jobs.stats", input)
-  };
-
-  cron = {
-    list: (input: Routes.Cron.list.Input): Promise<Routes.Cron.list.Output> => this.request("api.cron.list", input)
-  };
-
-  ratelimit = {
-    check: (input: Routes.Ratelimit.check.Input): Promise<Routes.Ratelimit.check.Output> => this.request("api.ratelimit.check", input),
-    reset: (input: Routes.Ratelimit.reset.Input): Promise<Routes.Ratelimit.reset.Output> => this.request("api.ratelimit.reset", input)
-  };
-
-  events = {
-    emit: (input: Routes.Events.emit.Input): Promise<Routes.Events.emit.Output> => this.request("api.events.emit", input)
-  };
-
-  sse = {
-    broadcast: (input: Routes.Sse.broadcast.Input): Promise<Routes.Sse.broadcast.Output> => this.request("api.sse.broadcast", input),
-    clients: (input: Routes.Sse.clients.Input): Promise<Routes.Sse.clients.Output> => this.request("api.sse.clients", input)
+  api = {
+    counter: {
+      get: (input: Routes.Api.Counter.Get.Input): Promise<Routes.Api.Counter.Get.Output> => this.request("api.counter.get", input),
+      increment: (input: Routes.Api.Counter.Increment.Input): Promise<Routes.Api.Counter.Increment.Output> => this.request("api.counter.increment", input),
+      decrement: (input: Routes.Api.Counter.Decrement.Input): Promise<Routes.Api.Counter.Decrement.Output> => this.request("api.counter.decrement", input),
+      reset: (input: Routes.Api.Counter.Reset.Input): Promise<Routes.Api.Counter.Reset.Output> => this.request("api.counter.reset", input)
+    },
+    cache: {
+      set: (input: Routes.Api.Cache.Set.Input): Promise<Routes.Api.Cache.Set.Output> => this.request("api.cache.set", input),
+      get: (input: Routes.Api.Cache.Get.Input): Promise<Routes.Api.Cache.Get.Output> => this.request("api.cache.get", input),
+      delete: (input: Routes.Api.Cache.Delete.Input): Promise<Routes.Api.Cache.Delete.Output> => this.request("api.cache.delete", input),
+      keys: (input: Routes.Api.Cache.Keys.Input): Promise<Routes.Api.Cache.Keys.Output> => this.request("api.cache.keys", input)
+    },
+    jobs: {
+      enqueue: (input: Routes.Api.Jobs.Enqueue.Input): Promise<Routes.Api.Jobs.Enqueue.Output> => this.request("api.jobs.enqueue", input),
+      stats: (input: Routes.Api.Jobs.Stats.Input): Promise<Routes.Api.Jobs.Stats.Output> => this.request("api.jobs.stats", input)
+    },
+    cron: {
+      list: (input: Routes.Api.Cron.List.Input): Promise<Routes.Api.Cron.List.Output> => this.request("api.cron.list", input)
+    },
+    ratelimit: {
+      check: (input: Routes.Api.Ratelimit.Check.Input): Promise<Routes.Api.Ratelimit.Check.Output> => this.request("api.ratelimit.check", input),
+      reset: (input: Routes.Api.Ratelimit.Reset.Input): Promise<Routes.Api.Ratelimit.Reset.Output> => this.request("api.ratelimit.reset", input)
+    },
+    events: {
+      emit: (input: Routes.Api.Events.Emit.Input): Promise<Routes.Api.Events.Emit.Output> => this.request("api.events.emit", input)
+    },
+    sse: {
+      broadcast: (input: Routes.Api.Sse.Broadcast.Input): Promise<Routes.Api.Sse.Broadcast.Output> => this.request("api.sse.broadcast", input),
+      clients: (input: Routes.Api.Sse.Clients.Input): Promise<Routes.Api.Sse.Clients.Output> => this.request("api.sse.clients", input)
+    }
   };
 }
 

package/templates/sveltekit-app/src/routes/+page.server.ts

@@ -8,7 +8,7 @@ export const load: PageServerLoad = async ({ locals }) => {
 
   try {
     // Direct service call through typed client
-    const result = await client.counter.get({});
+    const result = await client.api.counter.get({});
     return {
       count: result.count,
       loadedAt: new Date().toISOString(),

package/templates/sveltekit-app/src/routes/+page.svelte

@@ -72,37 +72,37 @@
   ) {
     counterLoading = true;
 
-    const result = await client.counter[action]({});
+    const result = await client.api.counter[action]({});
     count = result.count;
     counterLoading = false;
   }
 
   // Cache actions - using typed client
   async function cacheSet() {
-    await client.cache.set({ key: cacheKey, value: cacheValue, ttl: cacheTTL });
+    await client.api.cache.set({ key: cacheKey, value: cacheValue, ttl: cacheTTL });
     cacheResult = { action: "set", success: true };
     refreshCacheKeys();
   }
 
   async function cacheGet() {
-    cacheResult = await client.cache.get({ key: cacheKey });
+    cacheResult = await client.api.cache.get({ key: cacheKey });
     refreshCacheKeys();
   }
 
   async function cacheDelete() {
-    await client.cache.delete({ key: cacheKey });
+    await client.api.cache.delete({ key: cacheKey });
     cacheResult = { action: "deleted", success: true };
     refreshCacheKeys();
   }
 
   async function refreshCacheKeys() {
-    const result = await client.cache.keys({});
+    const result = await client.api.cache.keys({});
     cacheKeys = result.keys || [];
   }
 
   // Jobs actions - using typed client
   async function enqueueJob() {
-    const result = (await client.jobs.enqueue({
+    const result = (await client.api.jobs.enqueue({
       name: "demo-job",
       data: { message: jobMessage },
       delay: jobDelay > 0 ? jobDelay : undefined,
@@ -112,7 +112,7 @@
   }
 
   async function refreshJobStats() {
-    jobStats = (await client.jobs.stats({})) as {
+    jobStats = (await client.api.jobs.stats({})) as {
       pending: number;
       running: number;
       completed: number;
@@ -121,7 +121,7 @@
 
   // Rate limiter actions - using typed client
   async function checkRateLimit() {
-    rateLimitResult = await client.ratelimit.check({
+    rateLimitResult = await client.api.ratelimit.check({
       key: rateLimitKey,
       limit: rateLimitMax,
       window: rateLimitWindow,
@@ -129,13 +129,13 @@
   }
 
   async function resetRateLimit() {
-    await client.ratelimit.reset({ key: rateLimitKey });
+    await client.api.ratelimit.reset({ key: rateLimitKey });
     rateLimitResult = { reset: true, message: "Rate limit reset" };
   }
 
   // Cron actions - using typed client
   async function refreshCronTasks() {
-    const result = (await client.cron.list({})) as { tasks: CronTask[] };
+    const result = (await client.api.cron.list({})) as { tasks: CronTask[] };
     cronTasks = result.tasks;
   }
 
@@ -143,7 +143,7 @@
   async function emitEvent() {
     try {
       const parsedData = JSON.parse(eventData);
-      await client.events.emit({ event: eventName, data: parsedData });
+      await client.api.events.emit({ event: eventName, data: parsedData });
     } catch (e) {
       console.error("Invalid JSON:", e);
     }
@@ -151,7 +151,7 @@
 
   // SSE actions - using typed client
   async function manualBroadcast() {
-    await client.sseRoutes.broadcast({
+    await client.api.sse.broadcast({
       channel: "events",
       event: "manual",
       data: {
@@ -164,7 +164,7 @@
   }
 
   async function refreshSSEClients() {
-    sseClients = (await client.sseRoutes.clients({})) as {
+    sseClients = (await client.api.sse.clients({})) as {
       total: number;
       byChannel: number;
     };