@donkeylabs/cli 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,201 @@
+/**
+ * Init Command
+ *
+ * Initialize a new @donkeylabs/server project by copying from templates
+ */
+
+import { mkdir, writeFile, readFile, readdir, copyFile, stat } from "node:fs/promises";
+import { join, resolve, dirname, basename } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import pc from "picocolors";
+import prompts from "prompts";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+type ProjectType = "server" | "sveltekit";
+
+// Files/directories to skip when copying templates
+const SKIP_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".svelte-kit",
+  "build",
+  "dist",
+  ".DS_Store",
+  "bun.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+];
+
+// Files that need to be renamed (template name -> actual name)
+const RENAME_MAP: Record<string, string> = {
+  ".gitignore.template": ".gitignore",
+  ".env.example": ".env",
+};
+
+export async function initCommand(args: string[]) {
+  // Parse --type flag if provided
+  let projectDir = ".";
+  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];
+    }
+  }
+
+  const targetDir = resolve(process.cwd(), projectDir);
+
+  console.log(pc.bold("\nInitializing @donkeylabs/server project...\n"));
+
+  let projectType: ProjectType;
+
+  if (typeArg === "server" || typeArg === "sveltekit") {
+    projectType = typeArg;
+    console.log(pc.cyan(`Project type: ${projectType === "server" ? "Server Only" : "SvelteKit + Adapter"}\n`));
+  } else {
+    // Prompt for project type
+    const response = await prompts({
+      type: "select",
+      name: "projectType",
+      message: "Select project type:",
+      choices: [
+        {
+          title: "Server Only",
+          description: "Standalone API server with @donkeylabs/server",
+          value: "server",
+        },
+        {
+          title: "SvelteKit + Adapter",
+          description: "Full-stack app with SvelteKit and @donkeylabs/adapter-sveltekit",
+          value: "sveltekit",
+        },
+      ],
+    });
+
+    if (!response.projectType) {
+      console.log(pc.yellow("Cancelled."));
+      return;
+    }
+    projectType = response.projectType;
+  }
+
+  // Check if directory exists and has files
+  if (existsSync(targetDir)) {
+    const files = await readdir(targetDir);
+    const hasConflicts = files.some(
+      (f) => f === "src" || f === "donkeylabs.config.ts" || f === "svelte.config.js" || f === "package.json"
+    );
+
+    if (hasConflicts) {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: "Directory contains existing files. Overwrite?",
+        initial: false,
+      });
+
+      if (!overwrite) {
+        console.log(pc.yellow("Cancelled."));
+        return;
+      }
+    }
+  }
+
+  // Determine template directory
+  const templateName = projectType === "server" ? "starter" : "sveltekit-app";
+  const templateDir = resolve(__dirname, "../../templates", templateName);
+
+  if (!existsSync(templateDir)) {
+    console.error(pc.red(`Template not found: ${templateDir}`));
+    console.error(pc.dim("Make sure @donkeylabs/cli is installed correctly."));
+    process.exit(1);
+  }
+
+  // Copy template to target directory
+  await copyDirectory(templateDir, targetDir);
+
+  // Update package.json with project name
+  const pkgPath = join(targetDir, "package.json");
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    const projectName = basename(targetDir) || "my-app";
+    pkg.name = projectName;
+    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")}
+
+  2. Start development:
+     ${pc.cyan("bun run dev")}
+
+  3. Generate types after adding plugins:
+     ${pc.cyan("bun run gen:types")}
+`);
+  } else {
+    console.log(`
+${pc.bold(pc.green("Success!"))} SvelteKit project initialized.
+
+${pc.bold("Next steps:")}
+  1. Install dependencies:
+     ${pc.cyan("bun install")}
+
+  2. Start development:
+     ${pc.cyan("bun run dev")}
+
+  3. Build for production:
+     ${pc.cyan("bun run build")}
+
+  4. Preview production build:
+     ${pc.cyan("bun run preview")}
+
+${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
+`);
+  }
+}
+
+/**
+ * Recursively copy a directory
+ */
+async function copyDirectory(src: string, dest: string): Promise<void> {
+  await mkdir(dest, { recursive: true });
+
+  const entries = await readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+
+    // Skip certain files/directories
+    if (SKIP_PATTERNS.includes(entry.name)) {
+      continue;
+    }
+
+    // Handle renames
+    const destName = RENAME_MAP[entry.name] || entry.name;
+    const destPath = join(dest, destName);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+      console.log(pc.green("  Created:"), destName);
+    }
+  }
+}

package/src/commands/interactive.ts

@@ -0,0 +1,223 @@
+/**
+ * Interactive CLI Menu
+ *
+ * Full interactive experience with context-aware menus
+ */
+
+import prompts from "prompts";
+import pc from "picocolors";
+import { readdir, writeFile, mkdir } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { existsSync } from "node:fs";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+export async function interactiveCommand() {
+  console.clear();
+  console.log(pc.magenta(pc.bold("\n  @donkeylabs/cli\n")));
+
+  // Detect context - are we in a plugin directory?
+  const cwd = process.cwd();
+  const pathParts = cwd.split("/");
+  const parentDir = pathParts[pathParts.length - 2];
+  const currentDir = pathParts[pathParts.length - 1];
+
+  let contextPlugin: string | null = null;
+  if (parentDir === "plugins" && currentDir && existsSync(join(cwd, "index.ts"))) {
+    contextPlugin = currentDir;
+  }
+
+  // Run appropriate menu loop
+  if (contextPlugin) {
+    await pluginMenuLoop(contextPlugin);
+  } else {
+    await globalMenuLoop();
+  }
+}
+
+// ============================================
+// Plugin Context Menu (Inside plugins/<name>/)
+// ============================================
+
+async function pluginMenuLoop(pluginName: string) {
+  while (true) {
+    console.log(pc.cyan(`\n  Context: Plugin ${pc.bold(`'${pluginName}'`)}\n`));
+
+    const response = await prompts({
+      type: "select",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        { title: pc.yellow("1.") + " Generate Schema Types", value: "gen-types" },
+        { title: pc.yellow("2.") + " Create Migration", value: "migration" },
+        { title: pc.gray("─".repeat(35)), value: "separator", disabled: true },
+        { title: pc.blue("←") + "  Back to Global Menu", value: "global" },
+        { title: pc.red("×") + "  Exit", value: "exit" },
+      ],
+    });
+
+    if (!response.action || response.action === "exit") {
+      console.log(pc.gray("\nGoodbye!\n"));
+      process.exit(0);
+    }
+
+    if (response.action === "global") {
+      console.clear();
+      console.log(pc.magenta(pc.bold("\n  @donkeylabs/cli\n")));
+      await globalMenuLoop();
+      return;
+    }
+
+    console.log(""); // spacing
+
+    switch (response.action) {
+      case "gen-types":
+        await runCommand(`bun scripts/generate-types.ts ${pluginName}`);
+        break;
+      case "migration":
+        await createMigration(pluginName);
+        break;
+    }
+
+    await pressEnterToContinue();
+  }
+}
+
+// ============================================
+// Global Root Menu
+// ============================================
+
+async function globalMenuLoop() {
+  while (true) {
+    console.log(pc.cyan("\n  Context: Project Root\n"));
+
+    const choices = [
+      { title: pc.yellow("1.") + " Create New Plugin", value: "new-plugin" },
+      { title: pc.yellow("2.") + " Initialize New Project", value: "init" },
+      { title: pc.gray("─".repeat(35)), value: "separator1", disabled: true },
+      { title: pc.yellow("3.") + " Generate Types", value: "generate" },
+      { title: pc.yellow("4.") + " Generate Registry", value: "gen-registry" },
+      { title: pc.yellow("5.") + " Generate Server Context", value: "gen-server" },
+      { title: pc.gray("─".repeat(35)), value: "separator2", disabled: true },
+      { title: pc.red("×") + "  Exit", value: "exit" },
+    ];
+
+    const response = await prompts({
+      type: "select",
+      name: "action",
+      message: "Select a command:",
+      choices,
+    });
+
+    if (!response.action || response.action === "exit") {
+      console.log(pc.gray("\nGoodbye!\n"));
+      process.exit(0);
+    }
+
+    console.log(""); // spacing
+
+    switch (response.action) {
+      case "new-plugin":
+        const { pluginCommand } = await import("./plugin");
+        await pluginCommand(["create"]);
+        break;
+      case "init":
+        const { initCommand } = await import("./init");
+        await initCommand([]);
+        break;
+      case "generate":
+        const { generateCommand } = await import("./generate");
+        await generateCommand([]);
+        break;
+      case "gen-registry":
+        await runCommand("bun scripts/generate-registry.ts");
+        break;
+      case "gen-server":
+        await runCommand("bun scripts/generate-server.ts");
+        break;
+    }
+
+    await pressEnterToContinue();
+  }
+}
+
+// ============================================
+// Commands
+// ============================================
+
+async function createMigration(pluginName: string) {
+  const nameRes = await prompts({
+    type: "text",
+    name: "migName",
+    message: "Migration name (e.g. add_comments):",
+    validate: (v) =>
+      /^[a-z0-9_]+$/.test(v) ? true : "Use lowercase letters, numbers, and underscores",
+  });
+
+  if (!nameRes.migName) return;
+
+  // Determine migrations directory
+  const cwd = process.cwd();
+  const isPluginDir = basename(join(cwd, "..")) === "plugins";
+  const migrationsDir = isPluginDir
+    ? join(cwd, "migrations")
+    : join(process.cwd(), "src/plugins", pluginName, "migrations");
+
+  // Generate sequential 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")}_${nameRes.migName}.ts`;
+  const content = `import type { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  // await db.schema.createTable("...").execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // await db.schema.dropTable("...").execute();
+}
+`;
+
+  if (!existsSync(migrationsDir)) {
+    await mkdir(migrationsDir, { recursive: true });
+  }
+
+  await writeFile(join(migrationsDir, filename), content);
+  console.log(pc.green(`Created migration: ${filename}`));
+}
+
+// ============================================
+// Helpers
+// ============================================
+
+async function runCommand(cmd: string) {
+  console.log(pc.gray(`> ${cmd}\n`));
+  try {
+    const { stdout, stderr } = await execAsync(cmd);
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(pc.yellow(stderr));
+  } catch (e: any) {
+    console.error(pc.red("Command failed:"), e.message);
+  }
+}
+
+async function pressEnterToContinue() {
+  await prompts({
+    type: "invisible",
+    name: "continue",
+    message: pc.gray("Press Enter to continue..."),
+  });
+  console.clear();
+  console.log(pc.magenta(pc.bold("\n  @donkeylabs/cli\n")));
+}

