bobs-workshop 0.1.4

package/dist/dashboard/server.js

@@ -0,0 +1,1206 @@
+// 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()
+            });
+            // If enhanced_activity is provided, save it to SPEC file
+            if (spec_id && enhanced_activity) {
+                try {
+                    const specsDir = path.resolve(process.cwd(), ".bob/specs");
+                    const specPath = path.join(specsDir, `${spec_id}.json`);
+                    if (await fs.pathExists(specPath)) {
+                        const specData = await fs.readJson(specPath);
+                        // Initialize enhanced_activities if needed
+                        if (!specData.enhanced_activities) {
+                            specData.enhanced_activities = [];
+                        }
+                        // Add enhanced activity
+                        specData.enhanced_activities.push(enhanced_activity);
+                        specData.updated_at = new Date().toISOString();
+                        // Save back to file
+                        await fs.writeFile(specPath, JSON.stringify(specData, null, 2), "utf8");
+                    }
+                }
+                catch (fileError) {
+                    console.error(`Failed to save enhanced activity to SPEC ${spec_id}:`, fileError);
+                    // Continue - notification was still saved
+                }
+            }
+            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" });
+        }
+    });
+    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