@hailer/mcp 1.1.15 → 1.1.16

package/dist/agents/bug-fixer/bot.js

@@ -0,0 +1,687 @@
+"use strict";
+/**
+ * Bug Reports Module - Bug Fixer 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.BugFixerBot = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../../lib/logger");
+const pending_fix_1 = require("./registries/pending-fix");
+const pending_classification_1 = require("./registries/pending-classification");
+const app_scaffold_1 = require("../../mcp/tools/app-scaffold");
+// Import extracted modules
+const ai_1 = require("./ai");
+const git_1 = require("./git");
+const files_1 = require("./files");
+const lsp_1 = require("./lsp");
+const logger = (0, logger_1.createLogger)({ component: 'bug-fixer-bot' });
+class BugFixerBot {
+    userContext;
+    config;
+    monitor;
+    ai;
+    git;
+    files;
+    lsp;
+    appsRegistry = new Map();
+    schemaCache = null;
+    constructor(userContext, config, monitor, schemaCache) {
+        this.userContext = userContext;
+        this.config = config;
+        this.monitor = monitor;
+        // Initialize extracted modules
+        const apiKey = config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        this.ai = new ai_1.BugFixerAI(apiKey);
+        this.git = new git_1.BugFixerGit();
+        this.files = new files_1.BugFixerFiles(process.env.DEV_APPS_PATH, process.env.DEV_APPS_PATHS);
+        this.lsp = new lsp_1.BugFixerLsp();
+        this.schemaCache = schemaCache || null;
+        // Load apps registry from config
+        if (config.appsRegistry) {
+            for (const [appId, entry] of Object.entries(config.appsRegistry)) {
+                this.appsRegistry.set(appId, entry);
+            }
+        }
+    }
+    /**
+     * Set schema cache for dynamic workflow discovery
+     */
+    setSchemaCache(cache) {
+        this.schemaCache = cache;
+    }
+    /**
+     * Create a session log entry using dynamic schema discovery
+     * Links to the bug report for traceability
+     */
+    async createSessionLogEntry(title, summary, bugActivityId, metadata) {
+        try {
+            const { hailer, workspaceCache } = this.userContext;
+            const workspaceId = workspaceCache.currentWorkspace._id;
+            // Get Session Log schema dynamically
+            const schema = this.schemaCache?.getSessionLogSchema(workspaceId);
+            if (!schema) {
+                logger.warn('Session Log workflow not found in workspace - skipping session log', { workspaceId });
+                return null;
+            }
+            // Get field IDs from schema
+            const contextSummaryFieldId = schema.fields["contextSummary"] || schema.fields["Context summary"];
+            const linkedWorkFieldId = schema.fields["linkedWork"] || schema.fields["Most relevant link to work"];
+            const headlineFieldId = schema.fields["headline"];
+            const topicsFieldId = schema.fields["topics"];
+            const outcomeFieldId = schema.fields["outcome"];
+            // Get phase ID (try "active" first, then first available)
+            const phaseId = schema.phases["active"] || Object.values(schema.phases)[0];
+            if (!phaseId) {
+                logger.warn('No phase found in Session Log workflow');
+                return null;
+            }
+            // Build fields object
+            const fields = {};
+            if (contextSummaryFieldId) {
+                fields[contextSummaryFieldId] = summary;
+            }
+            if (linkedWorkFieldId && bugActivityId) {
+                fields[linkedWorkFieldId] = bugActivityId;
+            }
+            if (headlineFieldId && metadata?.headline) {
+                fields[headlineFieldId] = metadata.headline;
+            }
+            if (topicsFieldId && metadata?.topics) {
+                fields[topicsFieldId] = metadata.topics;
+            }
+            if (outcomeFieldId && metadata?.outcome) {
+                fields[outcomeFieldId] = metadata.outcome;
+            }
+            // Create activity
+            const activities = [{
+                    name: title,
+                    phaseId,
+                    fields
+                }];
+            const result = await hailer.createActivities(schema.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,
+                    workflowId: schema.workflowId
+                });
+                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('Bug Fixer 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_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_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_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('Bug Fixer 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}`);
+            // 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}`);
+            }
+            // 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) {
+                    // Run LSP analysis to check for remaining issues
+                    const lspResult = await this.lsp.validateFix(app.projectPath);
+                    if (!lspResult.valid) {
+                        result.log?.push(`LSP found ${lspResult.errors.length} issue(s)`);
+                        await this.reportProgress(bug, `⚠️ Build passed but LSP found issues:\n${lspResult.errors.slice(0, 3).join('\n')}`);
+                    }
+                    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_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('Bug Fixer failed', { bugId: bug.id, error });
+            await this.reportProgress(bug, `❌ Bug Fixer encountered an error: ${result.summary}`);
+            return result;
+        }
+    }
+    /**
+     * Publish an approved fix to production
+     * Called by the approval callback when LLM triggers publish via tool
+     */
+    async publishApprovedFix(discussionId, pending) {
+        logger.info('Publishing approved fix', { 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_1.pendingFixRegistry.unregister(discussionId);
+            this.monitor.unwatchDiscussion(discussionId);
+            // Log to Session Log - fix published
+            await this.createSessionLogEntry(`Bug Fixer: 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, {
+                headline: `Fixed bug in ${pending.app.name}: ${pending.bug.name.substring(0, 40)}`,
+                topics: 'bug, fix, publish, app',
+                outcome: 'resolved'
+            });
+            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 { success: true, version: publishResult.version };
+        }
+        else {
+            await this.sendDiscussionMessage(discussionId, `❌ Publish failed: ${publishResult.error}\n\nPlease try publishing manually or contact support.`);
+            return { success: false, error: publishResult.error };
+        }
+    }
+    /**
+     * 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_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_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_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_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_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_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_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_1.pendingFixRegistry.updateState(discussionId, 'awaiting_test');
+        }
+        return result.retrying || false;
+    }
+    /**
+     * 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.BugFixerBot = BugFixerBot;
+//# sourceMappingURL=bot.js.map