vibetree 1.2.0 → 1.3.0

package/.vibetree/worktrees/{d9baadc6-9864-472d-afa8-ee208877e85f → 3020aa56-a7a7-46c4-a452-b558cf6eadfd}/bin/vibetree.js

@@ -4,77 +4,40 @@ const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 const yargs = require('yargs/yargs');
 const { hideBin } = require('yargs/helpers');
-const prompts = require('prompts');
 // const open = require('open'); // Moved to dynamic import
 
-const argv = yargs(hideBin(process.argv))
-    .option('repo', {
-        alias: 'r',
-        type: 'string',
-        description: 'Path to target repository',
-    })
-    .option('ai', {
-        alias: 'a',
-        type: 'string',
-        choices: ['claude', 'codex', 'gemini'],
-        description: 'AI tool to use',
-    })
-    .argv;
+const argv = yargs(hideBin(process.argv)).argv;
 
-(async () => {
-    const PORT = process.env.VIBETREE_PORT || 5179;
-
-    // 1. Resolve Repo Path
-    let repoPath = argv.repo ? path.resolve(argv.repo) : process.cwd();
-
-    if (!fs.existsSync(repoPath) || !fs.statSync(repoPath).isDirectory()) {
-        console.error(`Error: Repository path does not exist: ${repoPath}`);
-        process.exit(1);
-    }
-
-    // 2. Resolve AI Tool
-    const configPath = path.join(repoPath, '.vibetree', 'config.json');
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        } catch (e) { }
+async function verifyNativeModules(pkgRoot) {
+    try {
+        require(require.resolve('node-pty', { paths: [path.join(pkgRoot, 'node_modules'), pkgRoot] }));
+        require(require.resolve('better-sqlite3', { paths: [path.join(pkgRoot, 'node_modules'), pkgRoot] }));
+    } catch (e) {
+        if (e.code === 'ERR_DLOPEN_FAILED' || (e.message && e.message.includes('Node.js version'))) {
+            console.log('\x1b[33m%s\x1b[0m', 'Binary mismatch detected. Rebuilding native modules for your Node.js version...');
+            spawnSync('npm', ['rebuild', 'node-pty', 'better-sqlite3'], { cwd: pkgRoot, stdio: 'inherit', shell: true });
+        }
     }
+}
 
-    let aiTool = argv.ai || config.aiTool;
+(async () => {
+    const pkgRoot = path.join(__dirname, '..');
 
-    if (!aiTool) {
-        const response = await prompts({
-            type: 'select',
-            name: 'aiTool',
-            message: 'Select AI tool to use:',
-            choices: [
-                { title: 'Claude', value: 'claude' },
-                { title: 'Codex (OpenAI)', value: 'codex' },
-                { title: 'Gemini', value: 'gemini' },
-            ],
-        });
-        aiTool = response.aiTool;
+    // Verify native modules before proceeding
+    await verifyNativeModules(pkgRoot);
 
-        // Save preference
-        const vibeDir = path.join(repoPath, '.vibetree');
-        if (!fs.existsSync(vibeDir)) fs.mkdirSync(vibeDir, { recursive: true });
-        fs.writeFileSync(path.join(vibeDir, 'config.json'), JSON.stringify({ aiTool }, null, 2));
-    }
+    const PORT = process.env.VIBETREE_PORT || 5179;
+    const repoPath = process.cwd();
 
     console.log(`Starting VibeTree...`);
-    console.log(`Repository: ${repoPath}`);
-    console.log(`AI Tool: ${aiTool}`);
     console.log(`Port: ${PORT}`);
 
     // 3. Start Server
-    const pkgRoot = path.join(__dirname, '..');
     const serverPath = path.join(pkgRoot, 'server', 'dist', 'index.js');
     const clientPath = path.join(pkgRoot, 'client', 'dist');
     const env = {
         ...process.env,
         REPO_PATH: repoPath,
-        AI_TOOL: aiTool,
         VIBETREE_PORT: PORT,
     };
 

package/.vibetree/worktrees/{d9baadc6-9864-472d-afa8-ee208877e85f → 3020aa56-a7a7-46c4-a452-b558cf6eadfd}/client/package.json

@@ -1,7 +1,7 @@
 {
   "name": "client",
   "private": true,
-  "version": "1.1.1",
+  "version": "1.2.1",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -37,4 +37,4 @@
     "tailwindcss": "^3.4.19",
     "vite": "^5.1.0"
   }
-}
+}

package/.vibetree/worktrees/{d9baadc6-9864-472d-afa8-ee208877e85f → 3020aa56-a7a7-46c4-a452-b558cf6eadfd}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibetree",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Local task management with Git worktrees and AI integration",
   "main": "bin/vibetree.js",
   "bin": {
@@ -66,4 +66,4 @@
     "tailwindcss": "^3.4.19",
     "vite": "^5.1.0"
   }
-}
+}

package/.vibetree/worktrees/{d9baadc6-9864-472d-afa8-ee208877e85f → 3020aa56-a7a7-46c4-a452-b558cf6eadfd}/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "server",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -41,4 +41,4 @@
     "@vitest/ui": "^4.0.18",
     "vitest": "^4.0.18"
   }
