@hailer/mcp 0.1.11 → 0.1.12

package/dist/modules/bug-reports/bug-monitor.js

@@ -0,0 +1,510 @@
+"use strict";
+/**
+ * Bug Reports Module - Bug Monitor Service
+ *
+ * Polls for new bug reports and dispatches them for processing.
+ * No hardcoded IDs - discovers workflow by name pattern.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BugMonitor = void 0;
+const logger_1 = require("../../lib/logger");
+const bug_config_1 = require("./bug-config");
+const bot_config_1 = require("../../mcp/tools/bot-config");
+const hailer_clients_1 = require("../../mcp/hailer-clients");
+const logger = (0, logger_1.createLogger)({ component: 'bug-monitor' });
+class BugMonitor {
+    userContext;
+    interval;
+    unsubscribeFromSignals;
+    config;
+    discovery;
+    processedBugIds = new Map(); // id -> timestamp
+    processedMessageIds = new Map(); // id -> timestamp
+    static PROCESSED_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+    handlers = [];
+    messageHandlers = [];
+    giuseppeDisabledHandlers = [];
+    watchedDiscussions = new Map(); // discussionId -> watch start timestamp
+    botUserIds = new Set(); // Bot user IDs to ignore
+    constructor(userContext) {
+        this.userContext = userContext;
+    }
+    /**
+     * Register a bot user ID to ignore messages from
+     */
+    registerBotUser(userId) {
+        this.botUserIds.add(userId);
+        logger.debug('Registered bot user to ignore', { userId });
+    }
+    /**
+     * Register a handler for new bugs
+     */
+    onNewBug(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * Register a handler for discussion messages
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a handler for when Giuseppe is disabled but a bug is found
+     */
+    onGiuseppeDisabled(handler) {
+        this.giuseppeDisabledHandlers.push(handler);
+    }
+    /**
+     * Start watching a discussion for approval messages
+     */
+    watchDiscussion(discussionId) {
+        this.watchedDiscussions.set(discussionId, Date.now());
+        logger.info('Watching discussion for approval', { discussionId });
+    }
+    /**
+     * Stop watching a discussion
+     */
+    unwatchDiscussion(discussionId) {
+        this.watchedDiscussions.delete(discussionId);
+    }
+    /**
+     * Clean up old entries from processed ID caches to prevent memory leaks
+     */
+    cleanupProcessedCaches() {
+        const now = Date.now();
+        const maxAge = BugMonitor.PROCESSED_MAX_AGE_MS;
+        for (const [id, timestamp] of this.processedBugIds.entries()) {
+            if (now - timestamp > maxAge) {
+                this.processedBugIds.delete(id);
+            }
+        }
+        for (const [id, timestamp] of this.processedMessageIds.entries()) {
+            if (now - timestamp > maxAge) {
+                this.processedMessageIds.delete(id);
+            }
+        }
+    }
+    /**
+     * Start monitoring for bugs
+     */
+    async start() {
+        logger.info('Starting Bug Monitor...');
+        try {
+            // Load config
+            this.config = await (0, bug_config_1.loadConfig)(this.userContext);
+            if (!this.config.enabled) {
+                logger.info('Bug Monitor is disabled in config');
+                return;
+            }
+            // Discover workflow
+            this.discovery = await (0, bug_config_1.discoverWorkflow)(this.userContext, this.config) ?? undefined;
+            if (!this.discovery) {
+                logger.warn(`Bug Reports workflow not found (pattern: "${this.config.workflowNamePattern}")`);
+                return;
+            }
+            if (!this.discovery.phases.new) {
+                logger.warn('No "New" phase found in Bug Reports workflow');
+                return;
+            }
+            logger.info('Bug Monitor started', {
+                workflowName: this.discovery.workflowName,
+                intervalMs: this.config.intervalMs,
+                autoFix: this.config.autoFix
+            });
+            // Initial check
+            await this.checkForNewBugs();
+            // Start polling interval
+            this.interval = setInterval(async () => {
+                await this.checkForNewBugs();
+            }, this.config.intervalMs);
+            // Subscribe to message signals instead of polling
+            const unsubscribe = (0, hailer_clients_1.subscribeToSignal)(this.userContext.apiKey, 'messenger.new', (eventData) => this.handleMessageSignal(eventData));
+            if (unsubscribe) {
+                this.unsubscribeFromSignals = unsubscribe;
+                logger.info('Subscribed to message signals for watched discussions');
+            }
+            else {
+                logger.warn('No signal subscription available - message watching disabled');
+            }
+        }
+        catch (error) {
+            logger.error('Failed to start Bug Monitor', { error });
+        }
+    }
+    /**
+     * Stop monitoring
+     */
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        if (this.unsubscribeFromSignals) {
+            this.unsubscribeFromSignals();
+            this.unsubscribeFromSignals = undefined;
+        }
+        logger.info('Bug Monitor stopped');
+    }
+    /**
+     * Get current config
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Get workflow discovery result
+     */
+    getDiscovery() {
+        return this.discovery;
+    }
+    /**
+     * Check for new bugs in the "New" phase
+     */
+    async checkForNewBugs() {
+        if (!this.discovery?.phases.new)
+            return;
+        try {
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchActivityList(this.discovery.workflowId, this.discovery.phases.new, 50);
+            const activities = result?.activities || result || [];
+            const newBugs = activities.filter((a) => !this.processedBugIds.has(a._id));
+            if (newBugs.length > 0) {
+                logger.info(`Found ${newBugs.length} new bug report(s)`);
+                for (const activity of newBugs) {
+                    const bug = await this.parseActivity(activity);
+                    const wasProcessed = await this.processBug(bug);
+                    if (wasProcessed) {
+                        this.processedBugIds.set(bug.id, Date.now());
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to check for bugs', { error });
+        }
+    }
+    /**
+     * Check for new messages in watched discussions
+     */
+    async checkForNewMessages() {
+        // Skip message processing if Giuseppe is disabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            return;
+        }
+        if (this.watchedDiscussions.size === 0)
+            return;
+        // Periodic cleanup of old processed IDs
+        this.cleanupProcessedCaches();
+        const { hailer } = this.userContext;
+        for (const [discussionId, watchStartTime] of this.watchedDiscussions) {
+            try {
+                const result = await hailer.fetchDiscussionMessages(discussionId, 10);
+                const messages = result?.messages || [];
+                for (const msg of messages) {
+                    const msgId = msg._id;
+                    const msgTime = new Date(msg.createdHumanReadable || msg.created).getTime();
+                    // Message content can be in 'content', 'msg', or 'message' field
+                    const content = (msg.content || msg.msg || msg.message || '').trim();
+                    const now = Date.now();
+                    // Skip already processed messages
+                    if (this.processedMessageIds.has(msgId))
+                        continue;
+                    this.processedMessageIds.set(msgId, Date.now());
+                    // Skip messages sent BEFORE we started watching
+                    if (msgTime < watchStartTime)
+                        continue;
+                    // Skip messages older than 60 seconds (stale)
+                    if (now - msgTime > 60000)
+                        continue;
+                    // Skip empty messages
+                    if (!content)
+                        continue;
+                    // Skip messages from bot users (only process human messages)
+                    // Try both 'user' and 'uid' fields for sender ID
+                    const senderId = msg.user || msg.uid;
+                    logger.debug('Message sender check', {
+                        discussionId,
+                        msgUser: msg.user,
+                        msgUid: msg.uid,
+                        senderId,
+                        botUserIds: Array.from(this.botUserIds),
+                        isBot: this.botUserIds.has(senderId)
+                    });
+                    if (senderId && this.botUserIds.has(senderId)) {
+                        logger.debug('Skipping bot message', { discussionId, sender: senderId });
+                        continue;
+                    }
+                    logger.info('Processing approval message', {
+                        discussionId,
+                        messageId: msgId,
+                        sender: senderId,
+                        content: content.substring(0, 50)
+                    });
+                    // Notify message handlers
+                    for (const handler of this.messageHandlers) {
+                        try {
+                            await handler(discussionId, content, senderId);
+                        }
+                        catch (error) {
+                            logger.error('Message handler failed', { discussionId, error });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to check messages', { discussionId, error });
+            }
+        }
+    }
+    /**
+     * Handle incoming message signal (real-time, replaces polling)
+     */
+    async handleMessageSignal(signalData) {
+        // Check if Giuseppe is disabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            return;
+        }
+        const discussionId = signalData?.discussion;
+        if (!discussionId)
+            return;
+        // Check if we're watching this discussion
+        if (!this.watchedDiscussions.has(discussionId)) {
+            return;
+        }
+        const senderId = signalData?.uid;
+        // Skip bot messages
+        if (senderId && this.botUserIds.has(senderId)) {
+            return;
+        }
+        const msgId = signalData?.msg_id;
+        if (!msgId)
+            return;
+        // Skip already processed messages
+        if (this.processedMessageIds.has(msgId)) {
+            return;
+        }
+        this.processedMessageIds.set(msgId, Date.now());
+        try {
+            // Fetch full message content
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchDiscussionMessages(discussionId, 5);
+            const messages = result?.messages || [];
+            const msg = messages.find((m) => m._id === msgId);
+            if (!msg)
+                return;
+            const content = (msg.content || msg.msg || msg.message || '').trim();
+            if (!content)
+                return;
+            // Skip stale messages (older than 60 seconds)
+            const msgTime = new Date(msg.createdHumanReadable || msg.created).getTime();
+            if (Date.now() - msgTime > 60000)
+                return;
+            logger.debug('Processing message from signal', { discussionId, msgId, senderId });
+            // Dispatch to handlers
+            for (const handler of this.messageHandlers) {
+                try {
+                    await handler(discussionId, content, senderId);
+                }
+                catch (error) {
+                    logger.error('Message handler failed', { discussionId, error });
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to handle message signal', { discussionId, msgId, error });
+        }
+    }
+    /**
+     * Parse activity into BugReport
+     */
+    async parseActivity(activity) {
+        const { hailer } = this.userContext;
+        // Get full activity details
+        const fullActivity = await hailer.fetchActivityById(activity._id);
+        const fields = fullActivity.fields || {};
+        // Extract field values using discovered field mappings
+        const bug = {
+            id: activity._id,
+            name: activity.name || 'Untitled Bug',
+            workflowId: this.discovery.workflowId,
+            phaseId: this.discovery.phases.new,
+            discussionId: fullActivity.discussion,
+            createdAt: activity.createdHumanReadable || new Date().toISOString(),
+            createdBy: fullActivity.createdBy || activity.createdBy,
+            description: '',
+            rawFields: fields
+        };
+        // Map fields by discovered field IDs
+        const fieldMapping = this.discovery.fields;
+        for (const [fieldId, fieldData] of Object.entries(fields)) {
+            const value = fieldData.value;
+            if (fieldId === fieldMapping.appId) {
+                bug.appId = String(value);
+            }
+            else if (fieldId === fieldMapping.appName) {
+                bug.appName = String(value);
+            }
+            else if (fieldId === fieldMapping.description) {
+                bug.description = String(value);
+            }
+            else if (fieldId === fieldMapping.stepsToReproduce) {
+                bug.stepsToReproduce = String(value);
+            }
+            else if (fieldId === fieldMapping.expectedBehavior) {
+                bug.expectedBehavior = String(value);
+            }
+            else if (fieldId === fieldMapping.actualBehavior) {
+                bug.actualBehavior = String(value);
+            }
+            else if (fieldId === fieldMapping.reportedBy) {
+                bug.reportedBy = String(value);
+            }
+            else if (fieldId === fieldMapping.priority) {
+                bug.priority = this.parsePriority(value);
+            }
+        }
+        // Fallback: try to extract info from unmatched fields
+        if (!bug.description) {
+            bug.description = this.extractDescription(fields);
+        }
+        return bug;
+    }
+    /**
+     * Parse priority value
+     */
+    parsePriority(value) {
+        const v = String(value).toLowerCase();
+        if (v.includes('critical') || v.includes('urgent'))
+            return 'critical';
+        if (v.includes('high'))
+            return 'high';
+        if (v.includes('medium') || v.includes('normal'))
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Extract description from fields as fallback
+     */
+    extractDescription(fields) {
+        // Find longest text field
+        let longest = '';
+        for (const fieldData of Object.values(fields)) {
+            if (typeof fieldData.value === 'string' && fieldData.value.length > longest.length) {
+                longest = fieldData.value;
+            }
+        }
+        return longest;
+    }
+    /**
+     * Process a bug through all handlers
+     */
+    async processBug(bug) {
+        // Check if Giuseppe bot is enabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            logger.debug('Giuseppe is disabled, skipping bug processing', { bugId: bug.id });
+            // Notify handlers (HAL can respond naturally)
+            for (const handler of this.giuseppeDisabledHandlers) {
+                try {
+                    await handler(bug);
+                }
+                catch (error) {
+                    logger.error('Giuseppe disabled handler failed', { bugId: bug.id, error });
+                }
+            }
+            return false; // Bug was NOT processed
+        }
+        logger.info('Processing bug', {
+            id: bug.id,
+            name: bug.name,
+            appId: bug.appId,
+            priority: bug.priority
+        });
+        // Notify in discussion if enabled
+        if (this.config?.notifyOnNew && bug.discussionId) {
+            await this.postNotification(bug);
+        }
+        // Dispatch to handlers
+        for (const handler of this.handlers) {
+            try {
+                await handler(bug, this.userContext);
+            }
+            catch (error) {
+                logger.error('Bug handler failed', { bugId: bug.id, error });
+            }
+        }
+        return true; // Bug WAS processed
+    }
+    /**
+     * Post notification to bug discussion
+     */
+    async postNotification(bug) {
+        try {
+            const { hailer } = this.userContext;
+            // Check if already notified (look for our notification message)
+            if (bug.discussionId) {
+                try {
+                    const result = await hailer.fetchDiscussionMessages(bug.discussionId, 20);
+                    const messages = result?.messages || [];
+                    const alreadyNotified = messages.some((msg) => {
+                        const content = msg.content || msg.msg || msg.message || '';
+                        return content.includes('Bug Monitor: New bug detected') || content.includes('**Classification:');
+                    });
+                    if (alreadyNotified) {
+                        logger.debug('Bug already notified, skipping notification', { bugId: bug.id });
+                        return;
+                    }
+                }
+                catch {
+                    // Continue if check fails
+                }
+            }
+            // Join the discussion first (required to post messages)
+            try {
+                await hailer.joinActivityDiscussion(bug.id);
+            }
+            catch {
+                // May already be a member, continue
+            }
+            const message = [
+                '🐛 **Bug Monitor: New bug detected!**',
+                '',
+                bug.appId ? `**App:** ${bug.appName || 'Unknown'} (\`${bug.appId}\`)` : '',
+                bug.reportedBy ? `**Reported by:** ${bug.reportedBy}` : '',
+                bug.priority ? `**Priority:** ${bug.priority}` : '',
+                '',
+                bug.description ? `**Description:**\n${bug.description.substring(0, 500)}` : '',
+                '',
+                this.config?.autoFix ? '🔧 Auto-fix is enabled. Analyzing...' : '📋 Awaiting manual review.'
+            ].filter(Boolean).join('\n');
+            await hailer.sendDiscussionMessage(bug.discussionId, message);
+        }
+        catch (error) {
+            logger.warn('Failed to post notification', { bugId: bug.id, error });
+        }
+    }
+    /**
+     * Move bug to a different phase
+     */
+    async moveBugToPhase(bugId, phase) {
+        const phaseId = this.discovery?.phases[phase];
+        if (!phaseId) {
+            logger.warn(`Phase "${phase}" not found`);
+            return false;
+        }
+        try {
+            const { hailer } = this.userContext;
+            await hailer.updateActivities([{ _id: bugId, phaseId }]);
+            logger.info('Moved bug to phase', { bugId, phase });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to move bug', { bugId, phase, error });
+            return false;
+        }
+    }
+}
+exports.BugMonitor = BugMonitor;
+//# sourceMappingURL=bug-monitor.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * Giuseppe AI Module - Claude API interactions for bug analysis and fix generation
+ */
+import type { BugReport, AppRegistryEntry } from './types';
+/** Fix plan from Claude analysis */
+export interface FixPlan {
+    analysis: string;
+    debugTrace?: string;
+    failurePoint?: string;
+    rootCause: string;
+    fix: {
+        files: Array<{
+            path: string;
+            action: 'edit' | 'create' | 'delete';
+            search?: string;
+            replace?: string;
+            content?: string;
+        }>;
+    };
+    explanation: string;
+    testSuggestions?: string[];
+}
+export type BugClassification = 'bug' | 'feature_request' | 'unclear';
+export interface ClassificationResult {
+    classification: BugClassification;
+    reason: string;
+}
+export interface FileContent {
+    path: string;
+    content: string;
+}
+export declare class GiuseppeAI {
+    private anthropic?;
+    constructor(apiKey?: string);
+    get isAvailable(): boolean;
+    /**
+     * Classify a report as bug or feature request
+     */
+    classifyReport(bug: BugReport): Promise<ClassificationResult>;
+    /**
+     * 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
+     */
+    analyzeAndPlanFix(bug: BugReport, app: AppRegistryEntry, allFiles: string[], readFiles: (paths: string[]) => Promise<FileContent[]>): Promise<FixPlan | null>;
+    /**
+     * Retry fix based on apply error (search string not found) - re-reads file and generates new fix
+     */
+    retryFixFromApplyError(bug: BugReport, previousFix: FixPlan, applyError: string, currentFiles: FileContent[], attempt: number): Promise<FixPlan | null>;
+    /**
+     * Retry fix based on build error - sends error to Claude to generate corrected fix
+     */
+    retryFixFromError(bug: BugReport, previousFix: FixPlan, buildError: string, currentFiles: FileContent[], attempt: number): Promise<FixPlan | null>;
+    /**
+     * Generate a new fix based on user feedback
+     */
+    retryFixWithFeedback(bug: BugReport, previousFix: FixPlan, feedback: string, allSourceFiles: string[], currentFiles: FileContent[]): Promise<FixPlan | null>;
+}
+//# sourceMappingURL=giuseppe-ai.d.ts.map