@hailer/mcp 0.1.15 → 0.1.16

package/dist/modules/bug-reports/giuseppe-ai.js

@@ -68,12 +68,107 @@ Respond with JSON only:
             return { classification: 'unclear', reason: 'Classification error' };
         }
     }
+    /**
+     * Detect user intent from a message (replaces magic word detection)
+     * Returns the intent and confidence level
+     */
+    async detectIntent(message, context) {
+        if (!this.anthropic) {
+            // Fallback to simple keyword matching
+            const lower = message.toLowerCase().trim();
+            if (context === 'classification') {
+                if (lower.includes('fix') && !lower.includes('don\'t') && !lower.includes('not')) {
+                    return { intent: 'fix_it', confidence: 'medium', explanation: 'Contains "fix"' };
+                }
+                if (lower.includes('not a bug') || lower.includes('feature')) {
+                    return { intent: 'not_a_bug', confidence: 'medium', explanation: 'Contains "not a bug" or "feature"' };
+                }
+            }
+            else {
+                if (lower === 'approved' || lower === 'yes' || lower === 'ship it' || lower === 'deploy') {
+                    return { intent: 'approved', confidence: 'medium', explanation: 'Approval keyword' };
+                }
+                if (lower === 'denied' || lower === 'no' || lower === 'revert' || lower === 'cancel') {
+                    return { intent: 'denied', confidence: 'medium', explanation: 'Denial keyword' };
+                }
+            }
+            return { intent: 'unknown', confidence: 'low', explanation: 'No matching keywords' };
+        }
+        try {
+            const contextDescription = context === 'classification'
+                ? `Giuseppe classified a bug report and is waiting for the user to confirm:
+- "fix_it" = User wants Giuseppe to proceed with fixing the bug
+- "not_a_bug" = User says this isn't a bug, it's a feature request or not an issue
+- "clarify" = User is asking a question or providing more info
+- "unknown" = Can't determine intent`
+                : `Giuseppe has created a fix and is waiting for approval to publish:
+- "approved" = User approves publishing to production
+- "denied" = User rejects the fix or wants changes
+- "retry" = User wants Giuseppe to try a different approach
+- "question" = User is asking about the fix
+- "unknown" = Can't determine intent`;
+            const prompt = `Detect the user's intent from this message.
+
+Context: ${contextDescription}
+
+User message: "${message}"
+
+Respond with JSON only (no markdown):
+{"intent": "...", "confidence": "high|medium|low", "explanation": "brief reason"}`;
+            const response = await this.anthropic.messages.create({
+                model: 'claude-haiku-4-5-20251001',
+                max_tokens: 150,
+                messages: [{ role: 'user', content: prompt }]
+            });
+            const content = response.content[0];
+            if (content.type !== 'text') {
+                return { intent: 'unknown', confidence: 'low', explanation: 'AI response error' };
+            }
+            const parsed = JSON.parse(content.text.replace(/```json\n?|\n?```/g, '').trim());
+            logger.info('Intent detected', {
+                message: message.substring(0, 50),
+                intent: parsed.intent,
+                confidence: parsed.confidence
+            });
+            return {
+                intent: parsed.intent || 'unknown',
+                confidence: parsed.confidence || 'low',
+                explanation: parsed.explanation || ''
+            };
+        }
+        catch (error) {
+            logger.error('Intent detection failed', { error, message: message.substring(0, 50) });
+            return { intent: 'unknown', confidence: 'low', explanation: 'Detection error' };
+        }
+    }
+    /**
+     * Extract keywords from bug description for LSP filtering
+     */
+    extractKeywords(description) {
+        // Common technical terms to look for
+        const techTerms = [
+            'click', 'drag', 'drop', 'scroll', 'hover', 'focus', 'blur',
+            'render', 'update', 'load', 'save', 'delete', 'create',
+            'button', 'input', 'form', 'modal', 'menu', 'list', 'table',
+            'position', 'animation', 'transition', 'style', 'color',
+            'error', 'crash', 'freeze', 'slow', 'lag', 'broken'
+        ];
+        const words = description.toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 2);
+        // Find matching tech terms
+        const matchedTerms = techTerms.filter(term => words.some(w => w.includes(term) || term.includes(w)));
+        // Also include unique words from description (nouns/verbs likely)
+        const uniqueWords = words.filter(w => w.length > 4 && !['the', 'and', 'but', 'for', 'not', 'with', 'this', 'that', 'when', 'have', 'from'].includes(w));
+        return [...new Set([...matchedTerms, ...uniqueWords])].slice(0, 10);
+    }
     /**
      * Analyze bug and generate fix plan using Claude (two-phase approach)
      * Phase 1: Send file list -> Claude picks relevant files
      * Phase 2: Send those files -> Claude generates fix
      */
