zdev 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { resolve, basename } from "path";
+import { isGitRepo, getRepoName, run } from "../utils.js";
+import { getSeedPath, SEEDS_DIR } from "../config.js";
+
+export interface InitOptions {
+  seed?: boolean;
+}
+
+export async function init(projectPath: string = ".", options: InitOptions = {}): Promise<void> {
+  const fullPath = resolve(projectPath);
+  
+  if (!existsSync(fullPath)) {
+    console.error(`❌ Path does not exist: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  if (!isGitRepo(fullPath)) {
+    console.error(`❌ Not a git repository: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  const repoName = getRepoName(fullPath);
+  console.log(`🐂 Initializing zdev for: ${repoName}`);
+  
+  // Create .zdev directory in project
+  const zdevDir = resolve(fullPath, ".zdev");
+  if (!existsSync(zdevDir)) {
+    mkdirSync(zdevDir, { recursive: true });
+    console.log(`   Created ${zdevDir}`);
+  }
+  
+  // Create project config
+  const projectConfig = {
+    name: repoName,
+    path: fullPath,
+    initialized: new Date().toISOString(),
+  };
+  
+  const configPath = resolve(zdevDir, "project.json");
+  writeFileSync(configPath, JSON.stringify(projectConfig, null, 2));
+  console.log(`   Created project config`);
+  
+  // Check for existing .gitignore and add .zdev if needed
+  const gitignorePath = resolve(fullPath, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(".zdev")) {
+      writeFileSync(gitignorePath, content + "\n.zdev/\n");
+      console.log(`   Added .zdev/ to .gitignore`);
+    }
+  }
+  
+  // Create seed if requested
+  if (options.seed) {
+    console.log(`\n📦 Creating seed data...`);
+    
+    // Check if convex directory exists
+    const convexDir = resolve(fullPath, "convex");
+    if (!existsSync(convexDir)) {
+      console.log(`   No convex/ directory found, skipping seed`);
+    } else {
+      const seedPath = getSeedPath(repoName);
+      const result = run("bunx", ["convex", "export", "--path", seedPath], {
+        cwd: fullPath,
+      });
+      
+      if (result.success) {
+        console.log(`   Seed saved to: ${seedPath}`);
+      } else {
+        console.error(`   Failed to create seed: ${result.stderr}`);
+      }
+    }
+  }
+  
+  console.log(`\n✅ zdev initialized for ${repoName}`);
+  console.log(`\nNext steps:`);
+  console.log(`   zdev start <feature-name>   Start working on a feature`);
+  console.log(`   zdev list                   List active worktrees`);
+}

package/src/commands/list.ts

@@ -0,0 +1,78 @@
+import { existsSync } from "fs";
+import {
+  loadConfig,
+  getWorktreePath,
+  ZEBU_HOME,
+  WORKTREES_DIR,
+} from "../config.js";
+import { isProcessRunning, getTraefikStatus } from "../utils.js";
+
+export interface ListOptions {
+  json?: boolean;
+}
+
+export async function list(options: ListOptions = {}): Promise<void> {
+  const config = loadConfig();
+  const allocations = Object.entries(config.allocations);
+  
+  if (options.json) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  
+  console.log(`🐂 zdev Status\n`);
+  console.log(`📁 Home: ${ZEBU_HOME}`);
+  console.log(`📁 Worktrees: ${WORKTREES_DIR}`);
+  
+  const traefikStatus = getTraefikStatus();
+  if (traefikStatus.running) {
+    console.log(`🔗 Traefik: running (*.${traefikStatus.devDomain || 'dev.example.com'})`);
+  } else {
+    console.log(`🔗 Traefik: not running`);
+  }
+  
+  console.log(`\n${"─".repeat(60)}`);
+  
+  if (allocations.length === 0) {
+    console.log(`\nNo active features.\n`);
+    console.log(`Start one with: zdev start <feature-name> --project <path>`);
+    return;
+  }
+  
+  console.log(`\n📋 Active Features (${allocations.length}):\n`);
+  
+  for (const [name, alloc] of allocations) {
+    const worktreePath = getWorktreePath(name);
+    const worktreeExists = existsSync(worktreePath);
+    
+    const frontendRunning = alloc.pids.frontend
+      ? isProcessRunning(alloc.pids.frontend)
+      : false;
+    const convexRunning = alloc.pids.convex
+      ? isProcessRunning(alloc.pids.convex)
+      : false;
+    
+    const statusEmoji = frontendRunning && convexRunning ? "🟢" : 
+                        frontendRunning || convexRunning ? "🟡" : "🔴";
+    
+    console.log(`${statusEmoji} ${name}`);
+    console.log(`   Project:  ${alloc.project}`);
+    console.log(`   Branch:   ${alloc.branch}`);
+    console.log(`   Path:     ${worktreePath} ${worktreeExists ? "" : "(missing)"}`);
+    console.log(`   Local:    http://localhost:${alloc.frontendPort}`);
+    
+    if (alloc.funnelPath && traefikStatus.devDomain) {
+      console.log(`   Public:   https://${alloc.funnelPath}.${traefikStatus.devDomain}`);
+    }
+    
+    console.log(`   Frontend: ${frontendRunning ? `running (PID: ${alloc.pids.frontend})` : "stopped"}`);
+    console.log(`   Convex:   ${convexRunning ? `running (PID: ${alloc.pids.convex})` : "stopped"}`);
+    console.log(`   Started:  ${new Date(alloc.started).toLocaleString()}`);
+    console.log();
+  }
+  
+  console.log(`${"─".repeat(60)}`);
+  console.log(`\nCommands:`);
+  console.log(`   zdev stop <feature>    Stop servers for a feature`);
+  console.log(`   zdev clean <feature>   Remove worktree after merge`);
+}

package/src/commands/seed.ts

@@ -0,0 +1,98 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { isGitRepo, getRepoName, run } from "../utils.js";
+import { getSeedPath, ensurezdevDirs } from "../config.js";
+
+export interface SeedOptions {
+  project?: string;
+}
+
+export async function seedExport(
+  projectPath: string = ".",
+  options: SeedOptions = {}
+): Promise<void> {
+  const fullPath = resolve(projectPath);
+  
+  if (!existsSync(fullPath)) {
+    console.error(`❌ Path does not exist: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  if (!isGitRepo(fullPath)) {
+    console.error(`❌ Not a git repository: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  const repoName = getRepoName(fullPath);
+  const seedPath = getSeedPath(repoName);
+  
+  console.log(`🐂 Exporting seed data for: ${repoName}`);
+  
+  ensurezdevDirs();
+  
+  const result = run("bunx", ["convex", "export", "--path", seedPath], {
+    cwd: fullPath,
+  });
+  
+  if (result.success) {
+    console.log(`\n✅ Seed exported to: ${seedPath}`);
+  } else {
+    console.error(`\n❌ Failed to export seed:`);
+    console.error(result.stderr);
+    process.exit(1);
+  }
+}
+
+export async function seedImport(
+  projectPath: string = ".",
+  options: SeedOptions = {}
+): Promise<void> {
+  const fullPath = resolve(projectPath);
+  
+  if (!existsSync(fullPath)) {
+    console.error(`❌ Path does not exist: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  // Try to determine project name from .zdev/project.json or git
+  let repoName: string;
+  
+  const projectConfigPath = resolve(fullPath, ".zdev", "project.json");
+  if (existsSync(projectConfigPath)) {
+    try {
+      const config = JSON.parse(await Bun.file(projectConfigPath).text());
+      repoName = config.name;
+    } catch {
+      repoName = getRepoName(fullPath);
+    }
+  } else if (isGitRepo(fullPath)) {
+    repoName = getRepoName(fullPath);
+  } else {
+    console.error(`❌ Cannot determine project name`);
+    process.exit(1);
+  }
+  
+  const seedPath = getSeedPath(repoName);
+  
+  if (!existsSync(seedPath)) {
+    console.error(`❌ No seed found for ${repoName}`);
+    console.log(`   Expected: ${seedPath}`);
+    console.log(`\n   Create one with: zdev seed export --project <main-repo-path>`);
+    process.exit(1);
+  }
+  
+  console.log(`🐂 Importing seed data for: ${repoName}`);
+  console.log(`   From: ${seedPath}`);
+  
+  const result = run("bunx", ["convex", "import", "--replace", seedPath], {
+    cwd: fullPath,
+  });
+  
+  if (result.success) {
+    console.log(`\n✅ Seed imported successfully`);
+  } else {
+    console.error(`\n❌ Failed to import seed:`);
+    console.error(result.stderr);
+    process.exit(1);
+  }
+}

package/src/commands/start.ts

@@ -0,0 +1,306 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { resolve, basename, join } from "path";
+import {
+  isGitRepo,
+  getRepoName,
+  gitFetch,
+  createWorktree,
+  runBackground,
+  traefikAddRoute,
+  getTraefikStatus,
+  run,
+} from "../utils.js";
+import {
+  loadConfig,
+  saveConfig,
+  allocatePorts,
+  getWorktreePath,
+  getSeedPath,
+  type WorktreeAllocation,
+} from "../config.js";
+
+export interface StartOptions {
+  port?: number;
+  local?: boolean;  // Skip public URL setup
+  seed?: boolean;
+  baseBranch?: string;
+  webDir?: string;  // Subdirectory containing package.json (e.g., "web")
+}
+
+/**
+ * Detect the web/frontend directory in a project.
+ * Looks for common patterns: web/, frontend/, app/, or root package.json
+ */
+function detectWebDir(worktreePath: string): string {
+  // Check common subdirectory names
+  const commonDirs = ["web", "frontend", "app", "client", "packages/web", "apps/web"];
+  
+  for (const dir of commonDirs) {
+    const packagePath = join(worktreePath, dir, "package.json");
+    if (existsSync(packagePath)) {
+      return dir;
+    }
+  }
+  
+  // Check root
+  if (existsSync(join(worktreePath, "package.json"))) {
+    return ".";
+  }
+  
+  // Default to web/ if nothing found (will fail gracefully)
+  return "web";
+}
+
+export async function start(
+  featureName: string,
+  projectPath: string = ".",
+  options: StartOptions = {}
+): Promise<void> {
+  const fullPath = resolve(projectPath);
+  
+  if (!existsSync(fullPath)) {
+    console.error(`❌ Path does not exist: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  if (!isGitRepo(fullPath)) {
+    console.error(`❌ Not a git repository: ${fullPath}`);
+    process.exit(1);
+  }
+  
+  const repoName = getRepoName(fullPath);
+  const worktreeName = `${repoName}-${featureName}`;
+  const worktreePath = getWorktreePath(worktreeName);
+  const branchName = `feature/${featureName}`;
+  const baseBranch = options.baseBranch || "origin/main";
+  
+  console.log(`🐂 Starting feature: ${featureName}`);
+  console.log(`   Project: ${repoName}`);
+  console.log(`   Branch: ${branchName}`);
+  
+  // Load config
+  const config = loadConfig();
+  
+  // Check if already exists
+  if (config.allocations[worktreeName]) {
+    console.error(`\n❌ Feature "${featureName}" already exists for ${repoName}`);
+    console.log(`   Run: zdev stop ${featureName} --project ${fullPath}`);
+    process.exit(1);
+  }
+  
+  // Fetch latest
+  console.log(`\n📥 Fetching latest from origin...`);
+  if (!gitFetch(fullPath)) {
+    console.error(`   Failed to fetch, continuing anyway...`);
+  }
+  
+  // Create worktree
+  console.log(`\n🌳 Creating worktree...`);
+  if (existsSync(worktreePath)) {
+    console.error(`   Worktree path already exists: ${worktreePath}`);
+    process.exit(1);
+  }
+  
+  const worktreeResult = createWorktree(fullPath, worktreePath, branchName, baseBranch);
+  if (!worktreeResult.success) {
+    console.error(`   Failed to create worktree: ${worktreeResult.error}`);
+    process.exit(1);
+  }
+  console.log(`   Created: ${worktreePath}`);
+  
+  // Detect web directory
+  const webDir = options.webDir || detectWebDir(worktreePath);
+  const webPath = webDir === "." ? worktreePath : join(worktreePath, webDir);
+  
+  console.log(`\n📁 Web directory: ${webDir === "." ? "(root)" : webDir}`);
+  
+  // Copy configured files from main project to worktree
+  if (config.copyPatterns && config.copyPatterns.length > 0) {
+    console.log(`\n📋 Copying config files...`);
+    const mainWebPath = webDir === "." ? fullPath : join(fullPath, webDir);
+    
+    for (const pattern of config.copyPatterns) {
+      const srcPath = join(mainWebPath, pattern);
+      const destPath = join(webPath, pattern);
+      
+      if (existsSync(srcPath) && !existsSync(destPath)) {
+        try {
+          const content = readFileSync(srcPath);
+          writeFileSync(destPath, content);
+          console.log(`   Copied ${pattern}`);
+        } catch (e) {
+          console.log(`   Could not copy ${pattern}`);
+        }
+      }
+    }
+  }
+
+  // Run setup script if exists
+  const setupScriptPath = join(worktreePath, ".zdev", "setup.sh");
+  if (existsSync(setupScriptPath)) {
+    console.log(`\n📦 Running setup script...`);
+    const setupResult = run("bash", [setupScriptPath], { cwd: webPath });
+    if (!setupResult.success) {
+      console.error(`   Setup script failed: ${setupResult.stderr}`);
+    } else {
+      console.log(`   Setup complete`);
+    }
+  } else {
+    console.log(`\n⚠️  No .zdev/setup.sh found, skipping setup`);
+    console.log(`   Create one in your project to automate dependency installation`);
+  }
+  
+  // Check if this is a Convex project
+  const hasConvex = existsSync(join(webPath, "convex")) || existsSync(join(worktreePath, "convex"));
+  
+  // Import seed data if requested, exists, and is a Convex project
+  const seedPath = getSeedPath(repoName);
+  if (options.seed && hasConvex && existsSync(seedPath)) {
+    console.log(`\n🌱 Importing seed data...`);
+    const seedResult = run("bunx", ["convex", "import", seedPath], {
+      cwd: webPath,
+    });
+    if (seedResult.success) {
+      console.log(`   Seed data imported`);
+    } else {
+      console.error(`   Failed to import seed: ${seedResult.stderr}`);
+    }
+  }
+  
+  // Allocate ports
+  const ports = options.port
+    ? { frontend: options.port, convex: hasConvex ? options.port + 100 : 0 }
+    : allocatePorts(config, hasConvex);
+  
+  console.log(`\n🔌 Allocated ports:`);
+  console.log(`   Frontend: ${ports.frontend}`);
+  if (hasConvex) {
+    console.log(`   Convex: ${ports.convex}`);
+  }
+  
+  // Start Convex dev (only if this is a Convex project)
+  let convexPid: number | undefined;
+  if (hasConvex) {
+    console.log(`\n🚀 Starting Convex dev server...`);
+    convexPid = runBackground(
+      "bunx",
+      ["convex", "dev", "--tail-logs", "disable"],
+      { cwd: webPath }
+    );
+    console.log(`   Convex PID: ${convexPid}`);
+    
+    // Wait a moment for Convex to start
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  
+  // Patch vite.config to allow external hosts (for Traefik access)
+  const viteConfigTsPath = join(webPath, "vite.config.ts");
+  const viteConfigJsPath = join(webPath, "vite.config.js");
+  const viteConfigPath = existsSync(viteConfigTsPath) ? viteConfigTsPath : 
+                         existsSync(viteConfigJsPath) ? viteConfigJsPath : null;
+  
+  if (viteConfigPath) {
+    try {
+      let viteConfig = readFileSync(viteConfigPath, "utf-8");
+      
+      // Only patch if allowedHosts not already present
+      if (!viteConfig.includes("allowedHosts")) {
+        let patched = false;
+        
+        // Try to add allowedHosts to existing server block
+        if (viteConfig.includes("server:") || viteConfig.includes("server :")) {
+          // Add allowedHosts inside existing server block
+          viteConfig = viteConfig.replace(
+            /server\s*:\s*\{/,
+            "server: {\n    allowedHosts: true,"
+          );
+          patched = true;
+        } else if (viteConfig.includes("defineConfig({")) {
+          // No server block, add new one
+          viteConfig = viteConfig.replace(
+            /defineConfig\(\{/,
+            "defineConfig({\n  server: {\n    allowedHosts: true,\n  },"
+          );
+          patched = true;
+        }
+        
+        if (patched) {
+          writeFileSync(viteConfigPath, viteConfig);
+          console.log(`   Patched ${basename(viteConfigPath)} for external access`);
+          
+          // Mark file as skip-worktree so it won't be committed
+          run("git", ["update-index", "--skip-worktree", basename(viteConfigPath)], { cwd: webPath });
+        }
+      }
+    } catch (e) {
+      console.log(`   Could not patch vite config (non-critical)`);
+    }
+  }
+
+  // Start frontend (bind to all interfaces for Docker/Traefik access)
+  console.log(`\n🌐 Starting frontend dev server...`);
+  const frontendPid = runBackground(
+    "bun",
+    ["dev", "--port", String(ports.frontend), "--host", "0.0.0.0"],
+    { cwd: webPath }
+  );
+  console.log(`   Frontend PID: ${frontendPid}`);
+  
+  // Setup Traefik route for public URL
+  let routePath = "";
+  let publicUrl = "";
+  
+  if (!options.local) {
+    const traefikStatus = getTraefikStatus();
+    
+    if (traefikStatus.running && traefikStatus.devDomain) {
+      routePath = worktreeName;
+      console.log(`\n🔗 Setting up Traefik route...`);
+      
+      // Wait for frontend to be ready
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      
+      if (traefikAddRoute(worktreeName, ports.frontend)) {
+        publicUrl = `https://${worktreeName}.${traefikStatus.devDomain}`;
+        console.log(`   Public URL: ${publicUrl}`);
+      } else {
+        console.error(`   Failed to setup Traefik route`);
+      }
+    } else {
+      console.log(`\n⚠️  Traefik not configured or devDomain not set, skipping public URL`);
+      console.log(`   Run: zdev config --set devDomain=dev.yourdomain.com`);
+    }
+  }
+  
+  // Save allocation
+  const allocation: WorktreeAllocation = {
+    project: repoName,
+    projectPath: fullPath,
+    branch: branchName,
+    webDir,
+    frontendPort: ports.frontend,
+    convexPort: ports.convex,
+    funnelPath: routePath,
+    pids: {
+      frontend: frontendPid,
+      convex: convexPid,
+    },
+    started: new Date().toISOString(),
+  };
+  
+  config.allocations[worktreeName] = allocation;
+  saveConfig(config);
+  
+  // Summary
+  console.log(`\n${"─".repeat(50)}`);
+  console.log(`✅ Feature "${featureName}" is ready!\n`);
+  console.log(`📁 Worktree: ${worktreePath}`);
+  console.log(`🌐 Local:    http://localhost:${ports.frontend}`);
+  if (publicUrl) {
+    console.log(`🔗 Public:   ${publicUrl}`);
+  }
+  console.log(`\n📝 Commands:`);
+  console.log(`   cd ${worktreePath}`);
+  console.log(`   zdev stop ${featureName} --project ${fullPath}`);
+  console.log(`${"─".repeat(50)}`);
+}

package/src/commands/stop.ts

@@ -0,0 +1,101 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import {
+  isGitRepo,
+  getRepoName,
+  killProcess,
+  isProcessRunning,
+  traefikRemoveRoute,
+} from "../utils.js";
+import {
+  loadConfig,
+  saveConfig,
+  getWorktreePath,
+} from "../config.js";
+
+export interface StopOptions {
+  project?: string;
+  keep?: boolean;  // Keep worktree, just stop servers
+}
+
+export async function stop(
+  featureName: string,
+  options: StopOptions = {}
+): Promise<void> {
+  const config = loadConfig();
+  
+  // Find the allocation
+  let worktreeName: string | undefined;
+  let allocation;
+  
+  if (options.project) {
+    const projectPath = resolve(options.project);
+    const repoName = isGitRepo(projectPath) ? getRepoName(projectPath) : options.project;
+    worktreeName = `${repoName}-${featureName}`;
+    allocation = config.allocations[worktreeName];
+  } else {
+    // Search for matching feature across all projects
+    for (const [name, alloc] of Object.entries(config.allocations)) {
+      if (name.endsWith(`-${featureName}`)) {
+        worktreeName = name;
+        allocation = alloc;
+        break;
+      }
+    }
+  }
+  
+  if (!worktreeName || !allocation) {
+    console.error(`❌ Feature "${featureName}" not found`);
+    console.log(`\nRun 'zdev list' to see active features`);
+    process.exit(1);
+  }
+  
+  console.log(`🐂 Stopping feature: ${featureName}`);
+  console.log(`   Project: ${allocation.project}`);
+  
+  // Stop frontend
+  if (allocation.pids.frontend && isProcessRunning(allocation.pids.frontend)) {
+    console.log(`\n🛑 Stopping frontend (PID: ${allocation.pids.frontend})...`);
+    if (killProcess(allocation.pids.frontend)) {
+      console.log(`   Frontend stopped`);
+    } else {
+      console.error(`   Failed to stop frontend`);
+    }
+  }
+  
+  // Stop Convex
+  if (allocation.pids.convex && isProcessRunning(allocation.pids.convex)) {
+    console.log(`\n🛑 Stopping Convex (PID: ${allocation.pids.convex})...`);
+    if (killProcess(allocation.pids.convex)) {
+      console.log(`   Convex stopped`);
+    } else {
+      console.error(`   Failed to stop Convex`);
+    }
+  }
+  
+  // Remove Traefik route
+  if (allocation.funnelPath) {
+    console.log(`\n🔗 Removing Traefik route...`);
+    if (traefikRemoveRoute(allocation.funnelPath)) {
+      console.log(`   Route removed`);
+    } else {
+      console.error(`   Failed to remove route (may already be removed)`);
+    }
+  }
+  
+  // Remove allocation from config
+  delete config.allocations[worktreeName];
+  saveConfig(config);
+  
+  const worktreePath = getWorktreePath(worktreeName);
+  
+  if (options.keep) {
+    console.log(`\n✅ Feature "${featureName}" stopped (worktree kept)`);
+    console.log(`   Worktree: ${worktreePath}`);
+    console.log(`\n   To remove worktree: zdev clean ${featureName}`);
+  } else {
+    console.log(`\n✅ Feature "${featureName}" stopped`);
+    console.log(`\n   Worktree still exists at: ${worktreePath}`);
+    console.log(`   To remove: zdev clean ${featureName} --project ${allocation.projectPath}`);
+  }
+}