bobs-workshop 0.3.2 → 3.1.0

package/dist/index.js

@@ -1,960 +0,0 @@
-#!/usr/bin/env node
-// src/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-import { fileURLToPath } from "url";
-import path from "path";
-import fs from "fs-extra";
-// 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 } from "./tools/dashboardTools.js";
-import { workshopHandler, formatRoleDirective } 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: "bobs-workshop",
-        version: "0.2.0"
-    }, {
-        capabilities: {
-            resources: {},
-            prompts: {},
-            tools: {},
-            logging: {}
-        }
-    });
-    // 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();
-    // Send startup observation to reinforce policy awareness
-    try {
-        await mcpLogger.info("👋 Welcome to Bob's Workshop! Please review mcp://bobs-workshop/policy before invoking any tools.");
-    }
-    catch (error) {
-        console.log("Note: Could not send startup observation, but continuing normally");
-    }
-    // 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
-        }));
-    };
-    // Configure path resolution for manifest (works in both dev and global install)
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const getManifestPath = () => {
-        // Resolve manifest path relative to compiled dist directory
-        // When installed globally: /opt/homebrew/lib/node_modules/bobs-mcp/dist/index.js
-        // Manifest at: /opt/homebrew/lib/node_modules/bobs-mcp/public/.well-known/mcp/manifest.json
-        return path.resolve(__dirname, "../public/.well-known/mcp/manifest.json");
-    };
-    // Register MCP resource endpoints to expose manifest.json
-    // This allows Claude Code to read llm_guidance configuration for tool selection
-    server.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-        return {
-            resources: [
-                {
-                    uri: "mcp://bobs-workshop/manifest",
-                    name: "Bob's MCP Manifest",
-                    description: "MCP server manifest with tool definitions and LLM guidance for optimal tool selection",
-                    mimeType: "application/json"
-                },
-                {
-                    uri: "mcp://bobs-workshop/policy",
-                    name: "Bob's Workshop Policy",
-                    description: "Runtime behavioral rules and best practices for using Bob's Workshop",
-                    mimeType: "text/markdown"
-                }
-            ]
-        };
-    });
-    server.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        if (request.params.uri === "mcp://bobs-workshop/manifest") {
-            try {
-                const manifestPath = getManifestPath();
-                // Check if manifest file exists
-                if (!await fs.pathExists(manifestPath)) {
-                    console.error(`[MANIFEST ERROR] Manifest not found at: ${manifestPath}`);
-                    throw new Error(`Manifest file not found at ${manifestPath}`);
-                }
-                const manifest = await fs.readFile(manifestPath, "utf-8");
-                console.log(`[MANIFEST] Served manifest from ${manifestPath}`);
-                return {
-                    contents: [{
-                            uri: request.params.uri,
-                            mimeType: "application/json",
-                            text: manifest
-                        }]
-                };
-            }
-            catch (error) {
-                console.error(`[MANIFEST ERROR] Failed to read manifest:`, error);
-                throw new Error(`Failed to read manifest: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        if (request.params.uri === "mcp://bobs-workshop/policy") {
-            const policyContent = `# Bob's Workshop – Usage Policy
-
-## 1. Code Search Best Practices
-
-**Understanding Search Modes:**
-
-**Lexical Mode** (pattern matching via ripgrep):
-- ✅ Single terms: \`bob.code.search({ query: "mcpLogger", mode: "lexical" })\`
-- ✅ Regex patterns: \`bob.code.search({ query: "mcpLogger\\\\.(log|info)", mode: "lexical" })\`
-- ✅ Multi-word: Automatically interpreted with smart cascade (see below)
-
-**Multi-Word Query Smart Cascade:**
-When you use multi-word queries like "pdf export", the tool automatically tries patterns in order:
-1. **Method call** (2 words, identifiers): \`object\\.(method)\`
-2. **Ordered proximity** (3+ words or fallback): \`word1.*word2.*word3\`
-3. **OR pattern** (last resort if #2 returns 0): \`\\b(word1|word2|word3)\\b\`
-
-The tool will inform you which pattern was used and return results automatically.
-
-**Semantic Mode** (conceptual via semgrep):
-- ✅ Multi-word concepts: \`bob.code.search({ query: "authentication error handling", mode: "auto" })\`
-- Automatically selected for 3+ word queries in architect/debugger/reviewer phases
-- Best for understanding architecture, security, patterns
-
-**Auto Mode** (recommended - intelligent routing):
-- Automatically chooses lexical or semantic based on query and phase
-- 3+ words + semantic-enabled phase → semantic mode
-- Otherwise → lexical mode with smart cascade
-
-**Examples:**
-\`\`\`javascript
-// Method call (auto-detects)
-bob.code.search({ query: "mcpLogger info", mode: "lexical" })
-// → Tries: mcpLogger\\.(info) → Results found ✅
-
-// Concept search (ordered proximity)
-bob.code.search({ query: "pdf export", mode: "lexical" })
-// → Tries: pdf.*export → 355 results ✅
-// → Note: Skipped OR pattern (would return 1,665 noisy results)
-
-// Semantic routing (auto mode)
-bob.code.search({ query: "authentication flow security", mode: "auto", phase: "architect" })
-// → Routes to semantic search
-\`\`\`
-
-## 2. Tool Preference Hierarchy
-
-**Search Strategy:**
-1. **Start with \`bob.code.search\`** (auto mode) - smart cascade handles multi-word
-2. **Use Glob** for finding specific files by name/pattern
-3. **Use Read** when you know the exact file path
-4. **Use Grep** only for exact string matching (when bob.code.search doesn't fit)
-
-**Manual Updates:**
-- ❌ DO NOT create separate markdown files
-- ✅ ALWAYS use \`bob.manual.update\` with execution_log/debug_log
-
-**Git Operations:**
-- ❌ DO NOT use manual git commands
-- ✅ ALWAYS use \`bob.workflow.start\` and \`bob.workflow.deploy\`
-
-## 3. Workflow Sequence
-Follow the mode progression:
-Orchestrator → Architect → Engineer → Debugger → Reviewer
-
-## 4. Manual as Single Source of Truth
-- All specifications, logs, and progress MUST be in SPEC files
-- DO NOT create separate markdown files
-- Use \`bob.manual.update\` with execution_log or debug_log
-
-## 5. Mode-Specific Responsibilities
-**Architect**: Creates executive_summary, product_specifications, architecture_analysis, implementation_plan, testing
-**Engineer**: Updates execution_logs
-**Debugger**: Updates debug_logs
-**Reviewer**: Creates own review manual
-
-## 6. Before Acting
-1. Review this policy
-2. Use \`bob.code.search\` to locate information
-3. Log updates with \`bob.manual.update\`
-`;
-            console.log(`[POLICY] Served policy resource`);
-            return {
-                contents: [{
-                        uri: request.params.uri,
-                        mimeType: "text/markdown",
-                        text: policyContent
-                    }]
-            };
-        }
-        throw new Error(`Unknown resource URI: ${request.params.uri}`);
-    });
-    console.log("[MANIFEST] Resource endpoints registered successfully");
-    // 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 assigns you a role (Architect, Engineer, Debugger, Reviewer). When this tool returns, YOU will assume the assigned role and execute the provided actions immediately. This is not external routing - you are the agent.",
-        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 });
-        // Format response with role directive if routing to a mode (BACKEND-002 & BACKEND-003)
-        // This implements Option A: Enhanced Tool Response pattern from workflows-mcp-server
-        let responseText;
-        if ((result.action === 'route' || result.action === 'continue') && result.next_mode) {
-            const directive = formatRoleDirective(result.next_mode, {
-                spec_id: result.spec_id,
-                problem: problem,
-                confidence: 'confidence_score' in result ? result.confidence_score : undefined
-            });
-            responseText = `${directive}\n\n---\n\nContext (JSON):\n${JSON.stringify(result, null, 2)}`;
-        }
-        else {
-            // For clarify, await_approval, etc. - just return JSON (no directive)
-            responseText = JSON.stringify(result, null, 2);
-        }
-        return { content: [{ type: "text", text: responseText }] };
-    }));
-    // 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 + structural search",
-        description: "🔧 Hybrid search combining ripgrep (lexical), semgrep (semantic), and AST-based (structural) 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. Structural queries like 'find references to X', 'show dependencies' use AST analysis."),
-            mode: z.enum(["lexical", "semantic", "structural", "auto"]).optional().default("auto").describe("Search mode: lexical (ripgrep), semantic (semgrep), structural (AST-based), or auto (intelligent routing)"),
-            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(30).describe("Maximum total results to return (default: 30 for token efficiency)"),
-            perFileLimit: z.number().optional().default(5).describe("Maximum matches per file (default: 5 to prevent single-file domination)"),
-            contextLines: z.number().optional().default(2).describe("Context lines before/after matches"),
-            timeoutMs: z.number().optional().default(4000).describe("Timeout in milliseconds"),
-            verbose: z.boolean().optional().default(false).describe("Include full lexicalHits/semanticHits arrays for debugging (increases token usage)")
-        }
-    }, async ({ query, mode, phase, path, includeHidden, followGitIgnore, fileTypes, maxHits, perFileLimit, contextLines, timeoutMs, verbose }) => {
-        const result = await hybridSearchHandler({
-            query,
-            mode: mode || "auto",
-            phase,
-            path,
-            includeHidden: includeHidden || false,
-            followGitIgnore: followGitIgnore !== false,
-            fileTypes,
-            maxHits: maxHits || 30,
-            perFileLimit: perFileLimit || 5,
-            contextLines: contextLines || 2,
-            timeoutMs: timeoutMs || 4000,
-            verbose: verbose || false
-        });
-        // 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) }] };
-    });
-    // REMOVED: bob.dashboard.update tool - use bob.manual.update with execution_log/debug_log instead
-    // 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();
-        // Log workflow initialization via execution log (dashboard reads from SPEC file)
-        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
-        });
-        // Record completion milestone (dashboard reads from SPEC file)
-        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 }] }]
-    }));
-    server.registerPrompt("help", { description: "Get guidance on using Bob's Workshop effectively" }, async () => {
-        const helpContent = `You are connected to Bob's Workshop MCP.
-
-Before taking any actions:
-1. Review \`mcp://bobs-workshop/policy\` for behavioral rules
-2. Use \`bob.code.search\` to locate information
-3. Log updates with \`bob.manual.update\`
-4. Follow the workflow sequence: Orchestrator → Architect → Engineer → Debugger → Reviewer
-
-## Quick Reference
-
-**Multi-Word Search - Smart Cascade:**
-
-The tool automatically interprets your query:
-
-**Method Calls** (2 words, identifiers):
-\`\`\`javascript
-{ query: "mcpLogger info", mode: "lexical" }
-// → Auto-tries: mcpLogger\\.(info)
-// → Finds: await mcpLogger.info(...) calls
-\`\`\`
-
-**Concept Search** (3+ words or fallback):
-\`\`\`javascript
-{ query: "pdf export", mode: "lexical" }
-// → Auto-tries: pdf.*export
-// → Finds: 355 results about PDF export
-// → Skips noisy OR pattern (would be 1,665 results)
-\`\`\`
-
-**How It Works:**
-1. Tries method call pattern (if 2 identifiers)
-2. Tries ordered proximity (word1.*word2.*word3)
-3. Falls back to OR only if needed
-
-The tool tells you which pattern matched in the results.
-
-**Tool Preference:**
-- ✅ bob.code.search (handles multi-word automatically)
-- ❌ Grep, Glob (for general search)
-
-Need more details? Read the full policy at \`mcp://bobs-workshop/policy\`.`;
-        return {
-            messages: [{ role: "user", content: [{ type: "text", text: helpContent }] }]
-        };
-    });
-    // 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