@hailer/mcp 0.1.16 → 0.2.1

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

@@ -1,804 +0,0 @@
-"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 giuseppe_lsp_1 = require("./giuseppe-lsp");
-const discussion_lock_1 = require("../../lib/discussion-lock");
-const logger = (0, logger_1.createLogger)({ component: 'giuseppe-bot' });
-// 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;
-    lsp;
-    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);
-        this.lsp = new giuseppe_lsp_1.GiuseppeLsp();
-        // 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
-        });
-        // Acquire lock on this discussion to prevent other bots (Orchestrator) from responding
-        if (bug.discussionId) {
-            (0, discussion_lock_1.acquireDiscussionLock)(bug.discussionId, 'giuseppe', 10 * 60 * 1000); // 10 minute lock
-        }
-        const result = {
-            success: false,
-            summary: '',
-            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}`);
-            // Note: LSP analysis now runs AFTER Phase 1 identifies relevant files
-            // This is more efficient - we only analyze files related to the bug
-            // 2. Analyze and generate fix
-            const allFiles = await this.files.scanSourceFiles(app.projectPath);
-            // Create LSP analysis callback - runs TARGETED analysis on specific files
-            const runLspAnalysis = async (files, keywords) => {
-                logger.info('Running targeted LSP analysis', { files: files.length, keywords });
-                const analysis = await this.lsp.analyzeRelevantFiles(app.projectPath, files, keywords);
-                return {
-                    unusedProps: (analysis.unusedProps || []).map((p) => ({
-                        name: p.name,
-                        line: p.line,
-                        file: p.file || 'unknown'
-                    })),
-                    issues: (analysis.issues || []).map(i => ({
-                        file: i.file,
-                        line: i.line,
-                        message: i.message
-                    }))
-                };
-            };
-            const fixPlan = await this.ai.analyzeAndPlanFix(bug, app, allFiles, (paths) => this.files.readSelectedFiles(app.projectPath, paths), runLspAnalysis);
-            if (!fixPlan) {
-                result.summary = 'Could not generate fix plan';
-                result.log?.push('Fix plan generation failed');
-                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_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 - uses LLM to understand intent
-     */
-    async handleDiscussionMessage(discussionId, message, _senderId) {
-        logger.debug('handleDiscussionMessage called', {
-            discussionId,
-            message: message.substring(0, 50),
-            pendingClassificationsSize: pending_classification_registry_1.pendingClassificationRegistry.size,
-            hasPendingForDiscussion: pending_classification_registry_1.pendingClassificationRegistry.has(discussionId)
-        });
-        // Check for pending classification first (waiting for user to confirm fix or mark as not-a-bug)
-        const pendingClassification = pending_classification_registry_1.pendingClassificationRegistry.get(discussionId);
-        if (pendingClassification) {
-            // Use LLM to understand user intent (replaces hardcoded magic words)
-            const { intent, confidence } = await this.ai.detectIntent(message, 'classification');
-            logger.debug('Classification intent detected', {
-                discussionId,
-                message: message.substring(0, 50),
-                intent,
-                confidence
-            });
-            if (intent === 'fix_it' && confidence !== 'low') {
-                logger.debug('User wants to fix - calling handleFixItConfirmation');
-                return await this.handleFixItConfirmation(discussionId, pendingClassification);
-            }
-            if (intent === 'not_a_bug' && confidence !== 'low') {
-                logger.debug('User says not a bug - calling handleNotABugConfirmation');
-                return await this.handleNotABugConfirmation(discussionId, pendingClassification);
-            }
-            // Unknown or clarify intent - ignore and wait for clearer response
-            logger.debug('Unclear intent - waiting for clearer response', { intent, confidence });
-            return { approved: false, published: false };
-        }
-        // Check for pending fix (waiting for approval to publish)
-        const pendingFix = pending_fix_registry_1.pendingFixRegistry.get(discussionId);
-        if (!pendingFix) {
-            return { approved: false, published: false };
-        }
-        // Use LLM to understand approval intent
-        const { intent, confidence } = await this.ai.detectIntent(message, 'approval');
-        logger.debug('Approval intent detected', {
-            discussionId,
-            message: message.substring(0, 50),
-            intent,
-            confidence
-        });
-        if (intent === 'approved' && confidence !== 'low') {
-            return await this.handleApproval(discussionId, pendingFix);
-        }
-        if (intent === 'denied' && confidence !== 'low') {
-            // Handle denial - revert changes
-            return await this.handleDenial(discussionId, pendingFix);
-        }
-        if (intent === 'retry' && confidence !== 'low') {
-            // User wants to try again - not implemented yet
-            await this.sendDiscussionMessage(discussionId, "🔄 Retry is not implemented yet. Please say 'approved' to publish or 'denied' to cancel.");
-            return { approved: false, published: false };
-        }
-        // Unknown intent - let HAL or user clarify
-        return { approved: false, published: false };
-    }
-    /**
-     * 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 (creates commit, stores pending fix awaiting approval)
-        const result = await this.proceedWithFix(pending.bug);
-        // Return false for both - the CLASSIFICATION was approved ("fix it"),
-        // but the FIX itself is not yet approved (waiting for "approved" message)
-        // The fix was applied locally but NOT published to production
-        return {
-            approved: false, // Fix not approved yet, just classification
-            published: false, // Not published, just committed locally
-            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