-    async analyzeAndPlanFix(bug, app, allFiles, readFiles) {
+    async analyzeAndPlanFix(bug, app, allFiles, readFiles, runLspAnalysis) {
         if (!this.anthropic) {
             logger.warn('Anthropic client not initialized - cannot generate fix');
             return null;
@@ -120,9 +215,45 @@ Return ONLY a JSON array of file paths, maximum 10 files. Example: ["src/App.tsx
                 relevantFiles = allFiles.filter(f => f.startsWith('src/')).slice(0, 5);
             }
             logger.info('Phase 1 complete: Files to examine', { files: relevantFiles });
+            // Phase 1.5: Run TARGETED LSP analysis on relevant files only
+            // Extract keywords from bug description for filtering
+            const bugKeywords = this.extractKeywords(bug.description);
+            logger.info('Extracted bug keywords for LSP filtering', { keywords: bugKeywords });
+            let lspFindings = null;
+            if (runLspAnalysis) {
+                lspFindings = await runLspAnalysis(relevantFiles, bugKeywords);
+                logger.info('Targeted LSP analysis complete', {
+                    files: relevantFiles.length,
+                    unusedProps: lspFindings.unusedProps.length,
+                    issues: lspFindings.issues.length
+                });
+            }
             // Phase 2: Read selected files and generate fix
             const sourceFiles = await readFiles(relevantFiles);
             logger.info('Phase 2: Generating fix', { filesRead: sourceFiles.length });
+            // Build LSP findings section if available
+            let lspSection = '';
+            if (lspFindings && (lspFindings.unusedProps.length > 0 || lspFindings.issues.length > 0)) {
+                lspSection = '\n\n=== LSP CODE ANALYSIS (HIGH PRIORITY) ===\n';
+                lspSection += 'IMPORTANT: These are REAL code issues detected by static analysis. Fix these FIRST.\n\n';
+                if (lspFindings.unusedProps.length > 0) {
+                    lspSection += 'UNUSED PROPS (declared in interface but never used in component):\n';
+                    lspFindings.unusedProps.forEach(p => {
+                        lspSection += `- ${p.file}:${p.line} - prop "${p.name}" is declared but never destructured/used\n`;
+                        // Add hint if prop name matches bug keywords
+                        if (bug.description.toLowerCase().includes(p.name.toLowerCase())) {
+                            lspSection += `  ^ THIS PROP NAME MATCHES THE BUG DESCRIPTION - VERY LIKELY THE ROOT CAUSE!\n`;
+                        }
+                    });
+                }
+                if (lspFindings.issues.length > 0) {
+                    lspSection += '\nDEAD CODE (functions/variables declared but never called):\n';
+                    lspFindings.issues.forEach(i => {
+                        lspSection += `- ${i.file}:${i.line} - ${i.message}\n`;
+                    });
+                }
+                lspSection += '\nThe fix should USE these unused props/functions, not add workaround code.\n';
+            }
             const phase2Prompt = `
 Bug Report:
 - Title: ${bug.name}
@@ -131,7 +262,7 @@ ${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
 ${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
 ${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
 - Priority: ${bug.priority || 'unknown'}
-
+${lspSection}
 App: ${app.name}
 Project path: ${app.projectPath}
 

package/dist/modules/bug-reports/giuseppe-bot.d.ts

@@ -39,9 +39,9 @@ export declare class GiuseppeBot {
      */
     proceedWithFix(bug: BugReport): Promise<FixResult>;
     /**
-     * Handle a message in a bug discussion - state machine for approval flow
+     * Handle a message in a bug discussion - uses LLM to understand intent
      */
-    handleDiscussionMessage(discussionId: string, message: string, senderId: string): Promise<{
+    handleDiscussionMessage(discussionId: string, message: string, _senderId: string): Promise<{
         approved: boolean;
         published: boolean;
         retrying?: boolean;

package/dist/modules/bug-reports/giuseppe-bot.js

@@ -21,12 +21,8 @@ const giuseppe_ai_1 = require("./giuseppe-ai");
 const giuseppe_git_1 = require("./giuseppe-git");
 const giuseppe_files_1 = require("./giuseppe-files");
 const giuseppe_lsp_1 = require("./giuseppe-lsp");
+const discussion_lock_1 = require("../../lib/discussion-lock");
 const logger = (0, logger_1.createLogger)({ component: 'giuseppe-bot' });
-// Magic words for approval flow
-const MAGIC_WORD_APPROVED = 'approved';
-const MAGIC_WORD_DENIED = 'denied';
-const MAGIC_WORD_FIX_IT = 'fix it';
-const MAGIC_WORD_NOT_A_BUG = 'not a bug';
 // Session Log (Context Log) field IDs for logging
 const SESSION_LOG_CONFIG = {
     workflowId: '695784898d347a6c707ee397',
@@ -133,6 +129,10 @@ class GiuseppeBot {
             bugName: bug.name,
             appId: bug.appId
         });
+        // Acquire lock on this discussion to prevent other bots (Orchestrator) from responding
+        if (bug.discussionId) {
+            (0, discussion_lock_1.acquireDiscussionLock)(bug.discussionId, 'giuseppe', 10 * 60 * 1000); // 10 minute lock
+        }
         const result = {
             success: false,
             summary: '',
@@ -239,15 +239,28 @@ class GiuseppeBot {
             }
             result.log?.push(`Found app project: ${app.projectPath}`);
             await this.reportProgress(bug, `📁 Found app project: ${app.name}`);
-            // 1.5. Run LSP analysis to understand current codebase state
-            const preAnalysis = await this.lsp.analyzeProject(app.projectPath);
-            if (preAnalysis.issues.length > 0) {
-                result.log?.push(`Pre-fix LSP: ${preAnalysis.summary}`);
-                await this.reportProgress(bug, `🔎 Codebase analysis: ${preAnalysis.summary}`);
-            }
+            // Note: LSP analysis now runs AFTER Phase 1 identifies relevant files
+            // This is more efficient - we only analyze files related to the bug
             // 2. Analyze and generate fix
             const allFiles = await this.files.scanSourceFiles(app.projectPath);
-            const fixPlan = await this.ai.analyzeAndPlanFix(bug, app, allFiles, (paths) => this.files.readSelectedFiles(app.projectPath, paths));
+            // Create LSP analysis callback - runs TARGETED analysis on specific files
+            const runLspAnalysis = async (files, keywords) => {
+                logger.info('Running targeted LSP analysis', { files: files.length, keywords });
+                const analysis = await this.lsp.analyzeRelevantFiles(app.projectPath, files, keywords);
+                return {
+                    unusedProps: (analysis.unusedProps || []).map((p) => ({
+                        name: p.name,
+                        line: p.line,
+                        file: p.file || 'unknown'
+                    })),
+                    issues: (analysis.issues || []).map(i => ({
+                        file: i.file,
+                        line: i.line,
+                        message: i.message
+                    }))
+                };
+            };
+            const fixPlan = await this.ai.analyzeAndPlanFix(bug, app, allFiles, (paths) => this.files.readSelectedFiles(app.projectPath, paths), runLspAnalysis);
             if (!fixPlan) {
                 result.summary = 'Could not generate fix plan';
                 result.log?.push('Fix plan generation failed');
@@ -381,56 +394,64 @@ ${currentFixPlan.explanation}
         }
     }
     /**
-     * Handle a message in a bug discussion - state machine for approval flow
+     * Handle a message in a bug discussion - uses LLM to understand intent
      */
-    async handleDiscussionMessage(discussionId, message, senderId) {
-        // Normalize: replace non-breaking spaces (0xA0) with regular spaces (0x20)
-        // Hailer chat may send NBSP instead of regular spaces
-        const messageLower = message.toLowerCase().replace(/\u00A0/g, ' ').trim();
+    async handleDiscussionMessage(discussionId, message, _senderId) {
         logger.debug('handleDiscussionMessage called', {
             discussionId,
             message: message.substring(0, 50),
             pendingClassificationsSize: pending_classification_registry_1.pendingClassificationRegistry.size,
             hasPendingForDiscussion: pending_classification_registry_1.pendingClassificationRegistry.has(discussionId)
         });
-        // Check for pending classification first (waiting for "fix it" or "not a bug")
+        // Check for pending classification first (waiting for user to confirm fix or mark as not-a-bug)
         const pendingClassification = pending_classification_registry_1.pendingClassificationRegistry.get(discussionId);
         if (pendingClassification) {
-            // Hex dump for debugging character encoding issues
-            const hexDump = (str) => Array.from(str).map(c => c.charCodeAt(0).toString(16).padStart(2, '0')).join(' ');
-            logger.debug('Checking message against magic words', {
+            // Use LLM to understand user intent (replaces hardcoded magic words)
+            const { intent, confidence } = await this.ai.detectIntent(message, 'classification');
+            logger.debug('Classification intent detected', {
                 discussionId,
-                messageLower,
-                messageLowerHex: hexDump(messageLower),
-                MAGIC_WORD_NOT_A_BUG,
-                magicWordHex: hexDump(MAGIC_WORD_NOT_A_BUG),
-                isFixIt: messageLower === MAGIC_WORD_FIX_IT || messageLower === 'fix',
-                isNotABug: messageLower === MAGIC_WORD_NOT_A_BUG,
-                includesNotABug: messageLower.includes('not a bug'),
-                includesFeature: messageLower.includes('feature')
+                message: message.substring(0, 50),
+                intent,
+                confidence
             });
-            if (messageLower === MAGIC_WORD_FIX_IT || messageLower === 'fix') {
-                logger.debug('Matched fix it - calling handleFixItConfirmation');
+            if (intent === 'fix_it' && confidence !== 'low') {
+                logger.debug('User wants to fix - calling handleFixItConfirmation');
                 return await this.handleFixItConfirmation(discussionId, pendingClassification);
             }
-            if (messageLower === MAGIC_WORD_NOT_A_BUG || messageLower.includes('not a bug') || messageLower.includes('feature')) {
-                logger.debug('Matched not a bug - calling handleNotABugConfirmation');
+            if (intent === 'not_a_bug' && confidence !== 'low') {
+                logger.debug('User says not a bug - calling handleNotABugConfirmation');
                 return await this.handleNotABugConfirmation(discussionId, pendingClassification);
             }
-            logger.debug('No magic word match - ignoring message');
-            // Other messages while waiting for classification - ignore
+            // Unknown or clarify intent - ignore and wait for clearer response
+            logger.debug('Unclear intent - waiting for clearer response', { intent, confidence });
             return { approved: false, published: false };
         }
-        // Check for pending fix (waiting for "approved" or "denied")
+        // Check for pending fix (waiting for approval to publish)
         const pendingFix = pending_fix_registry_1.pendingFixRegistry.get(discussionId);
         if (!pendingFix) {
             return { approved: false, published: false };
         }
-        // Giuseppe ONLY handles "approved" - HAL handles everything else (denial, explanations)
-        if (messageLower === MAGIC_WORD_APPROVED) {
+        // Use LLM to understand approval intent
+        const { intent, confidence } = await this.ai.detectIntent(message, 'approval');
+        logger.debug('Approval intent detected', {
+            discussionId,
+            message: message.substring(0, 50),
+            intent,
+            confidence
+        });
+        if (intent === 'approved' && confidence !== 'low') {
             return await this.handleApproval(discussionId, pendingFix);
         }
-        // All other messages: return false, let HAL handle
+        if (intent === 'denied' && confidence !== 'low') {
+            // Handle denial - revert changes
+            return await this.handleDenial(discussionId, pendingFix);
+        }
+        if (intent === 'retry' && confidence !== 'low') {
+            // User wants to try again - not implemented yet
+            await this.sendDiscussionMessage(discussionId, "🔄 Retry is not implemented yet. Please say 'approved' to publish or 'denied' to cancel.");
+            return { approved: false, published: false };
+        }
+        // Unknown intent - let HAL or user clarify
         return { approved: false, published: false };
     }
     /**
@@ -441,11 +462,14 @@ ${currentFixPlan.explanation}
         // Remove from pending classifications
         pending_classification_registry_1.pendingClassificationRegistry.unregister(discussionId);
         await this.sendDiscussionMessage(discussionId, `✅ Got it! Starting bug fix...`);
-        // Proceed with the actual fix
+        // Proceed with the actual fix (creates commit, stores pending fix awaiting approval)
         const result = await this.proceedWithFix(pending.bug);
+        // Return false for both - the CLASSIFICATION was approved ("fix it"),
+        // but the FIX itself is not yet approved (waiting for "approved" message)
+        // The fix was applied locally but NOT published to production
         return {
-            approved: true,
-            published: result.success,
+            approved: false, // Fix not approved yet, just classification
+            published: false, // Not published, just committed locally
             error: result.success ? undefined : result.summary
         };
     }

package/dist/modules/bug-reports/giuseppe-daemon.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Giuseppe Daemon - LLM-Driven Bug Fixer Agent
+ *
+ * A fully autonomous AI agent for fixing bugs in Hailer apps.
+ * Unlike the old GiuseppeBot with hardcoded magic words, this daemon:
+ * - Understands natural language (no "fix it" / "approved" keywords)
+ * - Reasons about problems (git conflicts, build failures)
+ * - Decides when to ask for approval vs proceed
+ * - Has tools for all bug-fixing operations
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { ChatAgentDaemon, ChatAgentDaemonConfig, IncomingMessage } from "../../client/agents/base";
+import { HailerSignal } from "../../mcp/signal-handler";
+import { ToolInput } from "../../client/types";
+import type { BugMonitor } from "./bug-monitor";
+import type { UserContext } from "../../mcp/UserContextCache";
+export interface GiuseppeDaemonConfig extends ChatAgentDaemonConfig {
+    /** Bug monitor for phase transitions */
+    bugMonitor: BugMonitor;
+    /** User context for API access */
+    userContext: UserContext;
+    /** Base path for app projects */
+    appsBasePath: string;
+}
+export declare class GiuseppeDaemon extends ChatAgentDaemon {
+    private giuseppeLogger;
+    private bugMonitor;
+    private userContext;
+    private appsBasePath;
+    private ai;
+    private git;
+    private files;
+    private lsp;
+    private bugDiscussions;
+    constructor(config: GiuseppeDaemonConfig);
+    /**
+     * Register a bug discussion so Giuseppe knows to respond to it
+     */
+    registerBugDiscussion(discussionId: string, bugId: string, bugName: string, workflowId: string): void;
+    /**
+     * Unregister a bug discussion (bug resolved/closed)
+     */
+    unregisterBugDiscussion(discussionId: string): void;
+    protected getAgentName(): {
+        firstName: string;
+        lastName: string;
+    };
+    protected getAgentDescription(): string;
+    protected getPositionDetails(): {
+        name: string;
+        purpose: string;
+        personaTone: string;
+        coreCapabilities: string;
+        boundaries: string;
+    };
+    /**
+     * Only respond to messages in registered bug discussions
+     */
+    protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
+    /**
+     * Giuseppe's tools for bug fixing
+     */
+    protected getToolWhitelist(): string[];
+    /**
+     * Custom tools for bug fixing operations
+     */
+    protected getTools(): Anthropic.Tool[];
+    /**
+     * Execute Giuseppe's custom tools
+     */
+    protected executeCustomTool(name: string, rawInput: ToolInput): Promise<{
+        success: boolean;
+        result: any;
+    }>;
+    /**
+     * System prompt for Giuseppe - natural conversation about bug fixing
+     */
+    protected getSystemPrompt(): string;
+}
+//# sourceMappingURL=giuseppe-daemon.d.ts.map