bobs-workshop 0.3.2 → 3.1.0

package/dist/dashboard/server.js

@@ -1,1203 +0,0 @@
-// src/dashboard/server.ts
-import express from "express";
-import path from "path";
-import { fileURLToPath } from "url";
-import fs from "fs-extra";
-import { specCreateHandler, specUpdateHandler, specGetHandler, specListHandler } from "../tools/specTools.js";
-import { worktreeCreateHandler, worktreeListHandler, worktreeMergeHandler, worktreeRemoveHandler } from "../tools/worktreeTools.js";
-import { semgrepSearchHandler, enhancedFileSearchHandler } from "../tools/searchTools.js";
-import { createApprovalRequest, processApprovalResponse, checkApprovalStatus, handleApprovalTimeout } from "../tools/approvalTools.js";
-import { fileMonitor } from "../services/fileMonitor.js";
-import { mcpLogger } from "../services/mcpLogger.js";
-import multer from "multer";
-import { taskService, createErrorResponse, createSuccessResponse } from "../api/taskLogger.js";
-class NotificationManager {
-    constructor() {
-        this.notifications = [];
-        this.maxNotifications = 1000;
-    }
-    addNotification(notification) {
-        const fullNotification = {
-            id: `notif_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            ...notification
-        };
-        this.notifications.push(fullNotification);
-        // Keep only the last N notifications
-        if (this.notifications.length > this.maxNotifications) {
-            this.notifications = this.notifications.slice(-this.maxNotifications);
-        }
-        console.log(`📢 Dashboard notification: [${fullNotification.spec_id || 'system'}] ${fullNotification.event}`);
-        return fullNotification;
-    }
-    getRecentNotifications(limit = 50) {
-        return this.notifications.slice(-limit);
-    }
-    getNotificationsBySpec(spec_id, limit = 20) {
-        return this.notifications
-            .filter(n => n.spec_id === spec_id)
-            .slice(-limit);
-    }
-    clearOldNotifications(olderThanHours = 24) {
-        const cutoff = new Date(Date.now() - (olderThanHours * 60 * 60 * 1000));
-        const originalLength = this.notifications.length;
-        this.notifications = this.notifications.filter(n => new Date(n.timestamp) > cutoff);
-        return originalLength - this.notifications.length;
-    }
-}
-const notificationManager = new NotificationManager();
-// Helper functions for enhanced file change descriptions
-function generateFileChangeDescription(change) {
-    const fileName = change.file.split('/').pop() || change.file;
-    const fileExt = change.file.split('.').pop() || '';
-    let action = '';
-    let actionDetails = '';
-    switch (change.type) {
-        case 'added':
-            action = '➕ Created';
-            actionDetails = 'New file added to project';
-            break;
-        case 'changed':
-            action = '✏️ Modified';
-            actionDetails = 'Existing file updated with changes';
-            break;
-        case 'unlinked':
-            action = '🗑️ Deleted';
-            actionDetails = 'File removed from project';
-            break;
-        default:
-            action = '📝 Updated';
-            actionDetails = 'File content or structure changed';
-    }
-    const fileTypeInfo = getFileTypeDescription(fileExt);
-    const timeAgo = getTimeAgo(change.timestamp);
-    const linesInfo = change.lines_changed ? ` (${change.lines_changed} lines)` : '';
-    return `${action} ${fileTypeInfo} ${fileName}${linesInfo} • ${actionDetails} ${timeAgo}`;
-}
-function categorizeFileChange(filePath) {
-    if (filePath.includes('test') || filePath.includes('spec'))
-        return 'test';
-    if (filePath.includes('util') || filePath.includes('helper'))
-        return 'utility';
-    if (filePath.includes('component') || filePath.includes('ui'))
-        return 'component';
-    if (filePath.includes('service') || filePath.includes('api'))
-        return 'service';
-    if (filePath.includes('config') || filePath.endsWith('.json'))
-        return 'config';
-    if (filePath.includes('style') || filePath.endsWith('.css'))
-        return 'style';
-    if (filePath.endsWith('.md') || filePath.includes('doc'))
-        return 'documentation';
-    return 'core';
-}
-function getFileTypeDescription(ext) {
-    const typeMap = {
-        'ts': 'TypeScript file',
-        'js': 'JavaScript file',
-        'json': 'JSON config',
-        'md': 'documentation',
-        'css': 'stylesheet',
-        'html': 'HTML file',
-        'vue': 'Vue component',
-        'jsx': 'React component',
-        'tsx': 'React TypeScript component',
-        'yml': 'YAML config',
-        'yaml': 'YAML config'
-    };
-    return typeMap[ext] || 'file';
-}
-async function getFileGitDiff(filePath) {
-    try {
-        const { simpleGit } = await import('simple-git');
-        const gitInstance = simpleGit(process.cwd());
-        // Get the diff for the file (current worktree vs main branch to show all changes)
-        const diff = await gitInstance.diff(['--numstat', 'main', '--', filePath]);
-        if (!diff.trim()) {
-            return null;
-        }
-        const lines = diff.trim().split('\n');
-        const stats = lines[0].split('\t');
-        if (stats.length >= 2) {
-            const linesAdded = parseInt(stats[0]) || 0;
-            const linesRemoved = parseInt(stats[1]) || 0;
-            let diffSummary = '';
-            if (linesAdded > 0 && linesRemoved > 0) {
-                diffSummary = `+${linesAdded} -${linesRemoved}`;
-            }
-            else if (linesAdded > 0) {
-                diffSummary = `+${linesAdded}`;
-            }
-            else if (linesRemoved > 0) {
-                diffSummary = `-${linesRemoved}`;
-            }
-            return { linesAdded, linesRemoved, diffSummary };
-        }
-        return null;
-    }
-    catch (error) {
-        console.error('Error getting git diff for file:', filePath, error);
-        return null;
-    }
-}
-function generateHumanReadableActivityDescription(activity) {
-    if (!activity)
-        return 'Unknown activity';
-    // Handle verbose mode-specific details first
-    if (activity.data?.verbose_details) {
-        const verboseDescription = generateVerboseActivityDescription(activity);
-        if (verboseDescription)
-            return verboseDescription;
-    }
-    // Handle different types of activities
-    if (activity.type === 'mcp_operation') {
-        return generateMcpOperationDescription(activity);
-    }
-    if (activity.action) {
-        return generateActionDescription(activity);
-    }
-    if (activity.note) {
-        return activity.note;
-    }
-    return 'Activity completed';
-}
-function generateVerboseActivityDescription(activity) {
-    const mode = activity.data?.mode;
-    const verbose = activity.data?.verbose_details;
-    if (!mode || !verbose)
-        return null;
-    switch (mode) {
-        case 'engineer':
-            if (verbose.engineer) {
-                const eng = verbose.engineer;
-                let description = '';
-                if (eng.task_description) {
-                    description += `🔧 ${eng.task_description}`;
-                }
-                if (eng.completion_percentage !== undefined) {
-                    description += ` (${eng.completion_percentage}% complete)`;
-                }
-                if (eng.tasks_completed?.length) {
-                    description += ` • Completed: ${eng.tasks_completed.join(', ')}`;
-                }
-                if (eng.files_modified?.length) {
-                    description += ` • Files: ${eng.files_modified.length} modified`;
-                }
-                if (eng.build_status === 'success') {
-                    description += ' ✅ Build passed';
-                }
-                else if (eng.build_status === 'failed') {
-                    description += ' ❌ Build failed';
-                }
-                if (eng.test_status === 'passed') {
-                    description += ' 🧪 Tests passed';
-                }
-                else if (eng.test_status === 'failed') {
-                    description += ' 🧪 Tests failed';
-                }
-                return description || 'Engineer task completed';
-            }
-            break;
-        case 'debugger':
-            if (verbose.debugger) {
-                const dbg = verbose.debugger;
-                let description = '';
-                if (dbg.issue_description) {
-                    description += `🐛 Issue: ${dbg.issue_description}`;
-                }
-                if (dbg.root_cause) {
-                    description += ` • Root cause: ${dbg.root_cause}`;
-                }
-                if (dbg.fix_description) {
-                    description += ` • Fix: ${dbg.fix_description}`;
-                }
-                if (dbg.confidence_level) {
-                    const confidenceIcon = dbg.confidence_level === 'high' ? '🎯' :
-                        dbg.confidence_level === 'medium' ? '⚖️' : '❓';
-                    description += ` ${confidenceIcon} Confidence: ${dbg.confidence_level}`;
-                }
-                if (dbg.files_affected?.length) {
-                    description += ` • Affected: ${dbg.files_affected.length} files`;
-                }
-                return description || 'Debug task completed';
-            }
-            break;
-        case 'architect':
-            if (verbose.architect) {
-                const arch = verbose.architect;
-                let description = '';
-                if (arch.spec_sections_completed?.length) {
-                    description += `📋 Completed: ${arch.spec_sections_completed.join(', ')}`;
-                }
-                if (arch.research_findings?.length) {
-                    description += ` • Research: ${arch.research_findings.length} findings`;
-                }
-                if (arch.design_decisions?.length) {
-                    description += ` • Decisions: ${arch.design_decisions.length} made`;
-                }
-                if (arch.codebase_insights?.length) {
-                    description += ` • Insights: ${arch.codebase_insights.length} discovered`;
-                }
-                if (arch.architecture_patterns?.length) {
-                    description += ` • Patterns: ${arch.architecture_patterns.join(', ')}`;
-                }
-                return description || 'Architecture task completed';
-            }
-            break;
-    }
-    return null;
-}
-function generateMcpOperationDescription(activity) {
-    const tool = activity.tool_name || activity.operation || 'unknown';
-    const status = activity.status || 'completed';
-    const toolDescriptions = {
-        'bob.workshop': '🔧 Workshop orchestration',
-        'bob.manual.create': '📝 Manual creation',
-        'bob.manual.update': '✏️ Manual update',
-        'bob.manual.get': '📖 Manual retrieval',
-        'bob.workflow.start': '🚀 Workflow initiation',
-        'bob.workflow.deploy': '🚢 Deployment process',
-        'bob.code.search': '🔍 Code search',
-        'bob.validate.changes': '✅ Change validation',
-        'bob.summarize.implementation': '📊 Implementation summary',
-        'bob.dashboard.launch': '💻 Dashboard launch'
-    };
-    const description = toolDescriptions[tool] || `🔧 ${tool.replace('bob.', '').replace(/[._]/g, ' ')}`;
-    const statusIcon = status === 'success' ? '✅' : status === 'error' ? '❌' : '⏳';
-    return `${description} ${statusIcon}`;
-}
-function generateActionDescription(activity) {
-    const action = activity.action || '';
-    const actionDescriptions = {
-        'implementation_complete': '✅ Code implementation completed successfully',
-        'validation_compliant': '✅ Validation passed - changes are compliant',
-        'validation_partial': '⚠️ Validation completed with some issues',
-        'validation_non_compliant': '❌ Validation failed - changes need review',
-        'worktree_created': '🌳 Development workspace created',
-        'worktree_merged': '🔄 Changes merged to main branch',
-        'worktree_removed': '🗑️ Development workspace removed',
-        'worktree_status_changed': '🔄 Workspace status updated',
-        'commit_created': '💾 Changes committed to repository',
-        'files_modified': '📝 Files updated in project',
-        'test_run': '🧪 Tests executed',
-        'build_completed': '🏗️ Build process completed',
-        'deployment_started': '🚀 Deployment initiated',
-        'deployment_completed': '✅ Deployment completed successfully',
-        'debug_session': '🐛 Debug session completed',
-        'code_review': '👀 Code review performed',
-        'documentation_updated': '📚 Documentation updated'
-    };
-    // Try exact match first
-    if (actionDescriptions[action]) {
-        return actionDescriptions[action];
-    }
-    // Try partial matches
-    if (action.includes('implement'))
-        return '🛠️ Implementation work completed';
-    if (action.includes('validate') || action.includes('validation'))
-        return '✅ Validation process completed';
-    if (action.includes('commit'))
-        return '💾 Code changes committed';
-    if (action.includes('merge'))
-        return '🔄 Code changes merged';
-    if (action.includes('test'))
-        return '🧪 Testing completed';
-    if (action.includes('build'))
-        return '🏗️ Build process completed';
-    if (action.includes('deploy'))
-        return '🚀 Deployment completed';
-    if (action.includes('debug'))
-        return '🐛 Debug process completed';
-    if (action.includes('review'))
-        return '👀 Review completed';
-    if (action.includes('create'))
-        return '✨ Creation completed';
-    if (action.includes('update') || action.includes('modify'))
-        return '✏️ Update completed';
-    if (action.includes('delete') || action.includes('remove'))
-        return '🗑️ Removal completed';
-    // Fallback: humanize the action name
-    const humanized = action
-        .replace(/[_-]/g, ' ')
-        .replace(/\b\w/g, (l) => l.toUpperCase());
-    return `📋 ${humanized}`;
-}
-function getTimeAgo(timestamp) {
-    const now = new Date();
-    const changeTime = new Date(timestamp);
-    const diffMs = now.getTime() - changeTime.getTime();
-    const diffMins = Math.floor(diffMs / (1000 * 60));
-    if (diffMins < 1)
-        return 'just now';
-    if (diffMins < 60)
-        return `${diffMins}m ago`;
-    const diffHours = Math.floor(diffMins / 60);
-    if (diffHours < 24)
-        return `${diffHours}h ago`;
-    const diffDays = Math.floor(diffHours / 24);
-    return `${diffDays}d ago`;
-}
-// Compatibility for import.meta in different environments
-const getFilename = () => {
-    // Check if we're in a test environment
-    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-        return "/src/dashboard/server.ts";
-    }
-    // Check if import.meta is available
-    if (typeof import.meta !== 'undefined' && import.meta.url) {
-        return fileURLToPath(import.meta.url);
-    }
-    // Fallback
-    return "/src/dashboard/server.ts";
-};
-const __filename = getFilename();
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, "../..");
-export function createDashboardServer() {
-    const app = express();
-    app.use(express.json());
-    app.use(express.static(path.join(projectRoot, "public")));
-    app.use("/src", express.static(path.join(projectRoot, "src")));
-    // Multer configuration for image uploads
-    const storage = multer.memoryStorage();
-    const upload = multer({
-        storage,
-        limits: {
-            fileSize: 5 * 1024 * 1024, // 5MB limit
-        },
-        fileFilter: (req, file, cb) => {
-            // Accept common image formats
-            const allowedTypes = ['image/png', 'image/jpeg', 'image/jpg', 'image/gif', 'image/webp'];
-            if (allowedTypes.includes(file.mimetype)) {
-                cb(null, true);
-            }
-            else {
-                cb(new Error('Invalid file type. Only PNG, JPEG, GIF, and WebP are allowed.'));
-            }
-        }
-    });
-    // SPEC management endpoints
-    app.post("/api/tools/bob.spec.create", async (req, res) => {
-        try {
-            const result = await specCreateHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.spec.update", async (req, res) => {
-        try {
-            const result = await specUpdateHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.spec.get", async (req, res) => {
-        try {
-            const result = await specGetHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.get("/api/tools/bob.spec.list", async (req, res) => {
-        try {
-            const result = await specListHandler({ filter: req.query.filter });
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.spec.delete", async (req, res) => {
-        try {
-            const { spec_id } = req.body;
-            if (!spec_id) {
-                return res.status(400).json({ error: "spec_id is required" });
-            }
-            const specsDir = path.resolve(process.cwd(), ".bob/specs");
-            const filePath = path.join(specsDir, `${spec_id}.json`);
-            const indexPath = path.join(specsDir, "index.json");
-            // Check if spec exists
-            if (!await fs.pathExists(filePath)) {
-                return res.status(404).json({ error: `SPEC ${spec_id} not found` });
-            }
-            // Delete the spec file
-            await fs.remove(filePath);
-            // Update index.json
-            if (await fs.pathExists(indexPath)) {
-                const indexData = await fs.readJson(indexPath);
-                indexData.specs = (indexData.specs || []).filter((spec) => spec.spec_id !== spec_id);
-                await fs.writeFile(indexPath, JSON.stringify(indexData, null, 2), "utf8");
-            }
-            res.json({ status: "deleted", spec_id });
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Image upload endpoint for inline image support
-    app.post("/api/images/upload-inline", upload.single('image'), async (req, res) => {
-        try {
-            if (!req.file) {
-                return res.status(400).json({ error: "No image file provided" });
-            }
-            const workingDir = process.cwd();
-            const uploadsDir = path.join(workingDir, '.mcp', 'uploads');
-            // Ensure uploads directory exists
-            await fs.ensureDir(uploadsDir);
-            // Generate auto-increment filename
-            const files = await fs.readdir(uploadsDir);
-            const imageFiles = files.filter(f => /\.(png|jpg|jpeg|gif|webp)$/i.test(f));
-            const nextNumber = imageFiles.length + 1;
-            // Get file extension
-            const ext = path.extname(req.file.originalname) || '.png';
-            const filename = `img${nextNumber}${ext}`;
-            const filePath = path.join(uploadsDir, filename);
-            // Save file to uploads directory
-            await fs.writeFile(filePath, req.file.buffer);
-            // Return placeholder data for frontend
-            res.json({
-                success: true,
-                placeholder: {
-                    id: `img${nextNumber}`,
-                    filename: filename,
-                    path: `./mcp/uploads/${filename}`,
-                    size: req.file.size,
-                    mimetype: req.file.mimetype
-                }
-            });
-            // Add notification
-            notificationManager.addNotification({
-                event: "image_uploaded",
-                data: {
-                    filename: filename,
-                    size: req.file.size,
-                    path: `./mcp/uploads/${filename}`
-                },
-                timestamp: new Date().toISOString()
-            });
-        }
-        catch (error) {
-            console.error('Image upload error:', error);
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Worktree endpoints
-    app.get("/api/tools/bob.worktree.list", async (req, res) => {
-        try {
-            const result = await worktreeListHandler();
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.worktree.create", async (req, res) => {
-        try {
-            const result = await worktreeCreateHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.worktree.merge", async (req, res) => {
-        try {
-            const result = await worktreeMergeHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.worktree.remove", async (req, res) => {
-        try {
-            const result = await worktreeRemoveHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Research endpoints
-    app.post("/api/tools/bob.search.enhanced", async (req, res) => {
-        try {
-            const result = await enhancedFileSearchHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/tools/bob.search.semgrep", async (req, res) => {
-        try {
-            const result = await semgrepSearchHandler(req.body);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // User approval endpoints
-    app.get("/api/approvals/:spec_id", async (req, res) => {
-        try {
-            const { spec_id } = req.params;
-            const approval_type = req.query.approval_type;
-            const result = await checkApprovalStatus(spec_id, approval_type);
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/approvals/request", async (req, res) => {
-        try {
-            const { spec_id, approval_type, message, context } = req.body;
-            if (!spec_id || !approval_type || !message) {
-                return res.status(400).json({
-                    error: "spec_id, approval_type, and message are required"
-                });
-            }
-            const result = await createApprovalRequest({ spec_id, approval_type, message, context });
-            // Send real-time notification to dashboard
-            notificationManager.addNotification({
-                spec_id,
-                event: "approval_requested",
-                data: {
-                    approval_type,
-                    message,
-                    approval_id: result.approval_id,
-                    dashboard_url: result.dashboard_url
-                },
-                timestamp: new Date().toISOString()
-            });
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/approvals/respond", async (req, res) => {
-        try {
-            const { spec_id, approval_type, approved, feedback, timestamp } = req.body;
-            if (!spec_id || !approval_type || typeof approved !== 'boolean') {
-                return res.status(400).json({
-                    error: "spec_id, approval_type, and approved (boolean) are required"
-                });
-            }
-            const result = await processApprovalResponse({
-                spec_id,
-                approval_type,
-                approved,
-                feedback,
-                timestamp
-            });
-            // Send real-time notification to dashboard
-            notificationManager.addNotification({
-                spec_id,
-                event: "approval_responded",
-                data: {
-                    approval_type,
-                    approved,
-                    feedback,
-                    new_state: result.new_state,
-                    approval_id: result.approval_id
-                },
-                timestamp: result.timestamp
-            });
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/approvals/timeout", async (req, res) => {
-        try {
-            const { spec_id, approval_type } = req.body;
-            if (!spec_id || !approval_type) {
-                return res.status(400).json({
-                    error: "spec_id and approval_type are required"
-                });
-            }
-            const result = await handleApprovalTimeout(spec_id, approval_type);
-            // Send real-time notification to dashboard
-            notificationManager.addNotification({
-                spec_id,
-                event: "approval_timeout",
-                data: {
-                    approval_type,
-                    approval_id: result.approval_id,
-                    timeout_at: result.timeout_at
-                },
-                timestamp: new Date().toISOString()
-            });
-            res.json(result);
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // File monitoring endpoints
-    app.get("/api/file-changes", (req, res) => {
-        try {
-            const limit = parseInt(req.query.limit) || 50;
-            const changes = fileMonitor.getRecentChanges(limit);
-            res.json({ changes });
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.get("/api/untracked-changes", (req, res) => {
-        try {
-            const untracked = fileMonitor.getUntrackedChanges();
-            res.json({ untracked });
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    app.post("/api/assign-to-spec", async (req, res) => {
-        try {
-            const { files, spec_id } = req.body;
-            await fileMonitor.manuallyAssignToSpec(files, spec_id);
-            res.json({ status: "assigned" });
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Enhanced dashboard data endpoint
-    app.get("/api/dashboard-data", async (req, res) => {
-        try {
-            const specsDir = path.resolve(projectRoot, ".bob/specs");
-            const indexPath = path.join(specsDir, "index.json");
-            if (!await fs.pathExists(indexPath)) {
-                return res.json({ specs: [], untracked: [], recent_changes: [] });
-            }
-            const indexData = await fs.readJson(indexPath);
-            const enhancedSpecs = [];
-            for (const specSummary of indexData.specs || []) {
-                const specPath = path.join(specsDir, `${specSummary.spec_id}.json`);
-                if (await fs.pathExists(specPath)) {
-                    const specData = await fs.readJson(specPath);
-                    // Parse implementation plan into task checklist
-                    const implementationPlan = specData.implementation_plan || [];
-                    const executionLogs = specData.execution_logs || specData.execution_log || [];
-                    const taskChecklist = implementationPlan.map((task) => {
-                        const isCompleted = executionLogs.some((log) => log.task_id === task.task_id);
-                        const associatedLogs = executionLogs.filter((log) => log.task_id === task.task_id);
-                        return {
-                            task_id: task.task_id,
-                            description: task.description,
-                            completed: isCompleted,
-                            execution_count: associatedLogs.length,
-                            last_updated: associatedLogs.length > 0 ? associatedLogs[associatedLogs.length - 1].timestamp : null
-                        };
-                    });
-                    // Create per-SPEC timeline: Prioritize enhanced_activities, fallback to legacy logs
-                    const mcpOperations = specData.mcp_tool_operations || [];
-                    // PRIORITY 1: Enhanced activities (new unified format)
-                    const enhancedActivitiesTimeline = (specData.enhanced_activities || []).map(async (activity) => {
-                        // Enrich files with real git diff data
-                        const enrichedFiles = await Promise.all((activity.files_changed || []).map(async (file) => {
-                            const gitDiff = await getFileGitDiff(file.path);
-                            return {
-                                ...file,
-                                lines_added: gitDiff?.linesAdded || file.lines_added || 0,
-                                lines_removed: gitDiff?.linesRemoved || file.lines_removed || 0,
-                                diff_summary: gitDiff?.diffSummary || file.diff_summary || ''
-                            };
-                        }));
-                        return {
-                            ...activity,
-                            files_changed: enrichedFiles,
-                            human_description: activity.summary,
-                            is_enhanced: true // Flag to identify enhanced activities in frontend
-                        };
-                    });
-                    const resolvedEnhancedActivities = await Promise.all(enhancedActivitiesTimeline);
-                    // PRIORITY 2: Legacy logs (for backward compatibility)
-                    const legacyTimeline = specData.enhanced_activities && specData.enhanced_activities.length > 0 ? [] : [
-                        ...executionLogs.map((log) => ({
-                            ...log,
-                            type: 'execution',
-                            role: 'engineer',
-                            human_description: generateHumanReadableActivityDescription(log),
-                            is_enhanced: false
-                        })),
-                        ...(specData.debug_logs || specData.debug_log || []).map((log) => ({
-                            ...log,
-                            type: 'debug',
-                            role: 'debugger',
-                            human_description: generateHumanReadableActivityDescription(log),
-                            is_enhanced: false
-                        })),
-                        ...(specData.activity || []).map((activity) => ({
-                            ...activity,
-                            type: activity.type || 'activity',
-                            role: activity.role || 'system',
-                            action: activity.action || activity.note || 'Activity logged',
-                            human_description: generateHumanReadableActivityDescription(activity),
-                            is_enhanced: false
-                        }))
-                    ];
-                    // Add MCP operations to timeline
-                    const mcpTimeline = mcpOperations.map((op) => ({
-                        timestamp: op.timestamp,
-                        type: 'mcp_operation',
-                        role: 'mcp_system',
-                        tool_name: op.tool_name,
-                        success: op.success,
-                        duration_ms: op.duration_ms,
-                        parameters: op.input_parameters,
-                        error_message: op.error_message,
-                        human_description: generateHumanReadableActivityDescription(op),
-                        is_enhanced: false
-                    }));
-                    // Combine and sort by timestamp
-                    const timeline = [
-                        ...resolvedEnhancedActivities,
-                        ...legacyTimeline,
-                        ...mcpTimeline
-                    ].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-                    // Get file changes for this SPEC
-                    const fileChanges = specData.file_changes || [];
-                    // Get approval information for this SPEC
-                    let approvalInfo = {
-                        pending_approvals: [],
-                        recent_approvals: [],
-                        approval_history: []
-                    };
-                    try {
-                        const approvalStatus = await checkApprovalStatus(specSummary.spec_id);
-                        approvalInfo = {
-                            pending_approvals: approvalStatus.pending_approvals || [],
-                            recent_approvals: approvalStatus.all_approvals?.filter((a) => a.status === 'approved' || a.status === 'rejected').slice(-3) || [], // Last 3 completed approvals
-                            approval_history: approvalStatus.all_approvals || []
-                        };
-                    }
-                    catch (error) {
-                        console.log(`Failed to get approval status for ${specSummary.spec_id}:`, error);
-                    }
-                    // Determine if awaiting user input
-                    const awaitingApproval = approvalInfo.pending_approvals.length > 0;
-                    const currentApprovalType = awaitingApproval ? approvalInfo.pending_approvals[0]?.approval_type : null;
-                    // Get change validation information
-                    const changeValidations = specData.change_validations || [];
-                    const latestValidation = changeValidations.length > 0 ? changeValidations[changeValidations.length - 1] : null;
-                    // Get implementation summaries
-                    const implementationSummaries = specData.implementation_summaries || [];
-                    const latestSummary = implementationSummaries.length > 0 ? implementationSummaries[implementationSummaries.length - 1] : null;
-                    // Process file changes into human-readable format with validation status
-                    const enhancedFileChanges = await Promise.all(fileChanges.slice(-20).map(async (change) => {
-                        // Find validation data for this file
-                        const validationData = latestValidation?.file_analyses?.find((analysis) => analysis.file === change.file);
-                        // Get git diff information
-                        const gitDiff = await getFileGitDiff(change.file);
-                        return {
-                            ...change,
-                            humanReadable: generateFileChangeDescription(change),
-                            category: categorizeFileChange(change.file),
-                            compliance_status: validationData?.compliance || 'unknown',
-                            compliance_reason: validationData?.reason,
-                            lines_changed: validationData?.lineCount || (gitDiff ? gitDiff.linesAdded + gitDiff.linesRemoved : 0),
-                            human_description: validationData?.humanSummary || generateFileChangeDescription(change),
-                            git_diff: gitDiff ? {
-                                lines_added: gitDiff.linesAdded,
-                                lines_removed: gitDiff.linesRemoved,
-                                diff_summary: gitDiff.diffSummary,
-                                total_changes: gitDiff.linesAdded + gitDiff.linesRemoved
-                            } : null
-                        };
-                    }));
-                    // Extract worktree metadata from SPEC
-                    const worktreeInfo = specData.worktree || {
-                        branch: '',
-                        path: '',
-                        status: 'pending',
-                        created_at: '',
-                        removed_at: ''
-                    };
-                    enhancedSpecs.push({
-                        ...specSummary,
-                        task_checklist: taskChecklist,
-                        timeline,
-                        file_changes: enhancedFileChanges,
-                        completion_percentage: Math.round((taskChecklist.filter((t) => t.completed).length / Math.max(taskChecklist.length, 1)) * 100),
-                        approval_info: approvalInfo,
-                        awaiting_approval: awaitingApproval,
-                        current_approval_type: currentApprovalType,
-                        user_action_required: awaitingApproval,
-                        worktree: {
-                            branch: worktreeInfo.branch,
-                            path: worktreeInfo.path,
-                            status: worktreeInfo.status,
-                            created_at: worktreeInfo.created_at,
-                            removed_at: worktreeInfo.removed_at,
-                            is_active: worktreeInfo.status === 'active',
-                            display_path: worktreeInfo.path ? worktreeInfo.path.replace(process.cwd(), '.') : ''
-                        },
-                        change_validation: latestValidation ? {
-                            overall_compliance: latestValidation.overall_compliance,
-                            last_validated: latestValidation.timestamp,
-                            file_analyses: latestValidation.file_analyses || [],
-                            human_readable_changes: latestValidation.summary?.human_readable_changes || [],
-                            recommendations: latestValidation.recommendations || []
-                        } : null,
-                        implementation_summary: latestSummary ? {
-                            period_start: latestSummary.period_start,
-                            period_end: latestSummary.period_end,
-                            files_changed_count: latestSummary.files_changed?.length || 0,
-                            implementation_notes: latestSummary.implementation_notes || [],
-                            compliance_overview: latestSummary.compliance_overview || {
-                                total_files: 0,
-                                compliant_files: 0,
-                                deviation_files: 0,
-                                unexpected_files: 0,
-                                overall_status: 'unknown'
-                            },
-                            actionable_insights: latestSummary.actionable_insights || [],
-                            git_commits_count: latestSummary.git_commits?.length || 0
-                        } : null
-                    });
-                }
-            }
-            // Get untracked changes
-            const untrackedChanges = fileMonitor.getUntrackedChanges();
-            const recentChanges = fileMonitor.getRecentChanges(50);
-            // Get recent notifications and convert them to dashboard format
-            const recentNotifications = notificationManager.getRecentNotifications(20);
-            const notificationChanges = recentNotifications.map(notification => ({
-                type: 'notification',
-                path: `[${notification.event}]`,
-                timestamp: notification.timestamp,
-                spec_id: notification.spec_id,
-                event: notification.event,
-                data: notification.data,
-                role: notification.data?.role || 'system'
-            }));
-            // Get MCP tool operations from all SPECs for recent activity
-            const mcpOperationChanges = [];
-            for (const spec of enhancedSpecs) {
-                const mcpOps = spec.timeline?.filter((item) => item.type === 'mcp_operation') || [];
-                mcpOperationChanges.push(...mcpOps.slice(-5).map((op) => ({
-                    type: 'mcp_operation',
-                    path: `[MCP] ${op.tool_name}`,
-                    timestamp: op.timestamp,
-                    spec_id: spec.spec_id,
-                    event: op.tool_name,
-                    tool_name: op.tool_name,
-                    success: op.success,
-                    duration_ms: op.duration_ms,
-                    parameters: op.parameters,
-                    role: 'mcp_system'
-                })));
-            }
-            // Combine file changes, notifications, and MCP operations, sort by timestamp
-            const allChanges = [
-                ...recentChanges.map((change) => ({ ...change, type: 'file' })),
-                ...notificationChanges,
-                ...mcpOperationChanges
-            ].sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()).slice(0, 50);
-            // Sort specs by updated_at descending (latest first)
-            const sortedSpecs = enhancedSpecs.sort((a, b) => new Date(b.updated_at || 0).getTime() - new Date(a.updated_at || 0).getTime());
-            res.json({
-                specs: sortedSpecs,
-                untracked: untrackedChanges,
-                recent_changes: allChanges,
-                timestamp: new Date().toISOString()
-            });
-        }
-        catch (error) {
-            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
-        }
-    });
-    // Dashboard notification endpoints
-    app.post("/api/updates", async (req, res) => {
-        try {
-            const { spec_id, event, data, timestamp, enhanced_activity } = req.body;
-            if (!event) {
-                return res.status(400).json({ error: "Event is required" });
-            }
-            const notification = notificationManager.addNotification({
-                spec_id,
-                event,
-                data: data || {},
-                timestamp: timestamp || new Date().toISOString()
-            });
-            // Note: Enhanced activities are persisted via bob.manual.update only
-            // This endpoint is just for real-time UI notifications
-            res.json({
-                status: "notification_received",
-                notification_id: notification.id
-            });
-        }
-        catch (error) {
-            res.status(500).json({
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    });
-    app.get("/api/notifications", (req, res) => {
-        try {
-            const limit = parseInt(req.query.limit) || 50;
-            const spec_id = req.query.spec_id;
-            let notifications;
-            if (spec_id) {
-                notifications = notificationManager.getNotificationsBySpec(spec_id, limit);
-            }
-            else {
-                notifications = notificationManager.getRecentNotifications(limit);
-            }
-            res.json({
-                notifications,
-                count: notifications.length,
-                timestamp: new Date().toISOString()
-            });
-        }
-        catch (error) {
-            res.status(500).json({
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    });
-    app.post("/api/notifications/cleanup", (req, res) => {
-        try {
-            const hours = parseInt(req.body.hours) || 24;
-            const removed = notificationManager.clearOldNotifications(hours);
-            res.json({
-                status: "cleanup_completed",
-                removed_count: removed
-            });
-        }
-        catch (error) {
-            res.status(500).json({
-                error: error instanceof Error ? error.message : String(error)
-            });
-        }
-    });
-    // SSE endpoint for real-time events
-    app.get('/api/events/stream', (req, res) => {
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*'
-        });
-        // Send initial connection event
-        res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: new Date().toISOString() })}\n\n`);
-        // Subscribe to logical operations
-        const handleOperation = (operation) => {
-            res.write(`data: ${JSON.stringify(operation)}\n\n`);
-        };
-        mcpLogger.eventEmitter.on('logical_operation_start', handleOperation);
-        mcpLogger.eventEmitter.on('logical_operation_update', handleOperation);
-        mcpLogger.eventEmitter.on('logical_operation_complete', handleOperation);
-        // Cleanup on disconnect
-        req.on('close', () => {
-            mcpLogger.eventEmitter.off('logical_operation_start', handleOperation);
-            mcpLogger.eventEmitter.off('logical_operation_update', handleOperation);
-            mcpLogger.eventEmitter.off('logical_operation_complete', handleOperation);
-        });
-        // Keep connection alive
-        const keepAlive = setInterval(() => {
-            res.write(': keepalive\n\n');
-        }, 30000);
-        req.on('close', () => clearInterval(keepAlive));
-    });
-    // Health check
-    // MCP logs endpoint for activity timeline
-    app.get("/api/mcp-logs", (req, res) => {
-        const specId = req.query.spec_id;
-        const logs = mcpLogger.getLogs(specId);
-        res.json({ logs });
-    });
-    // Task Logger API Endpoints
-    // GET /api/tasks - List all tasks
-    app.get("/api/tasks", (req, res) => {
-        try {
-            const { priority, status, search } = req.query;
-            let tasks;
-            if (priority) {
-                tasks = taskService.getTasksByPriority(priority);
-            }
-            else if (status) {
-                tasks = taskService.getTasksByStatus(status);
-            }
-            else if (search) {
-                tasks = taskService.searchTasks(search);
-            }
-            else {
-                tasks = taskService.getAllTasks();
-            }
-            res.json(createSuccessResponse({
-                tasks,
-                count: tasks.length,
-                total: taskService.getTaskCount()
-            }));
-        }
-        catch (error) {
-            console.error("[TaskLogger API] Error listing tasks:", error);
-            res.status(500).json(createErrorResponse("Failed to list tasks", 500));
-        }
-    });
-    // POST /api/tasks - Create new task
-    app.post("/api/tasks", (req, res) => {
-        try {
-            const task = taskService.createTask(req.body);
-            res.status(201).json(createSuccessResponse(task, "Task created successfully"));
-        }
-        catch (error) {
-            console.error("[TaskLogger API] Error creating task:", error);
-            if (error instanceof Error && error.message.includes("validation")) {
-                res.status(400).json(createErrorResponse(error.message));
-            }
-            else {
-                res.status(500).json(createErrorResponse("Failed to create task", 500));
-            }
-        }
-    });
-    // GET /api/tasks/:id - Get specific task
-    app.get("/api/tasks/:id", (req, res) => {
-        try {
-            const task = taskService.getTaskById(req.params.id);
-            if (!task) {
-                return res.status(404).json(createErrorResponse("Task not found", 404));
-            }
-            res.json(createSuccessResponse(task));
-        }
-        catch (error) {
-            console.error("[TaskLogger API] Error getting task:", error);
-            res.status(500).json(createErrorResponse("Failed to get task", 500));
-        }
-    });
-    // PUT /api/tasks/:id - Update task
-    app.put("/api/tasks/:id", (req, res) => {
-        try {
-            const task = taskService.updateTask(req.params.id, req.body);
-            if (!task) {
-                return res.status(404).json(createErrorResponse("Task not found", 404));
-            }
-            res.json(createSuccessResponse(task, "Task updated successfully"));
-        }
-        catch (error) {
-            console.error("[TaskLogger API] Error updating task:", error);
-            if (error instanceof Error && error.message.includes("validation")) {
-                res.status(400).json(createErrorResponse(error.message));
-            }
-            else {
-                res.status(500).json(createErrorResponse("Failed to update task", 500));
-            }
-        }
-    });
-    // DELETE /api/tasks/:id - Delete task
-    app.delete("/api/tasks/:id", (req, res) => {
-        try {
-            const deleted = taskService.deleteTask(req.params.id);
-            if (!deleted) {
-                return res.status(404).json(createErrorResponse("Task not found", 404));
-            }
-            res.json(createSuccessResponse(null, "Task deleted successfully"));
-        }
-        catch (error) {
-            console.error("[TaskLogger API] Error deleting task:", error);
-            res.status(500).json(createErrorResponse("Failed to delete task", 500));
-        }
-    });
-    app.get("/api/git-diff", async (req, res) => {
-        try {
-            const { file, commit } = req.query;
-            if (!file) {
-                return res.status(400).json({ error: "File parameter is required" });
-            }
-            const gitDiff = await getFileGitDiff(file);
-            if (gitDiff) {
-                res.json({
-                    file: file,
-                    lines_added: gitDiff.linesAdded,
-                    lines_removed: gitDiff.linesRemoved,
-                    diff_summary: gitDiff.diffSummary,
-                    total_changes: gitDiff.linesAdded + gitDiff.linesRemoved
-                });
-            }
-            else {
-                res.json({
-                    file: file,
-                    lines_added: 0,
-                    lines_removed: 0,
-                    diff_summary: "",
-                    total_changes: 0
-                });
-            }
-        }
-        catch (error) {
-            console.error("Error getting git diff:", error);
-            res.status(500).json({ error: "Failed to get git diff" });
-        }
-    });
-    // Serve MCP manifest at /.well-known/mcp/manifest.json
-    app.get("/.well-known/mcp/manifest.json", async (req, res) => {
-        try {
-            const manifestPath = path.join(projectRoot, "public", ".well-known", "mcp", "manifest.json");
-            if (!await fs.pathExists(manifestPath)) {
-                return res.status(404).json({ error: "Manifest not found" });
-            }
-            const manifest = await fs.readJson(manifestPath);
-            // Set appropriate headers for manifest serving
-            res.setHeader('Content-Type', 'application/json');
-            res.setHeader('Cache-Control', 'public, max-age=300'); // 5 minutes cache
-            res.json(manifest);
-        }
-        catch (error) {
-            console.error("Error serving manifest:", error);
-            res.status(500).json({ error: "Failed to serve manifest" });
-        }
-    });
-    // Project info endpoint - returns current repository name based on process.cwd()
-    app.get("/api/project-info", (req, res) => {
-        try {
-            const cwd = process.cwd();
-            const repoName = path.basename(cwd);
-            res.json({
-                repoName,
-                workingDirectory: cwd
-            });
-        }
-        catch (error) {
-            res.status(500).json({
-                error: error instanceof Error ? error.message : String(error),
-                repoName: 'unknown',
-                workingDirectory: process.cwd()
-            });
-        }
-    });
-    app.get("/api/health", (req, res) => {
-        res.json({ status: "ok", uptime: process.uptime() });
-    });
-    return app;
-}
-// Start server when run directly
-const isMainModule = () => {
-    // Don't auto-start in test environments
-    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-        return false;
-    }
-    // Check if import.meta is available
-    if (typeof import.meta !== 'undefined' && import.meta.url) {
-        return import.meta.url === `file://${process.argv[1]}`;
-    }
-    return false;
-};
-if (isMainModule()) {
-    const app = createDashboardServer();
-    const port = 4577; // Match the expected dashboard port
-    app.listen(port, () => {
-        console.log(`Bob's Workshop dashboard running on http://localhost:${port}`);
-    });
-} // Test git diff functionality - timestamp: Sun 28 Sep 2025 19:38:38 IST
-//# sourceMappingURL=server.js.map