@hailer/mcp 0.1.11 → 0.1.12

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

@@ -0,0 +1,765 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiuseppeBot = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../../lib/logger");
+const pending_fix_registry_1 = require("./pending-fix-registry");
+const pending_classification_registry_1 = require("./pending-classification-registry");
+const app_scaffold_1 = require("../../mcp/tools/app-scaffold");
+// Import extracted modules
+const giuseppe_ai_1 = require("./giuseppe-ai");
+const giuseppe_git_1 = require("./giuseppe-git");
+const giuseppe_files_1 = require("./giuseppe-files");
+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',
+    phaseId: '695784898d347a6c707ee3c3', // Active phase
+    teamId: '6901c67b4e80fecb6fd7b38b', // Required team
+    fields: {
+        contextSummary: '695784898d347a6c707ee3be',
+        linkedWork: '695784898d347a6c707ee3c0', // Link to bug report
+        madeBy: '695784898d347a6c707ee3c2' // Link to agent
+    }
+};
+class GiuseppeBot {
+    userContext;
+    config;
+    monitor;
+    ai;
+    git;
+    files;
+    appsRegistry = new Map();
+    constructor(userContext, config, monitor) {
+        this.userContext = userContext;
+        this.config = config;
+        this.monitor = monitor;
+        // Initialize extracted modules
+        const apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        this.ai = new giuseppe_ai_1.GiuseppeAI(apiKey);
+        this.git = new giuseppe_git_1.GiuseppeGit();
+        this.files = new giuseppe_files_1.GiuseppeFiles(process.env.DEV_APPS_PATH);
+        // Load apps registry from config
+        if (config.appsRegistry) {
+            for (const [appId, entry] of Object.entries(config.appsRegistry)) {
+                this.appsRegistry.set(appId, entry);
+            }
+        }
+    }
+    /**
+     * Create a session log entry in Context Log workflow
+     * Links to the bug report for traceability
+     */
+    async createSessionLogEntry(title, summary, bugActivityId) {
+        try {
+            const { hailer } = this.userContext;
+            // createActivities expects array of activity objects with 'fields' (not 'fieldsAndValues')
+            const activities = [{
+                    name: title,
+                    phaseId: SESSION_LOG_CONFIG.phaseId,
+                    teamId: SESSION_LOG_CONFIG.teamId,
+                    fields: {
+                        [SESSION_LOG_CONFIG.fields.contextSummary]: summary,
+                        [SESSION_LOG_CONFIG.fields.linkedWork]: bugActivityId
+                    }
+                }];
+            const result = await hailer.createActivities(SESSION_LOG_CONFIG.workflowId, activities);
+            // Result is array of created activity IDs
+            const createdId = result?.[0];
+            if (createdId) {
+                logger.info('Created session log entry', {
+                    logId: createdId,
+                    title,
+                    linkedBugId: bugActivityId
+                });
+                return createdId;
+            }
+            return null;
+        }
+        catch (error) {
+            logger.warn('Failed to create session log entry', {
+                title,
+                bugActivityId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return null;
+        }
+    }
+    /**
+     * Check if this bug was already classified by looking for classification message in discussion
+     */
+    async wasAlreadyClassified(bug) {
+        if (!bug.discussionId)
+            return false;
+        try {
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchDiscussionMessages(bug.discussionId, 20);
+            const messages = result?.messages || [];
+            // Check if any message contains our classification pattern
+            return messages.some((msg) => {
+                const content = msg.content || msg.msg || msg.message || '';
+                return content.includes('**Classification:') && content.includes('Reply **"fix it"**');
+            });
+        }
+        catch (error) {
+            logger.debug('Failed to check classification history', { bugId: bug.id, error });
+            return false;
+        }
+    }
+    /**
+     * Handle a new bug - main entry point
+     */
+    async handleBug(bug) {
+        logger.info('Giuseppe analyzing report', {
+            bugId: bug.id,
+            bugName: bug.name,
+            appId: bug.appId
+        });
+        const result = {
+            success: false,
+            summary: '',
+            log: []
+        };
+        // Check if already classified (e.g., after server restart)
+        const alreadyClassified = await this.wasAlreadyClassified(bug);
+        if (alreadyClassified) {
+            logger.info('Bug already classified, skipping re-classification', { bugId: bug.id });
+            // Re-register in pending registry for message watching (in case server restarted)
+            if (bug.discussionId) {
+                // Just register with unknown classification - we're waiting for user response
+                pending_classification_registry_1.pendingClassificationRegistry.register({
+                    discussionId: bug.discussionId,
+                    bugId: bug.id,
+                    bugName: bug.name,
+                    appId: bug.appId,
+                    appName: bug.appName,
+                    classification: 'unclear', // Unknown at this point
+                    reason: 'Previously classified',
+                    timestamp: Date.now(),
+                    bug
+                });
+                this.monitor.watchDiscussion(bug.discussionId);
+            }
+            return {
+                success: false,
+                summary: 'Already classified - awaiting confirmation'
+            };
+        }
+        try {
+            // 0. Join the bug's discussion so we can post updates
+            await this.joinBugDiscussion(bug.id);
+            // 1. Classify the report first
+            const { classification, reason } = await this.ai.classifyReport(bug);
+            result.log?.push(`Classification: ${classification} - ${reason}`);
+            // 2. Post classification and ask for confirmation
+            const classificationEmoji = classification === 'bug' ? '🐛' : classification === 'feature_request' ? '✨' : '❓';
+            const classificationLabel = classification === 'bug' ? 'Bug' : classification === 'feature_request' ? 'Feature Request' : 'Unclear';
+            const confirmMessage = [
+                `${classificationEmoji} **Classification: ${classificationLabel}**`,
+                '',
+                `**Reason:** ${reason}`,
+                '',
+                classification === 'bug'
+                    ? `This looks like a bug I can try to fix.\n\n👉 Reply **"fix it"** to proceed with auto-fix.\n👉 Reply **"not a bug"** if this is actually a feature request.`
+                    : `This looks like a feature request, not a bug.\n\n👉 Reply **"fix it"** if you still want me to try.\n👉 Reply **"not a bug"** to confirm and close.`
+            ].join('\n');
+            await this.reportProgress(bug, confirmMessage);
+            // 3. Store pending classification and wait for user response
+            if (bug.discussionId) {
+                pending_classification_registry_1.pendingClassificationRegistry.register({
+                    discussionId: bug.discussionId,
+                    bugId: bug.id,
+                    bugName: bug.name,
+                    appId: bug.appId,
+                    appName: bug.appName,
+                    classification,
+                    reason,
+                    timestamp: Date.now(),
+                    bug
+                });
+                logger.info('Stored pending classification', {
+                    discussionId: bug.discussionId,
+                    bugId: bug.id,
+                    classification,
+                    pendingClassificationsSize: pending_classification_registry_1.pendingClassificationRegistry.size
+                });
+                this.monitor.watchDiscussion(bug.discussionId);
+            }
+            result.summary = `Classified as ${classificationLabel} - awaiting confirmation`;
+            result.log?.push('Waiting for user to confirm with "fix it"');
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Classification failed', { bugId: bug.id, error: errorMessage });
+            result.summary = `Classification error: ${errorMessage}`;
+            return result;
+        }
+    }
+    /**
+     * Continue with bug fix after user confirms
+     */
+    async proceedWithFix(bug) {
+        logger.info('Giuseppe proceeding with fix', {
+            bugId: bug.id,
+            bugName: bug.name,
+            appId: bug.appId
+        });
+        const result = {
+            success: false,
+            summary: '',
+            log: []
+        };
+        try {
+            // 1. Find app project
+            const app = await this.files.findAppProject(bug, this.appsRegistry);
+            if (!app) {
+                result.summary = `Could not find app project for appId: ${bug.appId}`;
+                result.log?.push('App project not found');
+                await this.reportProgress(bug, `❌ ${result.summary}`);
+                return result;
+            }
+            result.log?.push(`Found app project: ${app.projectPath}`);
+            await this.reportProgress(bug, `📁 Found app project: ${app.name}`);
+            // 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));
+            if (!fixPlan) {
+                result.summary = 'Could not generate fix plan';
+                result.log?.push('Fix plan generation failed');
+                await this.reportProgress(bug, '❌ Could not analyze bug - manual review needed');
+                return result;
+            }
+            result.log?.push(`Fix plan: ${fixPlan.analysis}`);
+            await this.reportProgress(bug, `🔍 Analysis: ${fixPlan.analysis}\n🔧 Root cause: ${fixPlan.rootCause}`);
+            // 3. Move to "In Progress"
+            await this.monitor.moveBugToPhase(bug.id, 'inProgress');
+            // 4. Apply fixes and build (with retry on any failure)
+            const MAX_RETRIES = 3;
+            let currentFixPlan = fixPlan;
+            let fixSuccess = false;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                // Try to apply the fix
+                const applyResult = await this.files.applyFixes(app, currentFixPlan.fix.files);
+                if (!applyResult.success) {
+                    // Apply failed - likely search string not found
+                    result.log?.push(`Apply failed (attempt ${attempt}): ${applyResult.error}`);
+                    await this.reportProgress(bug, `❌ Apply failed (attempt ${attempt}/${MAX_RETRIES}): ${applyResult.error}`);
+                    if (attempt < MAX_RETRIES) {
+                        await this.reportProgress(bug, `🔄 Re-reading file and generating new fix...`);
+                        // Re-read the current state of files that need to be modified
+                        const filePaths = currentFixPlan.fix.files.map(f => f.path);
+                        const currentFiles = await this.files.readSelectedFiles(app.projectPath, filePaths);
+                        // Re-generate fix with current file state
+                        const retryFix = await this.ai.retryFixFromApplyError(bug, currentFixPlan, applyResult.error || 'Unknown error', currentFiles, attempt);
+                        if (!retryFix) {
+                            result.log?.push('Could not generate retry fix');
+                            await this.reportProgress(bug, `❌ Could not generate corrected fix`);
+                            break;
+                        }
+                        currentFixPlan = retryFix;
+                        continue; // Try applying again
+                    }
+                    break;
+                }
+                // Apply succeeded - now build
+                result.filesModified = [...new Set([...(result.filesModified || []), ...applyResult.files])];
+                result.log?.push(`Modified ${applyResult.files.length} file(s)`);
+                await this.reportProgress(bug, `✏️ Applied fixes to ${applyResult.files.length} file(s)`);
+                const buildResult = await this.buildAndTest(app);
+                if (buildResult.success) {
+                    fixSuccess = true;
+                    result.log?.push(`Build successful (attempt ${attempt})`);
+                    await this.reportProgress(bug, '✅ Build successful');
+                    break;
+                }
+                // Build failed
+                result.log?.push(`Build failed (attempt ${attempt}): ${buildResult.error}`);
+                await this.reportProgress(bug, `❌ Build failed (attempt ${attempt}/${MAX_RETRIES}):\n\`\`\`\n${buildResult.error}\n\`\`\``);
+                if (attempt < MAX_RETRIES) {
+                    await this.reportProgress(bug, `🔄 Analyzing error and retrying...`);
+                    // Read the current state of files that were modified
+                    const currentFiles = await this.files.readSelectedFiles(app.projectPath, currentFixPlan.fix.files.map(f => f.path));
+                    const retryFix = await this.ai.retryFixFromError(bug, currentFixPlan, buildResult.error || 'Unknown error', currentFiles, attempt);
+                    if (!retryFix) {
+                        result.log?.push('Could not generate retry fix');
+                        await this.reportProgress(bug, `❌ Could not generate corrected fix`);
+                        break;
+                    }
+                    currentFixPlan = retryFix;
+                    // Continue to next attempt - will apply the new fix
+                }
+            }
+            if (!fixSuccess) {
+                result.summary = `Fix failed after ${MAX_RETRIES} attempts`;
+                // Revert all changes
+                if (result.filesModified && result.filesModified.length > 0) {
+                    await this.git.revertChanges(app, result.filesModified);
+                }
+                await this.reportProgress(bug, `❌ Could not fix bug after ${MAX_RETRIES} attempts. Changes reverted.`);
+                return result;
+            }
+            // 6. Commit changes
+            const commitResult = await this.git.commitChanges(app, bug);
+            if (commitResult.hash) {
+                result.commitHash = commitResult.hash;
+                result.log?.push(`Committed: ${commitResult.hash}`);
+            }
+            // 7. Stay in "In Progress" - will move to "Fixed" only after approval
+            // (already moved to inProgress in step 3)
+            // 8. Store pending fix and ask owner to test
+            if (bug.discussionId) {
+                pending_fix_registry_1.pendingFixRegistry.register({
+                    discussionId: bug.discussionId,
+                    bugId: bug.id,
+                    appId: bug.appId || app.name,
+                    state: 'awaiting_test',
+                    fixSummary: currentFixPlan.explanation,
+                    timestamp: Date.now(),
+                    bug,
+                    app,
+                    fixPlan: currentFixPlan,
+                    filesModified: result.filesModified || [],
+                    commitHash: result.commitHash
+                });
+                logger.info('Stored pending fix awaiting approval', { bugId: bug.id, discussionId: bug.discussionId });
+                // Start watching this discussion for approval messages
+                this.monitor.watchDiscussion(bug.discussionId);
+            }
+            result.success = true;
+            result.summary = `Fixed: ${currentFixPlan.explanation} (awaiting approval)`;
+            // Ask owner to test with clear magic words
+            await this.reportProgress(bug, `✅ **Bug Fixed!**
+
+${currentFixPlan.explanation}
+
+**Files changed:** ${result.filesModified?.join(', ') || 'none'}
+
+---
+
+🧪 **Please test the fix locally**, then reply with:
+- **\`approved\`** - to publish to production
+- **\`denied\`** - if the fix doesn't work (I'll ask what's wrong)`);
+            return result;
+        }
+        catch (error) {
+            result.summary = `Error: ${error instanceof Error ? error.message : String(error)}`;
+            result.log?.push(`Exception: ${result.summary}`);
+            logger.error('Giuseppe failed', { bugId: bug.id, error });
+            await this.reportProgress(bug, `❌ Giuseppe encountered an error: ${result.summary}`);
+            return result;
+        }
+    }
+    /**
+     * Handle a message in a bug discussion - state machine for approval flow
+     */
+    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();
+        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")
+        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', {
+                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')
+            });
+            if (messageLower === MAGIC_WORD_FIX_IT || messageLower === 'fix') {
+                logger.debug('Matched fix it - 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');
+                return await this.handleNotABugConfirmation(discussionId, pendingClassification);
+            }
+            logger.debug('No magic word match - ignoring message');
+            // Other messages while waiting for classification - ignore
+            return { approved: false, published: false };
+        }
+        // Check for pending fix (waiting for "approved" or "denied")
+        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) {
+            return await this.handleApproval(discussionId, pendingFix);
+        }
+        // All other messages: return false, let HAL handle
+        return { approved: false, published: false };
+    }
+    /**
+     * Handle "fix it" confirmation - proceed with bug fix
+     */
+    async handleFixItConfirmation(discussionId, pending) {
+        logger.info('User confirmed fix', { discussionId, bugId: pending.bugId });
+        // 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
+        const result = await this.proceedWithFix(pending.bug);
+        return {
+            approved: true,
+            published: result.success,
+            error: result.success ? undefined : result.summary
+        };
+    }
+    /**
+     * Handle "not a bug" confirmation - close without fixing
+     */
+    async handleNotABugConfirmation(discussionId, pending) {
+        logger.info('User confirmed not a bug', { discussionId, bugId: pending.bugId });
+        // Remove from pending classifications
+        pending_classification_registry_1.pendingClassificationRegistry.unregister(discussionId);
+        this.monitor.unwatchDiscussion(discussionId);
+        await this.sendDiscussionMessage(discussionId, `✅ Understood. This has been marked as a feature request and moved to Declined.\n\nPlease create a feature request if you'd like this change implemented.`);
+        // Move to declined phase (not a bug)
+        await this.monitor.moveBugToPhase(pending.bugId, 'declined');
+        return { approved: false, published: false };
+    }
+    /**
+     * Handle "approved" - publish to production
+     */
+    async handleApproval(discussionId, pending) {
+        logger.info('Fix approved', { discussionId, bugId: pending.bugId });
+        await this.sendDiscussionMessage(discussionId, `🚀 Publishing to production...`);
+        const publishResult = await this.publishApp(pending.app, pending.bug);
+        if (publishResult.success) {
+            // Move to Fixed phase (published successfully)
+            await this.monitor.moveBugToPhase(pending.bugId, 'fixed');
+            // Remove from pending and stop watching
+            pending_fix_registry_1.pendingFixRegistry.unregister(discussionId);
+            this.monitor.unwatchDiscussion(discussionId);
+            // Log to Session Log - fix published
+            await this.createSessionLogEntry(`Giuseppe: Published fix for ${pending.bug.name}`, [
+                `**Bug Report:** ${pending.bug.name}`,
+                `**App:** ${pending.app.name}`,
+                `**Version:** ${publishResult.version || 'latest'}`,
+                `**Files changed:** ${pending.filesModified.join(', ') || 'none'}`,
+                '',
+                `**Fix summary:** ${pending.fixPlan.explanation}`,
+                '',
+                `Fix has been tested, approved, and published to production.`
+            ].join('\n'), pending.bugId);
+            await this.sendDiscussionMessage(discussionId, `✅ **Published to production!** v${publishResult.version || 'latest'}\n\nBug marked as Fixed. Thank you for testing!`);
+            logger.info('Fix published', { bugId: pending.bugId, version: publishResult.version });
+            return { approved: true, published: true };
+        }
+        else {
+            await this.sendDiscussionMessage(discussionId, `❌ Publish failed: ${publishResult.error}\n\nPlease try publishing manually or contact support.`);
+            return { approved: true, published: false, error: publishResult.error };
+        }
+    }
+    /**
+     * Handle "denied" - ask for explanation
+     */
+    async handleDenial(discussionId, pending) {
+        logger.info('Fix denied, asking for explanation', { discussionId, bugId: pending.bugId });
+        // Change state to awaiting_explanation
+        pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_explanation');
+        await this.sendDiscussionMessage(discussionId, `📝 **What's not working?**\n\nPlease describe what's still broken or what the fix didn't address. I'll analyze your feedback and try again.`);
+        return { approved: false, published: false };
+    }
+    /**
+     * Handle explanation after denial - retry the fix
+     */
+    async handleExplanationAndRetry(discussionId, pending, explanation) {
+        logger.info('Received explanation, retrying fix', {
+            discussionId,
+            bugId: pending.bugId,
+            explanation: explanation.substring(0, 100)
+        });
+        await this.sendDiscussionMessage(discussionId, `🔄 Got it. Analyzing your feedback and generating a new fix...`);
+        // Revert previous changes first
+        if (pending.filesModified.length > 0) {
+            await this.git.revertChanges(pending.app, pending.filesModified);
+            await this.sendDiscussionMessage(discussionId, `↩️ Reverted previous changes`);
+        }
+        // Get file list from git (fast, accurate)
+        let allSourceFiles = await this.git.getSourceFilesFromGit(pending.app.projectPath);
+        if (allSourceFiles.length === 0) {
+            // Fallback to directory scan if git fails
+            allSourceFiles = await this.files.scanSourceFiles(pending.app.projectPath);
+        }
+        // Search for relevant files based on feedback keywords
+        const relevantFiles = await this.files.findRelevantFiles(pending.app.projectPath, explanation, pending.bug);
+        // Always include files from previous fix
+        const previousFixFiles = pending.fixPlan.fix.files.map(f => f.path);
+        // Combine all relevant files (deduplicated)
+        const filesToRead = [...new Set([
+                ...previousFixFiles,
+                ...relevantFiles,
+                'src/App.tsx' // Always include main app file
+            ])].filter(f => allSourceFiles.includes(f));
+        const currentFiles = await this.files.readSelectedFiles(pending.app.projectPath, filesToRead);
+        // Generate new fix based on feedback
+        const retryFix = await this.ai.retryFixWithFeedback(pending.bug, pending.fixPlan, explanation, allSourceFiles, currentFiles);
+        if (!retryFix) {
+            await this.sendDiscussionMessage(discussionId, `❌ Could not generate a new fix based on your feedback. Please provide more details or contact support.`);
+            // Reset state to allow another try
+            pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_explanation');
+            return { approved: false, published: false, error: 'Could not generate retry fix' };
+        }
+        // Apply the new fix
+        const applyResult = await this.files.applyFixes(pending.app, retryFix.fix.files);
+        if (!applyResult.success) {
+            await this.sendDiscussionMessage(discussionId, `❌ Failed to apply new fix: ${applyResult.error}\n\nPlease provide more details about the issue.`);
+            pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_explanation');
+            return { approved: false, published: false, error: applyResult.error };
+        }
+        // Build and test
+        const buildResult = await this.buildAndTest(pending.app);
+        if (!buildResult.success) {
+            await this.sendDiscussionMessage(discussionId, `❌ Build failed:\n\`\`\`\n${buildResult.error}\n\`\`\`\n\nI'll need to try a different approach. What exactly is broken?`);
+            // Revert and ask again
+            await this.git.revertChanges(pending.app, applyResult.files);
+            pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_explanation');
+            return { approved: false, published: false, error: buildResult.error };
+        }
+        // Success! Update pending fix and ask for approval again
+        pending.fixPlan = retryFix;
+        pending.filesModified = applyResult.files;
+        pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_test');
+        await this.sendDiscussionMessage(discussionId, `✅ **New fix applied!**
+
+${retryFix.explanation}
+
+**Files changed:** ${applyResult.files.join(', ')}
+
+---
+
+🧪 **Please test again**, then reply with:
+- **\`approved\`** - to publish to production
+- **\`denied\`** - if still not working`);
+        return { approved: false, published: false, retrying: true };
+    }
+    /**
+     * Check if there's a pending fix for a discussion
+     */
+    hasPendingFix(discussionId) {
+        return pending_fix_registry_1.pendingFixRegistry.has(discussionId);
+    }
+    /**
+     * Retry a pending fix with explanation from HAL
+     * Called by HAL after gathering info through conversation
+     */
+    async retryWithExplanation(discussionId, explanation) {
+        const pending = pending_fix_registry_1.pendingFixRegistry.get(discussionId);
+        if (!pending) {
+            logger.warn('No pending fix found for retry', { discussionId });
+            return false;
+        }
+        logger.info('HAL triggered retry with explanation', {
+            discussionId,
+            bugId: pending.bugId,
+            explanationLength: explanation.length
+        });
+        // Update registry state
+        pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_explanation');
+        // Trigger the retry
+        const result = await this.handleExplanationAndRetry(discussionId, pending, explanation);
+        // Update registry state based on result
+        if (result.retrying) {
+            pending_fix_registry_1.pendingFixRegistry.updateState(discussionId, 'awaiting_test');
+        }
+        return result.retrying || false;
+    }
+    /**
+     * Initialize registry callback (call this after construction)
+     */
+    initializeRegistryCallback() {
+        pending_fix_registry_1.pendingFixRegistry.setRetryCallback(async (discussionId, explanation) => {
+            await this.retryWithExplanation(discussionId, explanation);
+        });
+        logger.info('Registry retry callback initialized');
+    }
+    /**
+     * Initialize classification registry callbacks for HAL coordination
+     * This allows HAL to trigger "fix it" or "not a bug" via natural conversation
+     */
+    initializeClassificationCallbacks() {
+        pending_classification_registry_1.pendingClassificationRegistry.setCallbacks(
+        // fixIt callback
+        async (discussionId) => {
+            const pending = pending_classification_registry_1.pendingClassificationRegistry.get(discussionId);
+            if (pending) {
+                await this.handleFixItConfirmation(discussionId, pending);
+            }
+        }, 
+        // notABug callback
+        async (discussionId) => {
+            const pending = pending_classification_registry_1.pendingClassificationRegistry.get(discussionId);
+            if (pending) {
+                await this.handleNotABugConfirmation(discussionId, pending);
+            }
+        });
+        logger.info('Classification callbacks initialized');
+    }
+    /**
+     * Helper to send a message to a discussion
+     */
+    async sendDiscussionMessage(discussionId, message) {
+        try {
+            const { hailer } = this.userContext;
+            await hailer.sendDiscussionMessage(discussionId, message);
+        }
+        catch (error) {
+            logger.warn('Failed to send discussion message', { discussionId, error });
+        }
+    }
+    /**
+     * Build and test the app
+     */
+    async buildAndTest(app) {
+        return new Promise((resolve) => {
+            const child = (0, child_process_1.spawn)('npm', ['run', 'build'], {
+                cwd: app.projectPath,
+                shell: true
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve({ success: true });
+                }
+                else {
+                    // TypeScript errors often go to stdout, combine both
+                    const allOutput = stdout + '\n' + stderr;
+                    // Extract just the error lines (look for .tsx/.ts errors)
+                    const errorLines = allOutput.split('\n')
+                        .filter(line => line.includes('error TS') || line.includes('Error:') || line.includes('error:'))
+                        .slice(0, 10)
+                        .join('\n');
+                    resolve({ success: false, error: errorLines || allOutput.slice(-1000) });
+                }
+            });
+            child.on('error', (error) => {
+                resolve({ success: false, error: error.message });
+            });
+            // Timeout after 2 minutes
+            setTimeout(() => {
+                child.kill();
+                resolve({ success: false, error: 'Build timeout' });
+            }, 120000);
+        });
+    }
+    /**
+     * Join a bug's discussion using the activity ID (not discussion ID)
+     * For activity discussions, we must use joinActivityDiscussion
+     */
+    async joinBugDiscussion(activityId) {
+        try {
+            const { hailer } = this.userContext;
+            await hailer.joinActivityDiscussion(activityId);
+            logger.info('Joined bug discussion', { activityId });
+        }
+        catch (error) {
+            // Might already be a member, that's OK
+            logger.debug('Could not join bug discussion (may already be member)', { activityId, error });
+        }
+    }
+    /**
+     * Publish app to production using expect script (same as MCP tool)
+     */
+    async publishApp(app, bug) {
+        try {
+            // Bump patch version before publishing (bug fix = patch)
+            const versionBump = await this.git.bumpPatchVersion(app.projectPath);
+            const version = versionBump?.newVersion || '1.0.0';
+            if (versionBump) {
+                logger.info('Version bumped for bug fix', {
+                    oldVersion: versionBump.oldVersion,
+                    newVersion: versionBump.newVersion,
+                    bugId: bug.id
+                });
+                // Stage and commit the version bump
+                await this.git.commitVersionBump(app.projectPath, version);
+            }
+            logger.info('Publishing app via MCP tool', {
+                projectPath: app.projectPath,
+                version
+            });
+            // Use the MCP publish_hailer_app tool directly
+            const result = await app_scaffold_1.publishHailerAppTool.execute({
+                projectDirectory: app.projectPath,
+                publishToMarket: false
+            }, this.userContext);
+            // Parse the result
+            const text = result.content?.[0]?.type === 'text' ? result.content[0].text : '';
+            if (text.includes('✅') || text.includes('Successfully') || text.includes('Published')) {
+                logger.info('App published successfully', { version });
+                // Push to git after successful publish
+                await this.git.push(app.projectPath);
+                // Create and push version tag (persists version history across code resets)
+                this.git.createVersionTag(app.projectPath, version);
+                return { success: true, version };
+            }
+            else {
+                // Extract error message from response
+                const errorMatch = text.match(/❌.*?(?:\n|$)/)?.[0] || text.substring(0, 200);
+                logger.error('Publish failed', { error: errorMatch });
+                return { success: false, error: errorMatch };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Publish exception', { error: errorMessage });
+            return {
+                success: false,
+                error: errorMessage
+            };
+        }
+    }
+    /**
+     * Report progress to bug discussion
+     */
+    async reportProgress(bug, message) {
+        if (!bug.discussionId)
+            return;
+        try {
+            const { hailer } = this.userContext;
+            await hailer.sendDiscussionMessage(bug.discussionId, message);
+        }
+        catch (error) {
+            logger.warn('Failed to report progress', { bugId: bug.id, error });
+        }
+    }
+}
+exports.GiuseppeBot = GiuseppeBot;
+//# sourceMappingURL=giuseppe-bot.js.map