package/src/commands/plugin.ts

@@ -0,0 +1,205 @@
+/**
+ * Plugin Command
+ *
+ * Plugin management commands
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import pc from "picocolors";
+import prompts from "prompts";
+
+export async function pluginCommand(args: string[]) {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case "create":
+    case "new":
+      await createPlugin(args[1]);
+      break;
+
+    case "list":
+      await listPlugins();
+      break;
+
+    default:
+      console.log(`
+${pc.bold("Plugin Management")}
+
+${pc.bold("Commands:")}
+  ${pc.cyan("create <name>")}    Create a new plugin
+  ${pc.cyan("list")}             List installed plugins
+
+${pc.bold("Examples:")}
+  donkeylabs plugin create auth
+  donkeylabs plugin list
+`);
+  }
+}
+
+async function createPlugin(name?: string) {
+  // Prompt for name if not provided
+  if (!name) {
+    const response = await prompts({
+      type: "text",
+      name: "name",
+      message: "Plugin name:",
+      validate: (v) =>
+        /^[a-z][a-z0-9-]*$/.test(v) ||
+        "Name must be lowercase alphanumeric with dashes",
+    });
+    name = response.name;
+  }
+
+  if (!name) {
+    console.log(pc.yellow("Cancelled."));
+    return;
+  }
+
+  // Ask for configuration
+  const { hasSchema, hasDependencies } = await prompts([
+    {
+      type: "confirm",
+      name: "hasSchema",
+      message: "Does this plugin need a database schema?",
+      initial: false,
+    },
+    {
+      type: "confirm",
+      name: "hasDependencies",
+      message: "Does this plugin depend on other plugins?",
+      initial: false,
+    },
+  ]);
+
+  let dependencies: string[] = [];
+  if (hasDependencies) {
+    const { deps } = await prompts({
+      type: "list",
+      name: "deps",
+      message: "Enter dependency names (comma-separated):",
+      separator: ",",
+    });
+    dependencies = deps?.filter(Boolean) || [];
+  }
+
+  // Determine plugin directory
+  const pluginDir = join(process.cwd(), "src/plugins", name);
+
+  if (existsSync(pluginDir)) {
+    console.log(pc.red(`Plugin directory already exists: ${pluginDir}`));
+    return;
+  }
+
+  await mkdir(pluginDir, { recursive: true });
+
+  // Generate plugin code
+  const camelName = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const pascalName = camelName.charAt(0).toUpperCase() + camelName.slice(1);
+
+  const schemaImport = hasSchema
+    ? `import type { DB as ${pascalName}Schema } from "./schema";\n`
+    : "";
+
+  const schemaType = hasSchema ? `<${pascalName}Schema>()` : "";
+
+  const depsLine =
+    dependencies.length > 0
+      ? `  dependencies: [${dependencies.map((d) => `"${d}"`).join(", ")}] as const,\n`
+      : "";
+
+  const pluginContent = `import { createPlugin } from "@donkeylabs/server";
+${schemaImport}
+export interface ${pascalName}Service {
+  // Define your service interface here
+  getData(): Promise<string>;
+}
+
+export const ${camelName}Plugin = createPlugin${hasSchema ? `\n  .withSchema${schemaType}` : ""}
+  .define({
+    name: "${name}",
+    version: "1.0.0",
+${depsLine}
+    service: async (ctx): Promise<${pascalName}Service> => {
+      console.log("[${pascalName}Plugin] Initializing...");
+${
+  dependencies.length > 0
+    ? dependencies.map((d) => `      // Access ${d} via: ctx.deps.${d}`).join("\n") + "\n"
+    : ""
+}
+      return {
+        getData: async () => {
+          return "Hello from ${name} plugin!";
+        },
+      };
+    },
+  });
+`;
+
+  await writeFile(join(pluginDir, "index.ts"), pluginContent);
+  console.log(pc.green("  Created:"), `src/plugins/${name}/index.ts`);
+
+  if (hasSchema) {
+    // Create schema.ts
+    const schemaContent = `// Database schema types for ${name} plugin
+// Run \`bun run gen:types\` to regenerate from database
+
+export interface DB {
+  // Define your table interfaces here
+  // Example:
+  // ${name}: {
+  //   id: Generated<number>;
+  //   name: string;
+  //   created_at: Generated<string>;
+  // };
+}
+`;
+    await writeFile(join(pluginDir, "schema.ts"), schemaContent);
+    console.log(pc.green("  Created:"), `src/plugins/${name}/schema.ts`);
+
+    // Create migrations directory
+    await mkdir(join(pluginDir, "migrations"), { recursive: true });
+
+    // Create initial migration
+    const migrationContent = `import { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>) {
+  // Create your tables here
+  // await db.schema
+  //   .createTable("${name}")
+  //   .ifNotExists()
+  //   .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+  //   .addColumn("name", "text", (col) => col.notNull())
+  //   .addColumn("created_at", "text", (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+  //   .execute();
+}
+
+export async function down(db: Kysely<any>) {
+  // Drop your tables here
+  // await db.schema.dropTable("${name}").ifExists().execute();
+}
+`;
+    await writeFile(
+      join(pluginDir, "migrations", "001_initial.ts"),
+      migrationContent
+    );
+    console.log(
+      pc.green("  Created:"),
+      `src/plugins/${name}/migrations/001_initial.ts`
+    );
+  }
+
+  console.log(`
+${pc.bold(pc.green("Plugin created!"))}
+
+${pc.bold("Next steps:")}
+  1. Edit your plugin at ${pc.cyan(`src/plugins/${name}/index.ts`)}
+${hasSchema ? `  2. Define your schema in ${pc.cyan(`src/plugins/${name}/schema.ts`)}\n  3. Add migrations in ${pc.cyan(`src/plugins/${name}/migrations/`)}\n` : ""}  ${hasSchema ? "4" : "2"}. Regenerate types: ${pc.cyan("donkeylabs generate")}
+`);
+}
+
+async function listPlugins() {
+  console.log(pc.yellow("Plugin listing not yet implemented."));
+  console.log("Run 'donkeylabs generate' to see discovered plugins.");
+}