@hailer/mcp 0.1.10 → 0.1.12

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

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Giuseppe AI Module - Claude API interactions for bug analysis and fix generation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiuseppeAI = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const logger_1 = require("../../lib/logger");
+const giuseppe_prompt_1 = require("./giuseppe-prompt");
+const logger = (0, logger_1.createLogger)({ component: 'giuseppe-ai' });
+class GiuseppeAI {
+    anthropic;
+    constructor(apiKey) {
+        if (apiKey) {
+            this.anthropic = new sdk_1.default({ apiKey });
+        }
+    }
+    get isAvailable() {
+        return !!this.anthropic;
+    }
+    /**
+     * Classify a report as bug or feature request
+     */
+    async classifyReport(bug) {
+        if (!this.anthropic) {
+            return { classification: 'unclear', reason: 'No AI available for classification' };
+        }
+        try {
+            const prompt = `Classify this report as either a BUG or a FEATURE REQUEST.
+
+**Title:** ${bug.name}
+**Description:** ${bug.description || 'No description'}
+${bug.stepsToReproduce ? `**Steps:** ${bug.stepsToReproduce}` : ''}
+${bug.expectedBehavior ? `**Expected:** ${bug.expectedBehavior}` : ''}
+${bug.actualBehavior ? `**Actual:** ${bug.actualBehavior}` : ''}
+
+A BUG is something BROKEN - it was working or should work but doesn't.
+Examples: "button doesn't respond", "crashes when clicking", "data not saving", "display is wrong"
+
+A FEATURE REQUEST is asking for something NEW or DIFFERENT - not broken, just wanted.
+Examples: "change color to blue", "add dark mode", "make it bigger", "add new button"
+
+Respond with JSON only:
+{
+  "classification": "bug" | "feature_request" | "unclear",
+  "reason": "One sentence explaining why"
+}`;
+            const response = await this.anthropic.messages.create({
+                model: 'claude-haiku-4-5-20251001',
+                max_tokens: 200,
+                messages: [{ role: 'user', content: prompt }]
+            });
+            const content = response.content[0];
+            if (content.type !== 'text') {
+                return { classification: 'unclear', reason: 'Could not classify' };
+            }
+            const parsed = JSON.parse(content.text.replace(/```json\n?|\n?```/g, ''));
+            return {
+                classification: parsed.classification || 'unclear',
+                reason: parsed.reason || 'No reason provided'
+            };
+        }
+        catch (error) {
+            logger.error('Classification failed', { error });
+            return { classification: 'unclear', reason: 'Classification error' };
+        }
+    }
+    /**
+     * 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) {
+        if (!this.anthropic) {
+            logger.warn('Anthropic client not initialized - cannot generate fix');
+            return null;
+        }
+        try {
+            // Phase 1: Get file list and ask Claude which files to examine
+            logger.info('Phase 1: Asking Claude which files to examine', { fileCount: allFiles.length });
+            const phase1Prompt = `
+Bug Report:
+- Title: ${bug.name}
+- Description: ${bug.description}
+${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
+${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
+${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
+
+App: ${app.name}
+
+Source files in this project:
+${allFiles.map(f => `- ${f}`).join('\n')}
+
+Based on the bug description, which files should I examine to fix this bug?
+Return ONLY a JSON array of file paths, maximum 10 files. Example: ["src/App.tsx", "src/components/Player.tsx"]`;
+            const phase1Response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 1024,
+                system: 'You are a code analyst. Return only a JSON array of file paths that are most relevant to the bug. No explanation.',
+                messages: [{ role: 'user', content: phase1Prompt }]
+            });
+            const phase1Content = phase1Response.content[0];
+            if (phase1Content.type !== 'text')
+                return null;
+            // Parse file list from response
+            let relevantFiles = [];
+            try {
+                // Try to extract JSON array
+                const jsonMatch = phase1Content.text.match(/\[[\s\S]*?\]/);
+                if (jsonMatch) {
+                    relevantFiles = JSON.parse(jsonMatch[0]);
+                }
+            }
+            catch {
+                logger.warn('Could not parse file list from Phase 1', { response: phase1Content.text });
+                // Fallback: take first 5 files from src/
+                relevantFiles = allFiles.filter(f => f.startsWith('src/')).slice(0, 5);
+            }
+            logger.info('Phase 1 complete: Files to examine', { files: relevantFiles });
+            // Phase 2: Read selected files and generate fix
+            const sourceFiles = await readFiles(relevantFiles);
+            logger.info('Phase 2: Generating fix', { filesRead: sourceFiles.length });
+            const phase2Prompt = `
+Bug Report:
+- Title: ${bug.name}
+- Description: ${bug.description}
+${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
+${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
+${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
+- Priority: ${bug.priority || 'unknown'}
+
+App: ${app.name}
+Project path: ${app.projectPath}
+
+Source files:
+${sourceFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
+
+Analyze this bug and provide a fix. Output JSON only.`;
+            const phase2Response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                system: giuseppe_prompt_1.GIUSEPPE_SYSTEM_PROMPT,
+                messages: [{ role: 'user', content: phase2Prompt }]
+            });
+            // Extract JSON from response
+            const content = phase2Response.content[0];
+            if (content.type !== 'text')
+                return null;
+            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
+            if (!jsonMatch) {
+                // Try parsing whole response as JSON
+                try {
+                    return JSON.parse(content.text);
+                }
+                catch {
+                    logger.warn('Could not parse fix plan from response');
+                    return null;
+                }
+            }
+            return JSON.parse(jsonMatch[1]);
+        }
+        catch (error) {
+            logger.error('Failed to analyze bug', { error });
+            return null;
+        }
+    }
+    /**
+     * Retry fix based on apply error (search string not found) - re-reads file and generates new fix
+     */
+    async retryFixFromApplyError(bug, previousFix, applyError, currentFiles, attempt) {
+        if (!this.anthropic)
+            return null;
+        try {
+            logger.info('Retrying fix after apply error', { attempt, error: applyError });
+            const retryPrompt = `
+The previous fix attempt FAILED to apply with this error:
+\`\`\`
+${applyError}
+\`\`\`
+
+This usually means the search string didn't match the actual file content.
+
+Previous fix that was attempted:
+${JSON.stringify(previousFix.fix, null, 2)}
+
+Bug Report:
+- Title: ${bug.name}
+- Description: ${bug.description}
+
+CURRENT state of the files (read just now):
+${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
+
+Please analyze the current file content and provide a CORRECTED fix.
+Make sure the "search" strings EXACTLY match what's in the current files.
+Output JSON only.`;
+            const response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                system: giuseppe_prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: Your previous fix could not be applied because the search string was not found. Read the CURRENT file content carefully and make sure your search strings match EXACTLY.',
+                messages: [{ role: 'user', content: retryPrompt }]
+            });
+            const content = response.content[0];
+            if (content.type !== 'text')
+                return null;
+            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
+            if (!jsonMatch) {
+                try {
+                    return JSON.parse(content.text);
+                }
+                catch {
+                    return null;
+                }
+            }
+            return JSON.parse(jsonMatch[1]);
+        }
+        catch (error) {
+            logger.error('Failed to generate retry fix from apply error', { error });
+            return null;
+        }
+    }
+    /**
+     * Retry fix based on build error - sends error to Claude to generate corrected fix
+     */
+    async retryFixFromError(bug, previousFix, buildError, currentFiles, attempt) {
+        if (!this.anthropic)
+            return null;
+        try {
+            logger.info('Retrying fix based on build error', { attempt, error: buildError.substring(0, 200) });
+            const retryPrompt = `
+The previous fix attempt FAILED with this build error:
+\`\`\`
+${buildError}
+\`\`\`
+
+Previous fix that was attempted:
+${JSON.stringify(previousFix.fix, null, 2)}
+
+Bug Report:
+- Title: ${bug.name}
+- Description: ${bug.description}
+
+Current state of the files after the failed fix:
+${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
+
+Please analyze the build error and provide a CORRECTED fix.
+The fix must resolve the TypeScript/build error while still addressing the original bug.
+Output JSON only.`;
+            const response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                system: giuseppe_prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: Your previous fix caused a build error. Analyze the error carefully and provide a corrected fix that compiles successfully.',
+                messages: [{ role: 'user', content: retryPrompt }]
+            });
+            const content = response.content[0];
+            if (content.type !== 'text')
+                return null;
+            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
+            if (!jsonMatch) {
+                try {
+                    return JSON.parse(content.text);
+                }
+                catch {
+                    return null;
+                }
+            }
+            return JSON.parse(jsonMatch[1]);
+        }
+        catch (error) {
+            logger.error('Failed to generate retry fix', { error });
+            return null;
+        }
+    }
+    /**
+     * Generate a new fix based on user feedback
+     */
+    async retryFixWithFeedback(bug, previousFix, feedback, allSourceFiles, currentFiles) {
+        if (!this.anthropic)
+            return null;
+        try {
+            const prompt = `
+The previous fix was REJECTED by the user. Here's their feedback:
+
+**User feedback:**
+${feedback}
+
+**Original bug:**
+- Title: ${bug.name}
+- Description: ${bug.description}
+${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
+${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
+${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
+
+**Previous fix that was rejected:**
+${JSON.stringify(previousFix.fix, null, 2)}
+
+**AVAILABLE SOURCE FILES (use ONLY these exact paths):**
+${allSourceFiles.map(f => `- ${f}`).join('\n')}
+
+**Relevant source files (searched based on your feedback):**
+${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
+
+Based on the user's feedback, generate a DIFFERENT fix that addresses their concerns.
+IMPORTANT: Use ONLY file paths from the AVAILABLE SOURCE FILES list above.
+Output JSON only.`;
+            const response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                system: giuseppe_prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: The user rejected the previous fix. Read their feedback carefully and try a different approach.',
+                messages: [{ role: 'user', content: prompt }]
+            });
+            const content = response.content[0];
+            if (content.type !== 'text')
+                return null;
+            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
+            if (!jsonMatch) {
+                try {
+                    return JSON.parse(content.text);
+                }
+                catch {
+                    return null;
+                }
+            }
+            return JSON.parse(jsonMatch[1]);
+        }
+        catch (error) {
+            logger.error('Failed to generate retry fix with feedback', { error });
+            return null;
+        }
+    }
+}
+exports.GiuseppeAI = GiuseppeAI;
+//# sourceMappingURL=giuseppe-ai.js.map

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

