vibehub-cli 1.0.0

package/dist/lib/vibehub-manager.js

@@ -0,0 +1,855 @@
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+export class VibeHubManager {
+    constructor(repoPath) {
+        this.fileWatchers = new Map();
+        this.repoPath = repoPath;
+        this.configPath = path.join(repoPath, '.vibehub', 'vibehub.json');
+        this.sessionsPath = path.join(repoPath, '.vibehub', 'sessions');
+        this.commitsPath = path.join(repoPath, '.vibehub', 'commits');
+    }
+    async isInitialized() {
+        try {
+            await fs.access(this.configPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async init(config) {
+        const vibehubDir = path.join(this.repoPath, '.vibehub');
+        // Create .vibehub directory structure matching backend expectations
+        await fs.ensureDir(vibehubDir);
+        await fs.ensureDir(path.join(vibehubDir, 'workspace'));
+        await fs.ensureDir(path.join(vibehubDir, 'sessions'));
+        await fs.ensureDir(path.join(vibehubDir, 'config'));
+        await fs.ensureDir(path.join(vibehubDir, 'exports'));
+        await fs.ensureDir(this.commitsPath);
+        // Create vibehub.json configuration (matches backend structure)
+        const projectId = `${config.author.split('@')[0]}-${config.projectName}-${Date.now()}`;
+        const vibehubConfig = {
+            projectId: projectId,
+            projectName: config.projectName,
+            description: config.description || '',
+            localPath: this.repoPath,
+            createdAt: new Date().toISOString(),
+            lastUpdated: new Date().toISOString(),
+            version: '1.0.0',
+            author: {
+                name: config.author.split('@')[0],
+                email: config.author
+            },
+            config: {
+                autoSync: config.enableAutoSync,
+                capturePrompts: true,
+                workspaceTracking: true
+            },
+            workspace: {
+                cursorWorkspaceId: null, // Will be updated after detection
+                cursorWorkspacePath: null,
+                isActive: false
+            }
+        };
+        await fs.writeJson(this.configPath, vibehubConfig, { spaces: 2 });
+        // Try to detect and map Cursor workspace
+        await this.detectAndMapCursorWorkspace();
+        // Create initial commit
+        await this.createInitialCommit(config.author);
+    }
+    async getConfig() {
+        return await fs.readJson(this.configPath);
+    }
+    async updateConfig(updates) {
+        const config = await this.getConfig();
+        const updatedConfig = { ...config, ...updates };
+        await fs.writeJson(this.configPath, updatedConfig, { spaces: 2 });
+    }
+    async ensureAuthorInfo(email) {
+        const config = await this.getConfig();
+        // If author info is missing, add it
+        if (!config.author) {
+            await this.updateConfig({
+                author: {
+                    name: email.split('@')[0],
+                    email: email
+                }
+            });
+        }
+    }
+    async createSession(session) {
+        const sessionId = crypto.randomUUID();
+        const fullSession = {
+            ...session,
+            id: sessionId,
+            timestamp: new Date().toISOString()
+        };
+        const sessionFile = path.join(this.sessionsPath, `${sessionId}.json`);
+        await fs.writeJson(sessionFile, fullSession, { spaces: 2 });
+        return sessionId;
+    }
+    async getSession(sessionId) {
+        try {
+            const sessionFile = path.join(this.sessionsPath, `${sessionId}.json`);
+            return await fs.readJson(sessionFile);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getAllSessions() {
+        try {
+            const files = await fs.readdir(this.sessionsPath);
+            const sessions = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const sessionData = await fs.readJson(path.join(this.sessionsPath, file));
+                    // Handle prompts.json file which contains an array of prompts
+                    if (file === 'prompts.json' && sessionData.prompts) {
+                        for (const prompt of sessionData.prompts) {
+                            sessions.push({
+                                id: `prompt-${prompt.id}`,
+                                timestamp: prompt.timestamp_iso || new Date(prompt.timestamp).toISOString(),
+                                prompt: prompt.text,
+                                response: '',
+                                files: [],
+                                metadata: prompt.metadata || {}
+                            });
+                        }
+                    }
+                    else {
+                        // Handle regular session files
+                        sessions.push(sessionData);
+                    }
+                }
+            }
+            return sessions.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async createCommit(commit) {
+        const commitId = crypto.randomUUID();
+        const fullCommit = {
+            ...commit,
+            id: commitId,
+            timestamp: new Date().toISOString()
+        };
+        const commitFile = path.join(this.commitsPath, `${commitId}.json`);
+        await fs.writeJson(commitFile, fullCommit, { spaces: 2 });
+        return commitId;
+    }
+    async getCommit(commitId) {
+        try {
+            const commitFile = path.join(this.commitsPath, `${commitId}.json`);
+            return await fs.readJson(commitFile);
+        }
+        catch {
+            return null;
+        }
+    }
+    async getAllCommits() {
+        try {
+            const files = await fs.readdir(this.commitsPath);
+            const commits = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const commit = await fs.readJson(path.join(this.commitsPath, file));
+                    commits.push(commit);
+                }
+            }
+            return commits.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async createInitialCommit(author) {
+        await this.createCommit({
+            message: 'Initial VibeHub repository',
+            author,
+            files: [],
+            changes: {}
+        });
+    }
+    async updateGitignore() {
+        const gitignorePath = path.join(this.repoPath, '.gitignore');
+        const vibehubEntry = '\n# VibeHub\n.vibehub/\n';
+        try {
+            const existingContent = await fs.readFile(gitignorePath, 'utf-8');
+            if (!existingContent.includes('.vibehub/')) {
+                await fs.appendFile(gitignorePath, vibehubEntry);
+            }
+        }
+        catch {
+            // .gitignore doesn't exist, create it
+            await fs.writeFile(gitignorePath, vibehubEntry);
+        }
+    }
+    async getStatus() {
+        const initialized = await this.isInitialized();
+        if (!initialized) {
+            return {
+                initialized: false,
+                sessionCount: 0,
+                commitCount: 0
+            };
+        }
+        const config = await this.getConfig();
+        const sessions = await this.getAllSessions();
+        const commits = await this.getAllCommits();
+        let lastActivity;
+        if (sessions.length > 0 || commits.length > 0) {
+            const lastSession = sessions[0];
+            const lastCommit = commits[0];
+            if (lastSession && lastCommit) {
+                lastActivity = new Date(Math.max(new Date(lastSession.timestamp).getTime(), new Date(lastCommit.timestamp).getTime())).toISOString();
+            }
+            else if (lastSession) {
+                lastActivity = lastSession.timestamp;
+            }
+            else if (lastCommit) {
+                lastActivity = lastCommit.timestamp;
+            }
+        }
+        return {
+            initialized: true,
+            config,
+            sessionCount: sessions.length,
+            commitCount: commits.length,
+            lastActivity
+        };
+    }
+    /**
+     * Detect and map Cursor workspace to this project
+     */
+    async detectAndMapCursorWorkspace() {
+        try {
+            const cursorWorkspacePath = this.getCursorWorkspaceStoragePath();
+            if (!cursorWorkspacePath) {
+                console.log('⚠️  Cursor workspace storage not found');
+                return;
+            }
+            // Find workspace folders that contain this project path
+            const workspaceFolders = await fs.readdir(cursorWorkspacePath);
+            for (const folder of workspaceFolders) {
+                const workspaceJsonPath = path.join(cursorWorkspacePath, folder, 'workspace.json');
+                try {
+                    const workspaceJson = await fs.readJson(workspaceJsonPath);
+                    const workspacePath = workspaceJson.folder;
+                    // Handle both file:// URLs and regular paths
+                    let normalizedWorkspacePath = workspacePath;
+                    if (workspacePath.startsWith('file://')) {
+                        normalizedWorkspacePath = workspacePath.replace('file://', '');
+                    }
+                    if (normalizedWorkspacePath === this.repoPath) {
+                        // Found the matching workspace!
+                        await this.createWorkspaceMapping(folder, workspaceJson);
+                        console.log(`✅ Mapped Cursor workspace: ${folder}`);
+                        return;
+                    }
+                }
+                catch (error) {
+                    // Skip folders without workspace.json
+                    continue;
+                }
+            }
+            console.log('⚠️  No matching Cursor workspace found for this project');
+        }
+        catch (error) {
+            console.log('⚠️  Could not detect Cursor workspace:', error.message);
+        }
+    }
+    /**
+     * Get Cursor workspace storage path based on OS
+     */
+    getCursorWorkspaceStoragePath() {
+        const platform = process.platform;
+        switch (platform) {
+            case 'darwin': // macOS
+                return path.join(process.env.HOME || '', 'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage');
+            case 'win32': // Windows
+                return path.join(process.env.APPDATA || '', 'Cursor', 'User', 'workspaceStorage');
+            case 'linux': // Linux
+                return path.join(process.env.HOME || '', '.config', 'Cursor', 'User', 'workspaceStorage');
+            default:
+                return null;
+        }
+    }
+    /**
+     * Create workspace mapping file
+     */
+    async createWorkspaceMapping(workspaceId, workspaceJson) {
+        const workspaceDir = path.join(this.repoPath, '.vibehub', 'workspace');
+        const mappingPath = path.join(workspaceDir, `${workspaceId}.json`);
+        // Get actual file system timestamps for the workspace folder
+        const workspaceFolderPath = path.join(this.getCursorWorkspaceStoragePath(), workspaceId);
+        const stats = await fs.stat(workspaceFolderPath);
+        // Use birthtime (creation time) for createdAt, current time for lastAccessed
+        const createdAt = stats.birthtime || stats.ctime;
+        const lastAccessed = new Date();
+        const mapping = {
+            workspaceId: workspaceId,
+            localPath: this.repoPath,
+            cursorWorkspacePath: workspaceFolderPath,
+            createdAt: createdAt.toISOString(),
+            createdAtTimestamp: createdAt.getTime(),
+            lastAccessed: lastAccessed.toISOString(),
+            isActive: true,
+            metadata: {
+                projectName: path.basename(this.repoPath),
+                workspaceType: 'cursor',
+                gitRemote: await this.getGitRemote(),
+                branch: await this.getGitBranch()
+            }
+        };
+        await fs.writeJson(mappingPath, mapping, { spaces: 2 });
+        // Update the main vibehub.json with workspace information
+        await this.updateVibehubConfigWithWorkspace(workspaceId, mapping);
+        // Extract prompts and generations from the workspace
+        await this.extractPromptsAndGenerations(workspaceId);
+        // Start real-time file watching for auto-sync
+        await this.startWorkspaceWatching(workspaceId);
+    }
+    /**
+     * Get git remote URL
+     */
+    async getGitRemote() {
+        try {
+            const { execSync } = await import('child_process');
+            const remote = execSync('git config --get remote.origin.url', { cwd: this.repoPath, encoding: 'utf8' });
+            return remote.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get current git branch
+     */
+    async getGitBranch() {
+        try {
+            const { execSync } = await import('child_process');
+            const branch = execSync('git branch --show-current', { cwd: this.repoPath, encoding: 'utf8' });
+            return branch.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extract prompts and generations from Cursor workspace
+     */
+    async extractPromptsAndGenerations(workspaceId) {
+        try {
+            console.log('📝 Extracting prompts and generations...');
+            const workspacePath = path.join(this.getCursorWorkspaceStoragePath(), workspaceId);
+            const stateDbPath = path.join(workspacePath, 'state.vscdb');
+            if (!await fs.pathExists(stateDbPath)) {
+                console.log('⚠️  No state.vscdb found in workspace');
+                return;
+            }
+            // Extract prompts and generations using better-sqlite3
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(stateDbPath, { readonly: true });
+            // Extract prompts
+            const promptsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.prompts'").get();
+            const generationsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.generations'").get();
+            db.close();
+            if (!promptsResult && !generationsResult) {
+                console.log('⚠️  No prompts or generations found in workspace');
+                return;
+            }
+            // Parse and store prompts
+            if (promptsResult) {
+                await this.storePrompts(workspaceId, JSON.parse(promptsResult.value));
+            }
+            // Parse and store generations
+            if (generationsResult) {
+                await this.storeGenerations(workspaceId, JSON.parse(generationsResult.value));
+            }
+            // Generate CSV with prompts and timestamps
+            await this.generatePromptsCsv(workspaceId);
+            console.log('✅ Successfully extracted prompts and generations');
+        }
+        catch (error) {
+            console.log('⚠️  Could not extract prompts/generations:', error.message);
+        }
+    }
+    /**
+     * Store prompts in sessions directory
+     */
+    async storePrompts(workspaceId, prompts) {
+        const sessionsDir = path.join(this.repoPath, '.vibehub', 'sessions');
+        const promptsFile = path.join(sessionsDir, 'prompts.json');
+        // Load existing prompts or create new structure
+        let promptsData;
+        try {
+            promptsData = await fs.readJson(promptsFile);
+        }
+        catch {
+            promptsData = {
+                version: "1.0",
+                created_at: new Date().toISOString(),
+                last_updated: new Date().toISOString(),
+                total_prompts: 0,
+                prompts: []
+            };
+        }
+        // Add new prompts
+        for (const prompt of prompts) {
+            if (prompt.text && !promptsData.prompts.some((p) => p.text === prompt.text)) {
+                promptsData.prompts.push({
+                    id: promptsData.prompts.length + 1, // Use integer ID
+                    text: prompt.text,
+                    timestamp: prompt.unixMs || Date.now(),
+                    timestamp_iso: new Date(prompt.unixMs || Date.now()).toISOString(),
+                    source: 'cursor-database',
+                    workspace_id: workspaceId,
+                    metadata: {
+                        commandType: prompt.commandType,
+                        index: prompt.index
+                    }
+                });
+            }
+        }
+        promptsData.total_prompts = promptsData.prompts.length;
+        promptsData.last_updated = new Date().toISOString();
+        await fs.writeJson(promptsFile, promptsData, { spaces: 2 });
+    }
+    /**
+     * Store generations in exports directory
+     */
+    async storeGenerations(workspaceId, generations) {
+        const exportsDir = path.join(this.repoPath, '.vibehub', 'workspace', 'exports', `workspace-${workspaceId}`);
+        await fs.ensureDir(exportsDir);
+        const generationsFile = path.join(exportsDir, 'generations.jsonl');
+        const generationsData = generations.map((gen) => ({
+            id: gen.id || `gen_${gen.unixMs || Date.now()}`,
+            textDescription: gen.textDescription || gen.text || '',
+            unixMs: gen.unixMs || Date.now(),
+            timestamp: new Date(gen.unixMs || Date.now()).toISOString(),
+            type: gen.type || 'generation',
+            metadata: gen
+        }));
+        await fs.writeJson(generationsFile, generationsData, { spaces: 2 });
+    }
+    /**
+     * Generate CSV with prompts and timestamps
+     */
+    async generatePromptsCsv(workspaceId) {
+        try {
+            const sessionsDir = path.join(this.repoPath, '.vibehub', 'sessions');
+            const promptsFile = path.join(sessionsDir, 'prompts.json');
+            const exportsDir = path.join(this.repoPath, '.vibehub', 'workspace', 'exports', `workspace-${workspaceId}`);
+            await fs.ensureDir(exportsDir);
+            // Load prompts
+            const promptsData = await fs.readJson(promptsFile);
+            const workspacePrompts = promptsData.prompts.filter((p) => p.workspace_id === workspaceId);
+            // Create CSV content with prompt ID
+            const csvRows = ['prompt_id,timestamp,prompt_text,workspace_id'];
+            for (const prompt of workspacePrompts) {
+                const timestamp = new Date(prompt.timestamp).toISOString();
+                const promptText = prompt.text.replace(/"/g, '""').replace(/\n/g, ' ');
+                csvRows.push(`"${prompt.id}","${timestamp}","${promptText}","${workspaceId}"`);
+            }
+            const csvContent = csvRows.join('\n');
+            const csvFile = path.join(exportsDir, 'prompts_with_timestamps.csv');
+            await fs.writeFile(csvFile, csvContent);
+            console.log(`📊 Generated CSV with ${workspacePrompts.length} prompts`);
+        }
+        catch (error) {
+            console.log('⚠️  Could not generate CSV:', error.message);
+        }
+    }
+    /**
+     * Update vibehub.json with workspace information
+     */
+    async updateVibehubConfigWithWorkspace(workspaceId, mapping) {
+        try {
+            const vibehubConfig = await fs.readJson(this.configPath);
+            vibehubConfig.workspace = {
+                cursorWorkspaceId: workspaceId,
+                cursorWorkspacePath: mapping.cursorWorkspacePath,
+                isActive: mapping.isActive,
+                createdAt: mapping.createdAt,
+                lastAccessed: mapping.lastAccessed
+            };
+            vibehubConfig.lastUpdated = new Date().toISOString();
+            await fs.writeJson(this.configPath, vibehubConfig, { spaces: 2 });
+            console.log(`✅ Updated vibehub.json with workspace: ${workspaceId}`);
+        }
+        catch (error) {
+            console.log('⚠️  Could not update vibehub.json:', error.message);
+        }
+    }
+    /**
+     * Start real-time file watching for auto-sync (background service)
+     */
+    async startWorkspaceWatching(workspaceId) {
+        try {
+            const workspacePath = path.join(this.getCursorWorkspaceStoragePath(), workspaceId);
+            const stateDbPath = path.join(workspacePath, 'state.vscdb');
+            if (!await fs.pathExists(stateDbPath)) {
+                console.log('⚠️  No state.vscdb found for watching');
+                return;
+            }
+            // Auto-sync is now integrated into 'vibe add' command
+            console.log(`👁️  Auto-sync enabled for workspace: ${workspaceId}`);
+            console.log(`📝 New prompts will be synced when you run 'vibe add'`);
+        }
+        catch (error) {
+            console.log('⚠️  Could not setup auto-sync:', error.message);
+        }
+    }
+    /**
+     * Create a background watcher script
+     */
+    async createBackgroundWatcherScript(workspaceId, stateDbPath) {
+        const scriptDir = path.join(this.repoPath, '.vibehub', 'scripts');
+        await fs.ensureDir(scriptDir);
+        const scriptPath = path.join(scriptDir, 'watcher.js');
+        const scriptContent = `
+const chokidar = require('chokidar');
+const fs = require('fs-extra');
+const path = require('path');
+const Database = require('better-sqlite3');
+
+const workspaceId = '${workspaceId}';
+const stateDbPath = '${stateDbPath}';
+const repoPath = '${this.repoPath}';
+
+async function logToFile(message) {
+  try {
+    const logDir = path.join(repoPath, '.vibehub', 'logs');
+    await fs.ensureDir(logDir);
+    const logFile = path.join(logDir, 'vibehub-sync.log');
+    const timestamp = new Date().toISOString();
+    await fs.appendFile(logFile, \`[\${timestamp}] \${message}\\n\`);
+  } catch (error) {
+    // Silently fail if logging fails
+  }
+}
+
+async function syncNewData() {
+  try {
+    if (!await fs.pathExists(stateDbPath)) {
+      return;
+    }
+
+    // Load existing prompts
+    const sessionsDir = path.join(repoPath, '.vibehub', 'sessions');
+    const promptsFile = path.join(sessionsDir, 'prompts.json');
+    let existingPromptsData;
+    
+    try {
+      existingPromptsData = await fs.readJson(promptsFile);
+    } catch {
+      existingPromptsData = {
+        version: "1.0",
+        created_at: new Date().toISOString(),
+        last_updated: new Date().toISOString(),
+        total_prompts: 0,
+        prompts: []
+      };
+    }
+
+    // Extract new prompts
+    const db = new Database(stateDbPath, { readonly: true });
+    const promptsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.prompts'").get();
+    const generationsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.generations'").get();
+    db.close();
+
+    let newPromptsCount = 0;
+
+    // Process new prompts
+    if (promptsResult) {
+      const prompts = JSON.parse(promptsResult.value);
+      for (const prompt of prompts) {
+        if (prompt.text) {
+          const existingPrompt = existingPromptsData.prompts.find(p => p.text === prompt.text);
+          if (!existingPrompt) {
+            existingPromptsData.prompts.push({
+              id: existingPromptsData.prompts.length + 1,
+              text: prompt.text,
+              timestamp: prompt.unixMs || Date.now(),
+              timestamp_iso: new Date(prompt.unixMs || Date.now()).toISOString(),
+              source: 'cursor-database',
+              workspace_id: workspaceId,
+              metadata: {
+                commandType: prompt.commandType,
+                index: prompt.index
+              }
+            });
+            newPromptsCount++;
+          }
+        }
+      }
+    }
+
+    // Update prompts file
+    if (newPromptsCount > 0) {
+      existingPromptsData.total_prompts = existingPromptsData.prompts.length;
+      existingPromptsData.last_updated = new Date().toISOString();
+      await fs.writeJson(promptsFile, existingPromptsData, { spaces: 2 });
+      
+      // Regenerate CSV
+      await generatePromptsCsv();
+      
+      await logToFile(\`📝 Added \${newPromptsCount} new prompts\`);
+    }
+
+  } catch (error) {
+    await logToFile(\`⚠️  Sync failed: \${error.message}\`);
+  }
+}
+
+async function generatePromptsCsv() {
+  try {
+    const sessionsDir = path.join(repoPath, '.vibehub', 'sessions');
+    const promptsFile = path.join(sessionsDir, 'prompts.json');
+    const exportsDir = path.join(repoPath, '.vibehub', 'workspace', 'exports', \`workspace-\${workspaceId}\`);
+    
+    await fs.ensureDir(exportsDir);
+
+    const promptsData = await fs.readJson(promptsFile);
+    const workspacePrompts = promptsData.prompts.filter(p => p.workspace_id === workspaceId);
+
+    const csvRows = ['prompt_id,timestamp,prompt_text,workspace_id'];
+    
+    for (const prompt of workspacePrompts) {
+      const timestamp = new Date(prompt.timestamp).toISOString();
+      const promptText = prompt.text.replace(/"/g, '""').replace(/\\n/g, ' ');
+      csvRows.push(\`"\${prompt.id}","\${timestamp}","\${promptText}","\${workspaceId}"\`);
+    }
+
+    const csvContent = csvRows.join('\\n');
+    const csvFile = path.join(exportsDir, 'prompts_with_timestamps.csv');
+    await fs.writeFile(csvFile, csvContent);
+
+  } catch (error) {
+    await logToFile(\`⚠️  Could not generate CSV: \${error.message}\`);
+  }
+}
+
+// Start watching
+const watcher = chokidar.watch(stateDbPath, {
+  persistent: true,
+  ignoreInitial: true,
+  awaitWriteFinish: {
+    stabilityThreshold: 2000,
+    pollInterval: 100
+  }
+});
+
+let debounceTimer;
+
+watcher.on('change', async (path) => {
+  const logMessage = \`🔄 Detected change in \${path}\`;
+  await logToFile(logMessage);
+  
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(async () => {
+    try {
+      await logToFile('🔄 Syncing new prompts and generations...');
+      await syncNewData();
+      await logToFile('✅ Auto-sync completed');
+    } catch (error) {
+      await logToFile(\`⚠️  Auto-sync failed: \${error.message}\`);
+    }
+  }, 1000);
+});
+
+watcher.on('error', async (error) => {
+  await logToFile(\`⚠️  File watcher error: \${error.message}\`);
+});
+
+logToFile('👁️  Background watcher started').catch(console.error);
+`;
+        await fs.writeFile(scriptPath, scriptContent);
+    }
+    /**
+     * Start the background process
+     */
+    async startBackgroundProcess(workspaceId) {
+        try {
+            const { spawn } = await import('child_process');
+            const scriptPath = path.join(this.repoPath, '.vibehub', 'scripts', 'watcher.js');
+            // Start the watcher in a detached process
+            const child = spawn('node', [scriptPath], {
+                detached: true,
+                stdio: 'ignore'
+            });
+            // Store the process ID for cleanup
+            const pidFile = path.join(this.repoPath, '.vibehub', 'watcher.pid');
+            if (child.pid) {
+                await fs.writeFile(pidFile, child.pid.toString());
+            }
+            // Unref the child process so it doesn't keep the parent alive
+            child.unref();
+        }
+        catch (error) {
+            console.log('⚠️  Could not start background process:', error.message);
+        }
+    }
+    /**
+     * Log messages to a file for background operations
+     */
+    async logToFile(message) {
+        try {
+            const logDir = path.join(this.repoPath, '.vibehub', 'logs');
+            await fs.ensureDir(logDir);
+            const logFile = path.join(logDir, 'vibehub-sync.log');
+            const timestamp = new Date().toISOString();
+            await fs.appendFile(logFile, `[${timestamp}] ${message}\n`);
+        }
+        catch (error) {
+            // Silently fail if logging fails
+        }
+    }
+    /**
+     * Sync new data from Cursor workspace
+     */
+    async syncNewData(workspaceId) {
+        try {
+            const workspacePath = path.join(this.getCursorWorkspaceStoragePath(), workspaceId);
+            const stateDbPath = path.join(workspacePath, 'state.vscdb');
+            if (!await fs.pathExists(stateDbPath)) {
+                return;
+            }
+            // Load existing prompts to check for new ones
+            const sessionsDir = path.join(this.repoPath, '.vibehub', 'sessions');
+            const promptsFile = path.join(sessionsDir, 'prompts.json');
+            let existingPromptsData;
+            try {
+                existingPromptsData = await fs.readJson(promptsFile);
+            }
+            catch {
+                existingPromptsData = {
+                    version: "1.0",
+                    created_at: new Date().toISOString(),
+                    last_updated: new Date().toISOString(),
+                    total_prompts: 0,
+                    prompts: []
+                };
+            }
+            const existingPromptTexts = new Set(existingPromptsData.prompts.map((p) => p.text));
+            // Extract new prompts
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(stateDbPath, { readonly: true });
+            const promptsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.prompts'").get();
+            const generationsResult = db.prepare("SELECT value FROM ItemTable WHERE key = 'aiService.generations'").get();
+            db.close();
+            let newPromptsCount = 0;
+            let newGenerationsCount = 0;
+            // Process new prompts
+            if (promptsResult) {
+                const prompts = JSON.parse(promptsResult.value);
+                for (const prompt of prompts) {
+                    if (prompt.text) {
+                        // Check if this prompt already exists by text content
+                        const existingPrompt = existingPromptsData.prompts.find((p) => p.text === prompt.text);
+                        if (!existingPrompt) {
+                            existingPromptsData.prompts.push({
+                                id: existingPromptsData.prompts.length + 1, // Use integer ID
+                                text: prompt.text,
+                                timestamp: prompt.unixMs || Date.now(),
+                                timestamp_iso: new Date(prompt.unixMs || Date.now()).toISOString(),
+                                source: 'cursor-database',
+                                workspace_id: workspaceId,
+                                metadata: {
+                                    commandType: prompt.commandType,
+                                    index: prompt.index
+                                }
+                            });
+                            newPromptsCount++;
+                        }
+                    }
+                }
+            }
+            // Update prompts file
+            if (newPromptsCount > 0) {
+                existingPromptsData.total_prompts = existingPromptsData.prompts.length;
+                existingPromptsData.last_updated = new Date().toISOString();
+                await fs.writeJson(promptsFile, existingPromptsData, { spaces: 2 });
+                // Regenerate CSV with new prompts
+                await this.generatePromptsCsv(workspaceId);
+                console.log(`📝 Added ${newPromptsCount} new prompts`);
+            }
+            // Process new generations
+            if (generationsResult) {
+                const generations = JSON.parse(generationsResult.value);
+                const exportsDir = path.join(this.repoPath, '.vibehub', 'workspace', 'exports', `workspace-${workspaceId}`);
+                await fs.ensureDir(exportsDir);
+                const generationsFile = path.join(exportsDir, 'generations.jsonl');
+                const generationsData = generations.map((gen) => ({
+                    id: gen.id || `gen_${gen.unixMs || Date.now()}`,
+                    textDescription: gen.textDescription || gen.text || '',
+                    unixMs: gen.unixMs || Date.now(),
+                    timestamp: new Date(gen.unixMs || Date.now()).toISOString(),
+                    type: gen.type || 'generation',
+                    metadata: gen
+                }));
+                await fs.writeJson(generationsFile, generationsData, { spaces: 2 });
+                newGenerationsCount = generations.length;
+                console.log(`🤖 Updated ${newGenerationsCount} generations`);
+            }
+        }
+        catch (error) {
+            console.log('⚠️  Sync failed:', error.message);
+        }
+    }
+    /**
+     * Stop file watching for a workspace
+     */
+    async stopWorkspaceWatching(workspaceId) {
+        if (this.fileWatchers && this.fileWatchers.has(workspaceId)) {
+            const watcher = this.fileWatchers.get(workspaceId);
+            await watcher?.close();
+            this.fileWatchers.delete(workspaceId);
+            console.log(`👁️  Stopped watching workspace: ${workspaceId}`);
+        }
+    }
+    /**
+     * Manual sync method
+     */
+    async syncWorkspace(workspaceId) {
+        try {
+            console.log('🔄 Syncing workspace data...');
+            await this.syncNewData(workspaceId);
+            console.log('✅ Sync completed');
+        }
+        catch (error) {
+            console.log('⚠️  Sync failed:', error.message);
+        }
+    }
+    /**
+     * Stop all file watchers
+     */
+    async stopAllWatching() {
+        try {
+            const pidFile = path.join(this.repoPath, '.vibehub', 'watcher.pid');
+            if (await fs.pathExists(pidFile)) {
+                const pid = await fs.readFile(pidFile, 'utf-8');
+                const { exec } = await import('child_process');
+                // Kill the background process
+                exec(`kill ${pid.trim()}`, (error) => {
+                    if (error) {
+                        console.log('⚠️  Could not stop background watcher:', error.message);
+                    }
+                    else {
+                        console.log('👁️  Stopped background file watcher');
+                    }
+                });
+                // Remove the PID file
+                await fs.remove(pidFile);
+            }
+        }
+        catch (error) {
+            console.log('⚠️  Could not stop background watcher:', error.message);
+        }
+    }
+}
+//# sourceMappingURL=vibehub-manager.js.map