bobs-workshop 0.1.4

package/dist/index.js

@@ -0,0 +1,757 @@
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+// Import all tool handlers
+import { specCreateHandler, specUpdateHandler, specGetHandler, specListHandler } from "./tools/specTools.js";
+import { worktreeCreateHandler } from "./tools/worktreeTools.js";
+import { stopDevServer } from "./utils/processManager.js";
+import { hybridSearchHandler } from "./tools/searchTools.js";
+import { dashboardLaunchHandler, dashboardUpdateHandler } from "./tools/dashboardTools.js";
+import { workshopHandler } from "./tools/orchestratorTools.js";
+// REMOVED: Approval tools imports - use structured outputs instead
+import { getGitStatus, autoCommitChanges, autoMergeAndCleanup, findWorktreeForSpec } from "./tools/gitTools.js";
+import { autoDebugError, shouldInvokeDebugger } from "./tools/autoDebugger.js";
+import { cleanupService } from "./tools/cleanupService.js";
+import { changeValidator } from "./services/changeValidator.js";
+import { implementationSummarizer } from "./services/implementationSummarizer.js";
+import { mcpLogger } from "./services/mcpLogger.js";
+import { formatConciseResponse } from "./utils/responseFormatter.js";
+import { withTimeout, createCircuitBreaker, globalHealthChecker } from "./utils/reliability.js";
+import { withErrorHandling, globalErrorCollector } from "./utils/errorHandling.js";
+// Import all prompts
+import { ARCHITECT_PROMPT } from "./prompts/architect.js";
+import { ENGINEER_PROMPT } from "./prompts/engineer.js";
+import { DEBUGGER_PROMPT } from "./prompts/debugger.js";
+import { REVIEWER_PROMPT } from "./prompts/reviewer.js";
+// Global circuit breakers for external operations
+const fileSystemCircuitBreaker = createCircuitBreaker({
+    threshold: 5,
+    timeout: 15000,
+    resetTimeout: 30000
+});
+// Helper function to determine appropriate timeout for different tools
+function getToolTimeout(toolName) {
+    // Longer timeouts for complex operations
+    if (toolName.includes('search') || toolName.includes('hybrid')) {
+        return 45000; // 45 seconds for search operations
+    }
+    if (toolName.includes('workflow') || toolName.includes('create')) {
+        return 60000; // 60 seconds for workflow operations
+    }
+    return 20000; // 20 seconds default
+}
+// Initialize health checks for system components
+async function initializeHealthChecks() {
+    // MCP server health check
+    globalHealthChecker.register('mcp_server', async () => {
+        try {
+            // Basic functionality check
+            return process.uptime() > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+    // File system health check
+    globalHealthChecker.register('file_system', async () => {
+        try {
+            const fs = await import('fs-extra');
+            const path = await import('path');
+            const testPath = path.resolve(process.cwd(), '.bob');
+            await fs.ensureDir(testPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    // Dashboard service check
+    globalHealthChecker.register('dashboard', async () => {
+        try {
+            // Check if we can create the dashboard server
+            const { createDashboardServer } = await import('./dashboard/server.js');
+            const app = createDashboardServer();
+            return app !== null;
+        }
+        catch {
+            return false;
+        }
+    });
+    console.log("Health checks initialized");
+}
+// Graceful shutdown handler
+async function gracefulShutdown(server) {
+    console.log("Initiating graceful shutdown...");
+    try {
+        // Stop auto-cleanup service
+        const { cleanupService } = await import('./tools/cleanupService.js');
+        cleanupService.stopAutoCleanup();
+        console.log("Auto-cleanup service stopped");
+        // Perform final cleanup
+        await cleanupService.performCleanup({
+            maxWorktreeAge: 7,
+            cleanTempFiles: true,
+            stopOrphanedRecorders: true,
+            forceCleanup: false
+        });
+        console.log("Final cleanup completed");
+        // Log shutdown statistics
+        const errorStats = globalErrorCollector.getStats();
+        console.log("Error statistics:", errorStats);
+        console.log("Graceful shutdown completed");
+    }
+    catch (error) {
+        console.error("Error during shutdown:", error);
+    }
+}
+// Enhanced CLI output formatting for modern terminal experience
+function generateToolStatusMessage(toolName, args, status, duration, result, error) {
+    const toolCategory = getToolCategory(toolName);
+    const categoryIcon = getCategoryIcon(toolCategory);
+    const statusIcon = getStatusIcon(status);
+    const toolDisplayName = getToolDisplayName(toolName);
+    switch (status) {
+        case 'started':
+            return `${categoryIcon} [${toolCategory.toUpperCase()}] ${toolDisplayName} → ⏳ Starting...`;
+        case 'completed':
+            const durationText = formatDuration(duration || 0);
+            const summary = extractResultSummary(toolName, result);
+            return `${categoryIcon} [${toolCategory.toUpperCase()}] ${toolDisplayName} → ${statusIcon} ${summary} (${durationText})`;
+        case 'error':
+            const errorDuration = formatDuration(duration || 0);
+            return `${categoryIcon} [${toolCategory.toUpperCase()}] ${toolDisplayName} → ❌ Failed: ${error} (${errorDuration})`;
+        default:
+            return `${categoryIcon} [${toolCategory.toUpperCase()}] ${toolDisplayName}`;
+    }
+}
+function getToolCategory(toolName) {
+    if (toolName.includes('manual'))
+        return 'manual';
+    if (toolName.includes('search'))
+        return 'search';
+    if (toolName.includes('workflow'))
+        return 'workflow';
+    if (toolName.includes('dashboard'))
+        return 'dashboard';
+    if (toolName.includes('worktree'))
+        return 'worktree';
+    if (toolName.includes('validate'))
+        return 'validation';
+    if (toolName.includes('summarize'))
+        return 'analysis';
+    if (toolName.includes('health'))
+        return 'system';
+    if (toolName.includes('cleanup'))
+        return 'maintenance';
+    if (toolName.includes('workshop'))
+        return 'orchestration';
+    return 'tool';
+}
+function getCategoryIcon(category) {
+    const icons = {
+        'manual': '📋',
+        'search': '🔍',
+        'workflow': '🔄',
+        'dashboard': '💻',
+        'worktree': '🌳',
+        'validation': '✅',
+        'analysis': '📊',
+        'system': '🛠️',
+        'maintenance': '🧹',
+        'session': '📺',
+        'orchestration': '🎯',
+        'tool': '⚙️'
+    };
+    return icons[category] || '⚙️';
+}
+function getStatusIcon(status) {
+    const icons = {
+        'completed': '✅',
+        'error': '❌',
+        'started': '⏳',
+        'success': '✅'
+    };
+    return icons[status] || '📄';
+}
+function getToolDisplayName(toolName) {
+    return toolName.replace('bob.', '').replace(/\./g, '.');
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+}
+function extractResultSummary(toolName, result) {
+    if (!result)
+        return 'Completed';
+    // Custom summaries based on tool type
+    if (toolName.includes('manual')) {
+        if (result.spec_id) {
+            const action = toolName.includes('create') ? 'Created' : 'Updated';
+            return `${action} ${result.spec_id.split('-').pop() || 'manual'}`;
+        }
+        return 'Manual operation completed';
+    }
+    if (toolName.includes('search')) {
+        if (result.stats?.totalResults !== undefined) {
+            const count = result.stats.totalResults;
+            return `${count} result${count !== 1 ? 's' : ''} found`;
+        }
+        if (result.lexicalHits && result.semanticHits) {
+            const total = result.lexicalHits.length + result.semanticHits.length;
+            return `${total} result${total !== 1 ? 's' : ''} found`;
+        }
+        return 'Search completed';
+    }
+    if (toolName.includes('workflow')) {
+        if (toolName.includes('start') && result.manual?.spec_id) {
+            return `Workflow started for ${result.manual.spec_id.split('-').pop()}`;
+        }
+        if (toolName.includes('deploy')) {
+            return 'Deployment completed';
+        }
+        return 'Workflow operation completed';
+    }
+    if (toolName.includes('health')) {
+        const status = result.status || result.overall_healthy;
+        return status === 'healthy' || status === true ? 'System healthy' : 'Issues detected';
+    }
+    if (toolName.includes('validate')) {
+        if (result.overall_compliance) {
+            return `Validation: ${result.overall_compliance}`;
+        }
+        return 'Validation completed';
+    }
+    return 'Operation completed';
+}
+async function bootstrap() {
+    const server = new McpServer({
+        name: "bob-mcp",
+        version: "0.1.0"
+    });
+    // Initialize MCP logging with error handling
+    try {
+        mcpLogger.initialize(server.server);
+        console.log("MCP logging initialized successfully");
+    }
+    catch (error) {
+        console.error("Failed to initialize MCP logging:", error);
+        // Continue without logging rather than failing completely
+    }
+    // Initialize health checks
+    await initializeHealthChecks();
+    // Enhanced tool call wrapper with reliability features and modern CLI output
+    const withToolLogging = (toolName, handler) => {
+        return withErrorHandling(async (args, extra) => {
+            const startTime = Date.now();
+            const specId = (args && typeof args === 'object' && 'spec_id' in args) ? args.spec_id : undefined;
+            // Start logical operation for tool call
+            const operationId = await mcpLogger.startLogicalOperation('tool_call', specId, `🔧 Executing ${toolName}`);
+            // Generate enhanced status message for Claude Code terminal
+            const statusMessage = generateToolStatusMessage(toolName, args, 'started');
+            console.log(statusMessage);
+            await mcpLogger.logToolCall(toolName, args, specId);
+            try {
+                // Apply timeout to tool operations (30 seconds for most tools)
+                const timeoutMs = getToolTimeout(toolName);
+                const result = await withTimeout(() => handler(args, extra), { timeout: timeoutMs });
+                const duration = Date.now() - startTime;
+                // Add success sub-event
+                await mcpLogger.addSubEvent(operationId, {
+                    timestamp: new Date().toISOString(),
+                    event: 'tool_success',
+                    details: { tool_name: toolName, duration_ms: duration }
+                });
+                // Generate success status message
+                const successMessage = generateToolStatusMessage(toolName, args, 'completed', duration, result);
+                console.log(successMessage);
+                await mcpLogger.logToolSuccess(toolName, duration, specId);
+                await mcpLogger.completeLogicalOperation(operationId, true);
+                // Return enhanced result with status summary
+                return {
+                    ...result,
+                    _meta: {
+                        tool: toolName,
+                        duration_ms: duration,
+                        status: 'success',
+                        summary: extractResultSummary(toolName, result)
+                    }
+                };
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                // Add error sub-event
+                await mcpLogger.addSubEvent(operationId, {
+                    timestamp: new Date().toISOString(),
+                    event: 'tool_error',
+                    details: { tool_name: toolName, error: errorMsg }
+                });
+                // Generate error status message
+                const errorMessage = generateToolStatusMessage(toolName, args, 'error', duration, null, errorMsg);
+                console.log(errorMessage);
+                await mcpLogger.logToolError(toolName, errorMsg, duration, specId);
+                await mcpLogger.completeLogicalOperation(operationId, false);
+                // Auto-debug if we have a spec_id and this is a critical error
+                if (specId && shouldInvokeDebugger(error)) {
+                    try {
+                        await autoDebugError({
+                            spec_id: specId,
+                            operation: `MCP tool execution: ${toolName}`,
+                            error: error,
+                            context: { args, toolName, duration }
+                        });
+                        console.log(`[AUTO-DEBUG] Created debug log for ${toolName} error in spec ${specId}`);
+                    }
+                    catch (debugError) {
+                        console.log(`[AUTO-DEBUG] Failed to create debug log: ${debugError}`);
+                    }
+                }
+                throw error;
+            }
+        }, `MCP tool: ${toolName}`, (args) => ({
+            tool_name: toolName,
+            spec_id: (args && typeof args === 'object' && 'spec_id' in args) ? args.spec_id : undefined
+        }));
+    };
+    // Register orchestrator tool (main entry point)
+    server.registerTool("bob.workshop", {
+        title: "🔧 Intelligent workflow orchestrator for all development tasks",
+        description: "🔧 Main entry point for all development workflows. Analyzes problems, asks clarifying questions when needed, and routes to appropriate modes (Architect, Engineer, Debugger, Reviewer). Use this as your primary tool for any development task.",
+        inputSchema: {
+            problem: z.string().min(5).describe("Problem statement or task description (e.g. 'Add JWT authentication', 'Fix login bug', 'Review user service')"),
+            mode: z.enum(["architect", "engineer", "debugger", "reviewer"]).optional().describe("Preferred mode (optional - will be auto-determined based on problem)"),
+            spec_id: z.string().optional().describe("Continue work on existing manual (optional)"),
+            clarifications: z.record(z.string()).optional().describe("Answers to previous clarifying questions")
+        }
+    }, withToolLogging("bob.workshop", async ({ problem, mode, spec_id, clarifications }) => {
+        console.log("bob.workshop orchestrator called with:", { problem, mode, spec_id, clarifications });
+        const result = await workshopHandler({ problem, mode, spec_id, clarifications });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }));
+    // Register Manual management tools (new workshop terminology)
+    server.registerTool("bob.manual.create", {
+        title: "🔧 Start a new feature manual for this project",
+        description: "🔧 Start a new feature manual for this project. Use this when building new apps, features, or components. This creates the manual that drives planning, coding, debugging, and review.",
+        inputSchema: {
+            title: z.string().describe("Title of the feature/app to build (e.g. 'Sudoku PWA', 'User Authentication')"),
+            author: z.string().optional().describe("Author of the manual"),
+            category: z.string().optional().describe("Category: frontend, backend, fullstack, devtools, etc."),
+            priority: z.string().optional().describe("Priority: low, medium, high, critical"),
+            tags: z.array(z.string()).optional().describe("Tags for organization (e.g. ['pwa', 'mobile', 'game'])")
+        }
+    }, withToolLogging("bob.manual.create", async ({ title, author, category, priority, tags }) => {
+        console.log("bob.manual.create MCP tool called with:", { title, author, category, priority, tags });
+        const result = await specCreateHandler({ title, author, category, priority, tags, initial_state: "draft" });
+        const conciseText = await formatConciseResponse("bob.manual.create", result);
+        return { content: [{ type: "text", text: conciseText }] };
+    }));
+    server.registerTool("bob.manual.update", {
+        title: "🔧 Update details or logs in a manual",
+        description: "🔧 Update details or logs in a manual (implementation notes, debug entries, etc.). Use this to add progress updates, execution logs, or debug information to an existing manual.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID to update"),
+            section: z.enum(["executive_summary", "product_specifications", "architecture_analysis", "implementation_plan", "testing", "risk_assessment", "review"]).optional().describe("Section to update"),
+            content: z.string().optional().describe("Content to add to the section"),
+            execution_log: z.object({
+                timestamp: z.string(),
+                engineer: z.string(),
+                action: z.string(),
+                task_id: z.string(),
+                files_changed: z.array(z.string()),
+                commit_hash: z.string(),
+                note: z.string()
+            }).optional().describe("Execution log entry"),
+            debug_log: z.object({
+                timestamp: z.string(),
+                issue: z.string(),
+                root_cause: z.string(),
+                fix: z.string(),
+                confidence: z.string()
+            }).optional().describe("Debug log entry"),
+            state: z.enum(["draft", "ready", "engineered", "done"]).optional().describe("Manual state to set explicitly")
+        }
+    }, withToolLogging("bob.manual.update", async ({ spec_id, section, content, execution_log, debug_log, state }) => {
+        const result = await specUpdateHandler({ spec_id, section, content, execution_log, debug_log, state });
+        // Detect mode based on what type of update this is
+        let mode = 'unknown';
+        if (execution_log)
+            mode = 'engineer';
+        else if (debug_log)
+            mode = 'debugger';
+        else if (section === 'architecture_analysis' || section === 'product_specifications')
+            mode = 'architect';
+        else if (section === 'review')
+            mode = 'reviewer';
+        const conciseText = await formatConciseResponse("bob.manual.update", result);
+        return { content: [{ type: "text", text: conciseText }] };
+    }));
+    server.registerTool("bob.manual.get", {
+        title: "🔧 Retrieve a specific manual",
+        description: "🔧 Retrieve a specific manual with all its details, logs, and current status. Use this to review existing manuals before making updates or continuing work.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID to retrieve")
+        }
+    }, withToolLogging("bob.manual.get", async ({ spec_id }) => {
+        const result = await specGetHandler({ spec_id });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }));
+    server.registerTool("bob.manual.list", {
+        title: "🔧 List all project manuals",
+        description: "🔧 List all project manuals with their current status. Use this to see what features/components are planned, in progress, or completed.",
+        inputSchema: {
+            filter: z.string().optional().describe("Optional filter by title or category")
+        }
+    }, async ({ filter }) => {
+        const result = await specListHandler({ filter });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    // REMOVED: Legacy bob.spec.* tools - use bob.manual.* instead
+    // REMOVED: Individual worktree and git tools - use bob.workflow.* instead
+    // The following tools have been consolidated into bob.workflow.start and bob.workflow.deploy:
+    // - bob.worktree.list (use bob.worktree.debug with action: "status" instead)
+    // - bob.git.commit (automated by bob.workflow.deploy)
+    // - bob.git.merge (automated by bob.workflow.deploy)
+    // Advanced worktree maintenance tool (kept for debugging)
+    server.registerTool("bob.worktree.debug", {
+        title: "🔧 Debug and maintain worktrees",
+        description: "🔧 Comprehensive worktree maintenance tool. Handles repair (fix orphaned worktrees), cleanup (remove stale worktrees), validate (check worktree status), and status (detailed report). Essential for fail-safe worktree management.",
+        inputSchema: {
+            action: z.enum(["repair", "cleanup", "validate", "status"]).describe("Debug action: 'status' = report all worktrees, 'validate' = check manual worktree, 'repair' = fix orphaned worktrees, 'cleanup' = remove stale worktrees"),
+            spec_id: z.string().optional().describe("Optional manual ID for validate/repair actions"),
+            max_age_days: z.number().optional().default(7).describe("Max age in days for cleanup action (default: 7)")
+        }
+    }, withToolLogging("bob.worktree.debug", async ({ action, spec_id, max_age_days = 7 }) => {
+        const { worktreeDebugHandler } = await import("./tools/worktreeTools.js");
+        const result = await worktreeDebugHandler({ action, spec_id, max_age_days });
+        const conciseText = await formatConciseResponse("bob.worktree.debug", result);
+        return { content: [{ type: "text", text: conciseText }] };
+    }));
+    // REMOVED: Old search tools - use bob.code.search instead
+    server.registerTool("bob.code.search", {
+        title: "🔧 Unified lexical + semantic search",
+        description: "🔧 Hybrid search combining ripgrep (lexical) and semgrep (semantic) for comprehensive code search. Primary search tool with phase-aware execution and normalized outputs.",
+        inputSchema: {
+            query: z.string().describe("Search query to find in codebase"),
+            mode: z.enum(["lexical", "semantic", "auto"]).optional().default("auto").describe("Search mode: lexical (ripgrep only), semantic (semgrep only), or auto (both with smart scoping)"),
+            phase: z.enum(["architect", "engineer", "debugger", "reviewer"]).optional().describe("Caller phase for phase-aware Semgrep rule selection"),
+            path: z.string().optional().describe("Root path or subdirectory to search (optional)"),
+            includeHidden: z.boolean().optional().default(false).describe("Include hidden/ignored files (equivalent to rg -uuu)"),
+            followGitIgnore: z.boolean().optional().default(true).describe("Respect .gitignore rules (default: true)"),
+            fileTypes: z.array(z.string()).optional().describe("File types to include (e.g., ['ts', 'tsx', 'py'])"),
+            maxHits: z.number().optional().default(200).describe("Maximum total results across lexical and semantic"),
+            contextLines: z.number().optional().default(2).describe("Context lines before/after matches"),
+            timeoutMs: z.number().optional().default(4000).describe("Timeout in milliseconds")
+        }
+    }, async ({ query, mode, phase, path, includeHidden, followGitIgnore, fileTypes, maxHits, contextLines, timeoutMs }) => {
+        const result = await hybridSearchHandler({
+            query,
+            mode: mode || "auto",
+            phase,
+            path,
+            includeHidden: includeHidden || false,
+            followGitIgnore: followGitIgnore !== false,
+            fileTypes,
+            maxHits: maxHits || 200,
+            contextLines: contextLines || 2,
+            timeoutMs: timeoutMs || 4000
+        });
+        // Keep search results verbose since Claude needs to see the content
+        // But add concise summary to _meta for status messages
+        const enhancedResult = {
+            ...result,
+            _meta: {
+                ...(result._meta || {}),
+                summary: formatConciseResponse("bob.code.search", result)
+            }
+        };
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(enhancedResult, null, 2)
+                }]
+        };
+    });
+    // Register dashboard tools
+    server.registerTool("bob.dashboard.launch", {
+        title: "🔧 Open the visual workshop management interface",
+        description: "🔧 Launch the visual workshop dashboard for tracking manuals, worktrees, and logs on port 4577. Orchestrator should launch this when starting new feature development. Architect MUST launch this when working on new manuals. Returns status: 'launched', 'already_running', or 'already_running_external'. Process exits cleanly without hanging."
+    }, async () => {
+        const result = await dashboardLaunchHandler();
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    server.registerTool("bob.dashboard.update", {
+        title: "🔧 Send real-time updates to workshop dashboard",
+        description: "🔧 Push update to dashboard. Send real-time notifications to the dashboard about manual progress, server status, or other development events.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID to send update for"),
+            event: z.string().describe("Event description (e.g., 'server started', 'implementation completed')"),
+            data: z.object({}).optional().describe("Additional event data")
+        }
+    }, async ({ spec_id, event, data }) => {
+        const result = await dashboardUpdateHandler({ spec_id, event, data });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+    // REMOVED: Approval tools - use structured outputs with approval_required flag instead
+    // Register Simplified Workflow tools (bundled git + worktree operations)
+    server.registerTool("bob.workflow.start", {
+        title: "🔧 Start new feature development workflow",
+        description: "🔧 Architect workflow: Create manual + worktree + launch dashboard. Bundles manual creation, git worktree setup, and dashboard launch for streamlined feature development start.",
+        inputSchema: {
+            title: z.string().describe("Title of the feature/app to build"),
+            author: z.string().optional().describe("Author of the manual"),
+            category: z.string().optional().describe("Category: frontend, backend, fullstack, devtools, etc."),
+            priority: z.string().optional().describe("Priority: low, medium, high, critical"),
+            tags: z.array(z.string()).optional().describe("Tags for organization"),
+            branch_name: z.string().optional().describe("Custom branch name (auto-generated if not provided)")
+        }
+    }, withToolLogging("bob.workflow.start", async ({ title, author, category, priority, tags, branch_name }) => {
+        console.log("bob.workflow.start called with:", { title, author, category, priority, tags, branch_name });
+        // Create manual
+        const manual = await specCreateHandler({ title, author, category, priority, tags, initial_state: "draft" });
+        // Create worktree with auto-generated branch name if not provided
+        const branchName = branch_name || `feature/${title.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')}`;
+        const worktree = await worktreeCreateHandler({ spec_id: manual.spec_id, branch: branchName });
+        // Launch dashboard
+        const dashboard = await dashboardLaunchHandler();
+        // Send dashboard notification
+        await dashboardUpdateHandler({
+            spec_id: manual.spec_id,
+            event: "workflow_started",
+            data: { title, branch: branchName, dashboard_url: "http://localhost:4577" }
+        });
+        // Log workflow initialization via execution log
+        await specUpdateHandler({
+            spec_id: manual.spec_id,
+            execution_log: {
+                timestamp: new Date().toISOString(),
+                engineer: "architect",
+                action: "planning: milestone_completed",
+                task_id: "WORKFLOW_INIT",
+                files_changed: [`manual: ${manual.spec_id}`, `worktree: ${branchName}`, "dashboard: launched"],
+                commit_hash: "pending",
+                note: "[planning] 🎯 Milestone: Feature development workflow started. Deliverables: manual: " + manual.spec_id + ", worktree: " + branchName + ", dashboard: launched. Next: complete requirements analysis, create implementation plan, start development"
+            }
+        });
+        // NOTE: Dev server startup moved to post-test phase in Engineer workflow
+        // This prevents early resource conflicts and aligns with 3-gate approval system
+        const workflowResult = {
+            manual: manual,
+            worktree: worktree,
+            dashboard: dashboard,
+            workflow_status: "started",
+            work_recording: "active",
+            note: "Dev server will be started after implementation and testing"
+        };
+        const conciseText = await formatConciseResponse("bob.workflow.start", workflowResult);
+        return {
+            content: [{
+                    type: "text",
+                    text: conciseText
+                }]
+        };
+    }));
+    server.registerTool("bob.workflow.deploy", {
+        title: "🔧 Complete implementation and deploy to main",
+        description: "🔧 Engineer workflow: Commit changes + merge to main + cleanup worktree. Bundles git operations for streamlined feature completion and deployment.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID for the completed implementation"),
+            action_description: z.string().describe("Brief description of what was implemented"),
+            files_changed: z.array(z.string()).optional().describe("List of files changed (auto-detected if not provided)"),
+            target_branch: z.string().optional().default("main").describe("Target branch to merge into")
+        }
+    }, withToolLogging("bob.workflow.deploy", async ({ spec_id, action_description, files_changed, target_branch = "main" }) => {
+        console.log("bob.workflow.deploy called with:", { spec_id, action_description, files_changed, target_branch });
+        // Get git status and auto-detect changed files if not provided
+        const gitStatus = await getGitStatus();
+        const changedFiles = files_changed || [...gitStatus.staged_files, ...gitStatus.unstaged_files, ...gitStatus.untracked_files];
+        // NEW: Stop any running dev server before deployment
+        let serverCleanupInfo = null;
+        try {
+            console.log(`Stopping dev server for manual ${spec_id}...`);
+            const serverStopped = await stopDevServer(spec_id);
+            if (serverStopped) {
+                serverCleanupInfo = { server_stopped: true };
+                console.log(`Dev server stopped successfully for manual ${spec_id}`);
+                // Log server cleanup
+                await specUpdateHandler({
+                    spec_id,
+                    execution_log: {
+                        timestamp: new Date().toISOString(),
+                        engineer: "system",
+                        action: "server_stopped",
+                        task_id: "auto-server-cleanup",
+                        files_changed: [],
+                        commit_hash: "pending",
+                        note: `Auto-stopped dev server before deployment`
+                    }
+                });
+            }
+            else {
+                serverCleanupInfo = { server_stopped: false, reason: "no_server_running" };
+                console.log(`No running server found for manual ${spec_id}`);
+            }
+        }
+        catch (serverError) {
+            console.warn('Server cleanup failed (non-critical):', serverError);
+            serverCleanupInfo = { server_stopped: false, error: String(serverError) };
+        }
+        // Find worktree path for this spec
+        const worktreePath = await findWorktreeForSpec(spec_id);
+        console.log(`Found worktree path: ${worktreePath}`);
+        // Commit changes
+        const commit = await autoCommitChanges({
+            spec_id,
+            files_changed: changedFiles,
+            action_description,
+            worktree_path: worktreePath || undefined
+        });
+        // Merge and cleanup
+        const merge = await autoMergeAndCleanup({
+            spec_id,
+            target_branch,
+            cleanup_worktree: true
+        });
+        // Send dashboard notification
+        await dashboardUpdateHandler({
+            spec_id,
+            event: "workflow_deployed",
+            data: {
+                action_description,
+                files_changed: changedFiles,
+                target_branch,
+                commit_hash: commit.commit_hash
+            }
+        });
+        // Record completion milestone
+        await specUpdateHandler({
+            spec_id: spec_id,
+            execution_log: {
+                timestamp: new Date().toISOString(),
+                engineer: "engineer",
+                action: "implementation: workflow_deployment_completed",
+                task_id: "WORKFLOW_DEPLOY",
+                files_changed: changedFiles,
+                commit_hash: commit.commit_hash,
+                note: `🚀 Successfully deployed implementation: ${action_description}. Committed ${changedFiles.length} files and merged to ${target_branch}. Commit: ${commit.commit_hash}`
+            }
+        });
+        const deployResult = {
+            commit: commit,
+            merge: merge,
+            server_cleanup: serverCleanupInfo,
+            workflow_status: "deployed",
+            work_recording: "completed"
+        };
+        const conciseText = await formatConciseResponse("bob.workflow.deploy", deployResult);
+        return {
+            content: [{
+                    type: "text",
+                    text: conciseText
+                }]
+        };
+    }));
+    // Health check tool migrated to CLI: use "bobs health"
+    // Register change validation tool
+    server.registerTool("bob.validate.changes", {
+        title: "🔍 Validate implementation changes against manual",
+        description: "🔍 Validate recent file changes against manual expectations. Analyzes actual diffs, checks compliance, and provides human-readable summaries of what was implemented.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID to validate changes against")
+        }
+    }, withToolLogging("bob.validate.changes", async ({ spec_id }) => {
+        console.log("bob.validate.changes called with:", { spec_id });
+        if (!spec_id) {
+            throw new Error("spec_id is required");
+        }
+        const validationResult = await changeValidator.validateChangesForSpec(spec_id);
+        // Update manual with validation results
+        await changeValidator.updateSpecWithValidation(validationResult);
+        return { content: [{ type: "text", text: JSON.stringify(validationResult, null, 2) }] };
+    }));
+    // Register implementation summarizer tool
+    server.registerTool("bob.summarize.implementation", {
+        title: "📊 Generate implementation summary from chokidar observations",
+        description: "📊 Analyze file changes observed by chokidar and generate comprehensive implementation summaries with compliance analysis, git commits, and actionable insights. Updates the manual's implementation logs.",
+        inputSchema: {
+            spec_id: z.string().describe("Manual ID to generate implementation summary for"),
+            lookback_hours: z.number().optional().default(24).describe("Hours to look back for changes (default: 24)")
+        }
+    }, withToolLogging("bob.summarize.implementation", async ({ spec_id, lookback_hours = 24 }) => {
+        console.log("bob.summarize.implementation called with:", { spec_id, lookback_hours });
+        if (!spec_id) {
+            throw new Error("spec_id is required");
+        }
+        const summary = await implementationSummarizer.generateSummaryForSpec(spec_id, lookback_hours);
+        // Update manual with summary
+        await implementationSummarizer.updateSpecWithSummary(summary);
+        return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    }));
+    // Cleanup tools migrated to CLI: use "bobs cleanup" and "bobs cleanup --stats"
+    // Debug tool - no parameters
+    server.registerTool("bob.debug", {
+        title: "🔧 Debug Bob's Workshop server state",
+        description: "🔧 Debug tool with no parameters. Use this to check Bob's Workshop internal state and troubleshoot issues.",
+    }, async () => {
+        console.log("bob.debug called successfully");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Debug tool works!",
+                },
+            ],
+        };
+    });
+    // Register prompts
+    server.registerPrompt("Architect", { description: "Requirements analysis and technical planning specialist" }, async () => ({
+        messages: [{ role: "user", content: [{ type: "text", text: ARCHITECT_PROMPT }] }]
+    }));
+    server.registerPrompt("Engineer", { description: "Implementation specialist following engineering best practices" }, async () => ({
+        messages: [{ role: "user", content: [{ type: "text", text: ENGINEER_PROMPT }] }]
+    }));
+    server.registerPrompt("Debugger", { description: "Issue diagnosis and resolution specialist" }, async () => ({
+        messages: [{ role: "user", content: [{ type: "text", text: DEBUGGER_PROMPT }] }]
+    }));
+    server.registerPrompt("Reviewer", { description: "Quality assurance and security audit specialist" }, async () => ({
+        messages: [{ role: "user", content: [{ type: "text", text: REVIEWER_PROMPT }] }]
+    }));
+    // Start auto-cleanup service
+    cleanupService.startAutoCleanup(30); // Every 30 minutes
+    console.log("Auto-cleanup service started (30-minute intervals)");
+    // Set up graceful shutdown handlers
+    const signals = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+    signals.forEach(signal => {
+        process.on(signal, async () => {
+            console.log(`Received ${signal}, initiating graceful shutdown`);
+            await gracefulShutdown(server);
+            process.exit(0);
+        });
+    });
+    // Handle uncaught exceptions and rejections
+    process.on('uncaughtException', async (error) => {
+        console.error('Uncaught Exception:', error);
+        globalErrorCollector.add(await import('./utils/errorHandling.js').then(m => m.enhanceError(error, m.createErrorContext('uncaught_exception'))));
+        await gracefulShutdown(server);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', async (reason, promise) => {
+        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        globalErrorCollector.add(await import('./utils/errorHandling.js').then(m => m.enhanceError(error, m.createErrorContext('unhandled_rejection'))));
+        await gracefulShutdown(server);
+        process.exit(1);
+    });
+    console.log("Starting Bob MCP server with enhanced reliability...");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log("Bob MCP server started successfully");
+}
+bootstrap().catch(err => {
+    console.error("Failed to start Bob MCP:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map