@@ -0,0 +1,109 @@
+/**
+ * Bug Reports Module - Giuseppe Bot
+ *
+ * Autonomous app fixer that:
+ * 1. Analyzes bug reports
+ * 2. Finds app project code
+ * 3. Generates fixes using Claude
+ * 4. Tests locally
+ * 5. Publishes to production
+ */
+import type { UserContext } from '../../mcp/UserContextCache';
+import type { BugReport, BugReportsConfig, FixResult } from './types';
+import type { BugMonitor } from './bug-monitor';
+export declare class GiuseppeBot {
+    private userContext;
+    private config;
+    private monitor;
+    private ai;
+    private git;
+    private files;
+    private appsRegistry;
+    constructor(userContext: UserContext, config: BugReportsConfig, monitor: BugMonitor);
+    /**
+     * Create a session log entry in Context Log workflow
+     * Links to the bug report for traceability
+     */
+    private createSessionLogEntry;
+    /**
+     * Check if this bug was already classified by looking for classification message in discussion
+     */
+    private wasAlreadyClassified;
+    /**
+     * Handle a new bug - main entry point
+     */
+    handleBug(bug: BugReport): Promise<FixResult>;
+    /**
+     * Continue with bug fix after user confirms
+     */
+    proceedWithFix(bug: BugReport): Promise<FixResult>;
+    /**
+     * Handle a message in a bug discussion - state machine for approval flow
+     */
+    handleDiscussionMessage(discussionId: string, message: string, senderId: string): Promise<{
+        approved: boolean;
+        published: boolean;
+        retrying?: boolean;
+        error?: string;
+    }>;
+    /**
+     * Handle "fix it" confirmation - proceed with bug fix
+     */
+    private handleFixItConfirmation;
+    /**
+     * Handle "not a bug" confirmation - close without fixing
+     */
+    private handleNotABugConfirmation;
+    /**
+     * Handle "approved" - publish to production
+     */
+    private handleApproval;
+    /**
+     * Handle "denied" - ask for explanation
+     */
+    private handleDenial;
+    /**
+     * Handle explanation after denial - retry the fix
+     */
+    private handleExplanationAndRetry;
+    /**
+     * Check if there's a pending fix for a discussion
+     */
+    hasPendingFix(discussionId: string): boolean;
+    /**
+     * Retry a pending fix with explanation from HAL
+     * Called by HAL after gathering info through conversation
+     */
+    retryWithExplanation(discussionId: string, explanation: string): Promise<boolean>;
+    /**
+     * Initialize registry callback (call this after construction)
+     */
+    initializeRegistryCallback(): void;
+    /**
+     * Initialize classification registry callbacks for HAL coordination
+     * This allows HAL to trigger "fix it" or "not a bug" via natural conversation
+     */
+    initializeClassificationCallbacks(): void;
+    /**
+     * Helper to send a message to a discussion
+     */
+    private sendDiscussionMessage;
+    /**
+     * Build and test the app
+     */
+    private buildAndTest;
+    /**
+     * Join a bug's discussion using the activity ID (not discussion ID)
+     * For activity discussions, we must use joinActivityDiscussion
+     */
+    private joinBugDiscussion;
+    /**
+     * Publish app to production using expect script (same as MCP tool)
+     */
+    private publishApp;
+    /**
+     * Report progress to bug discussion
+     */
+    private reportProgress;
+}
+//# sourceMappingURL=giuseppe-bot.d.ts.map