-}
+}

package/.vibetree/worktrees/3020aa56-a7a7-46c4-a452-b558cf6eadfd/server/router.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+import { router, publicProcedure } from './trpc';
+import { v4 as uuidv4 } from 'uuid';
+import { Task } from './types';
+import { createWorktree, runGit } from './git';
+import { exec } from 'child_process';
+import util from 'util';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { saveConfig } from './config';
+import {
+    getRepositories,
+    getRepositoryByPath,
+    addRepository,
+    getTasks,
+    getTaskById,
+    createTask,
+    updateTask,
+    deleteTask,
+    normalizePath
+} from './db';
+
+const execAsync = util.promisify(exec);
+
+function slugify(text: string): string {
+    return text
+        .toString()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')
+        .replace(/[^\w-]+/g, '')
+        .replace(/--+/g, '-');
+}
+
+export const appRouter = router({
+    // Config Procedures
+    getConfig: publicProcedure.query(({ ctx }) => {
+        return ctx.getState();
+    }),
+    updateConfig: publicProcedure
+        .input(z.object({
+            repoPath: z.string().optional(),
+            aiTool: z.string().optional(),
+            copyFiles: z.string().optional(),
+        }))
+        .mutation(async ({ input, ctx }) => {
+            const state = ctx.getState();
+            if (input.repoPath !== undefined) {
+                if (input.repoPath && !fs.existsSync(input.repoPath)) {
+                    throw new Error('Path does not exist');
+                }
+                const normalized = normalizePath(input.repoPath || '');
+                state.repoPath = normalized;
+                if (normalized) {
+                    addRepository(normalized, input.copyFiles);
+                }
+            }
+            if (input.aiTool !== undefined) state.aiTool = input.aiTool;
+            if (input.copyFiles !== undefined) {
+                state.copyFiles = input.copyFiles;
+                // Update copyFiles for active repo if it exists
+                const repo = getRepositoryByPath(state.repoPath);
+                if (repo) {
+                    const { updateRepository } = await import('./db');
+                    updateRepository(repo.id, { copyFiles: input.copyFiles });
+                }
+            }
+
+            await saveConfig(state);
+            return state;
+        }),
+
+    getRepositories: publicProcedure.query(async () => {
+        return getRepositories();
+    }),
+
+    addRepository: publicProcedure
+        .input(z.object({ path: z.string(), copyFiles: z.string().optional() }))
+        .mutation(async ({ input }) => {
+            return addRepository(input.path, input.copyFiles);
+        }),
+
+    // Task Procedures
+    getTasks: publicProcedure
+        .input(z.object({ repoPath: z.string() }))
+        .query(async ({ input }) => {
+            const repo = getRepositoryByPath(input.repoPath);
+            if (!repo) return [];
+            return getTasks(repo.id);
+        }),
+    createTask: publicProcedure
+        .input(z.object({
+            repoPath: z.string(),
+            title: z.string(),
+            description: z.string().optional(),
+        }))
+        .mutation(async ({ input, ctx }) => {
+            let repo = getRepositoryByPath(input.repoPath);
+            if (!repo) {
+                repo = addRepository(input.repoPath);
+            }
+
+            const slug = slugify(input.title);
+            const shortHash = uuidv4().split('-')[0];
+            const branchName = `feature/task-${slug.substring(0, 50)}-${shortHash}`;
+
+            const newTask = createTask(repo.id, {
+                title: input.title,
+                description: input.description || '',
+                branchName: branchName
+            });
+
+            // Handle side effects (worktree, terminal, AI)
+            if (input.repoPath && ctx.createWorktree && ctx.ensureTerminalForTask && ctx.runAiForTask) {
+                try {
+                    console.log(`[tRPC] Creating worktree for task ${newTask.id} in ${input.repoPath}`);
+                    await ctx.createWorktree(input.repoPath, newTask.id, newTask.branchName || '');
+
+                    console.log(`[tRPC] Ensuring terminal for task ${newTask.id}`);
+                    await ctx.ensureTerminalForTask(newTask.id, input.repoPath);
+
+                    console.log(`[tRPC] Running AI for task ${newTask.id}`);
+                    ctx.runAiForTask(newTask.id, input.repoPath).catch(e => console.error(`[tRPC] runAiForTask error:`, e));
+                } catch (e) {
+                    console.error(`[tRPC] Side effects failed for task ${newTask.id}:`, e);
+                }
+            }
+
+            return newTask;
+        }),
+    updateTask: publicProcedure
+        .input(z.object({
+            repoPath: z.string(),
+            id: z.string(),
+            updates: z.object({
+                title: z.string().optional(),
+                description: z.string().optional(),
+            }),
+        }))
+        .mutation(async ({ input }) => {
+            const task = getTaskById(input.id);
+            if (!task) throw new Error('Task not found');
+            return updateTask(input.id, input.updates);
+        }),
+    deleteTask: publicProcedure
+        .input(z.object({ repoPath: z.string(), taskId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+            const task = getTaskById(input.taskId);
+            if (!task) throw new Error('Task not found');
+
+            // Cleanup side effects
+            if (ctx.shutdownTerminalForTask) {
+                console.log(`[tRPC] Shutting down terminal for task ${input.taskId}`);
+                await ctx.shutdownTerminalForTask(input.taskId);
+            }
+            if (input.repoPath && ctx.removeWorktree) {
+                console.log(`[tRPC] Removing worktree and branch for task ${input.taskId} (${task.branchName})`);
+                try {
+                    await ctx.removeWorktree(input.repoPath, input.taskId, task.branchName);
+                } catch (e) {
+                    console.error(`[tRPC] Failed to remove worktree/branch:`, e);
+                }
+            }
+
+            deleteTask(input.taskId);
+            return { success: true };
+        }),
+
+    // Git Procedures
+    getGitStatus: publicProcedure
+        .input(z.object({ repoPath: z.string(), taskId: z.string().optional() }))
+        .query(async ({ input }) => {
+            const cwd = input.taskId ? path.join(input.repoPath, '.vibetree', 'worktrees', input.taskId) : input.repoPath;
+            const branch = await runGit('git branch --show-current', cwd, input.repoPath);
+            const status = await runGit('git status --short', cwd, input.repoPath);
+            return { branch, status };
+        }),
+    getGitDiff: publicProcedure
+        .input(z.object({ repoPath: z.string(), taskId: z.string().optional() }))
+        .query(async ({ input }) => {
+            const cwd = input.taskId ? path.join(input.repoPath, '.vibetree', 'worktrees', input.taskId) : input.repoPath;
+            const diff = await runGit('git diff', cwd, input.repoPath);
+            return { diff };
+        }),
+    createCommit: publicProcedure
+        .input(z.object({
+            repoPath: z.string(),
+            taskId: z.string().optional(),
+            message: z.string(),
+        }))
+        .mutation(async ({ input }) => {
+            const cwd = input.taskId ? path.join(input.repoPath, '.vibetree', 'worktrees', input.taskId) : input.repoPath;
+            await runGit('git add .', cwd, input.repoPath);
+            await runGit(`git commit -m "${input.message}"`, cwd, input.repoPath);
+            return { success: true };
+        }),
+    getWorktreePath: publicProcedure
+        .input(z.object({ repoPath: z.string(), taskId: z.string() }))
+        .query(({ input }) => {
+            const worktreePath = path.join(input.repoPath, '.vibetree', 'worktrees', input.taskId);
+            return { path: worktreePath };
+        }),
+
+    // System Procedures
+    openDirectory: publicProcedure
+        .input(z.object({ path: z.string() }))
+        .mutation(async ({ input }) => {
+            let command: string;
+            switch (os.platform()) {
+                case 'darwin':
+                    command = `open "${input.path}"`;
+                    break;
+                case 'win32':
+                    command = `start "" "${input.path}"`;
+                    break;
+                default:
+                    command = `xdg-open "${input.path}"`;
+                    break;
+            }
+            await execAsync(command);
+            return { success: true };
+        }),
+    pickFolder: publicProcedure.mutation(async () => {
+        let command: string | undefined;
+        if (os.platform() === 'darwin') {
+            command = `osascript -e 'POSIX path of (choose folder with prompt "Select a Git Repository")'`;
+        } else if (os.platform() === 'win32') {
+            command = `powershell -Command "Add-Type -AssemblyName System.Windows.Forms; $f = New-Object System.Windows.Forms.FolderBrowserDialog; $f.ShowDialog() | Out-Null; $f.SelectedPath"`;
+        } else {
+            throw new Error('Directory picker not supported on this platform');
+        }
+
+        const { stdout } = await execAsync(command);
+        const resultPath = stdout.trim();
+        return resultPath ? { path: resultPath } : { canceled: true };
+    }),
+    getAiTools: publicProcedure.query(async () => {
+        const tools = ['claude', 'codex', 'gemini'];
+        const results: Record<string, boolean> = {};
+        const commonPaths = [
+            '/opt/homebrew/bin',
+            '/usr/local/bin',
+            '/usr/bin',
+            '/bin',
+            (process.env.HOME || '') + '/.local/bin',
+            (process.env.HOME || '') + '/bin',
+        ];
+        const envPath = process.env.PATH || '';
+        const extendedPath = commonPaths.join(path.delimiter) + path.delimiter + envPath;
+
+        for (const tool of tools) {
+            let found = false;
+            try {
+                const cmd = os.platform() === 'win32' ? `where ${tool}` : `which ${tool}`;
+                const { stdout } = await execAsync(cmd, { env: { ...process.env, PATH: extendedPath } });
+                if (stdout.trim()) found = true;
+            } catch { }
+
+            if (!found) {
+                for (const p of commonPaths) {
+                    const binaryPath = path.join(p, tool + (os.platform() === 'win32' ? '.exe' : ''));
+                    if (fs.existsSync(binaryPath)) { found = true; break; }
+                }
+            }
+            results[tool] = found;
+        }
+        return results;
+    }),
+});
+
+export type AppRouter = typeof appRouter;