@hailer/mcp 0.1.16 → 0.2.1

package/dist/agents/giuseppe/ai.d.ts

@@ -1,83 +0,0 @@
-/**
- * Giuseppe AI Module - Claude API interactions for bug analysis and fix generation
- */
-import type { BugReport, AppRegistryEntry } from './types';
-/** Fix plan from Claude analysis */
-export interface FixPlan {
-    analysis: string;
-    debugTrace?: string;
-    failurePoint?: string;
-    rootCause: string;
-    fix: {
-        files: Array<{
-            path: string;
-            action: 'edit' | 'create' | 'delete';
-            search?: string;
-            replace?: string;
-            content?: string;
-        }>;
-    };
-    explanation: string;
-    testSuggestions?: string[];
-}
-export type BugClassification = 'bug' | 'feature_request' | 'unclear';
-export interface ClassificationResult {
-    classification: BugClassification;
-    reason: string;
-}
-export interface FileContent {
-    path: string;
-    content: string;
-}
-export declare class GiuseppeAI {
-    private anthropic?;
-    constructor(apiKey?: string);
-    get isAvailable(): boolean;
-    /**
-     * Classify a report as bug or feature request
-     */
-    classifyReport(bug: BugReport): Promise<ClassificationResult>;
-    /**
-     * Detect user intent from a message (replaces magic word detection)
-     * Returns the intent and confidence level
-     */
-    detectIntent(message: string, context: 'classification' | 'approval'): Promise<{
-        intent: string;
-        confidence: 'high' | 'medium' | 'low';
-        explanation: string;
-    }>;
-    /**
-     * Extract keywords from bug description for LSP filtering
-     */
-    private extractKeywords;
-    /**
-     * Analyze bug and generate fix plan using Claude (two-phase approach)
-     * Phase 1: Send file list -> Claude picks relevant files
-     * Phase 2: Send those files -> Claude generates fix
-     */
-    analyzeAndPlanFix(bug: BugReport, app: AppRegistryEntry, allFiles: string[], readFiles: (paths: string[]) => Promise<FileContent[]>, runLspAnalysis?: (files: string[], keywords: string[]) => Promise<{
-        unusedProps: {
-            name: string;
-            line: number;
-            file: string;
-        }[];
-        issues: {
-            file: string;
-            line: number;
-            message: string;
-        }[];
-    }>): Promise<FixPlan | null>;
-    /**
-     * Retry fix based on apply error (search string not found) - re-reads file and generates new fix
-     */
-    retryFixFromApplyError(bug: BugReport, previousFix: FixPlan, applyError: string, currentFiles: FileContent[], attempt: number): Promise<FixPlan | null>;
-    /**
-     * Retry fix based on build error - sends error to Claude to generate corrected fix
-     */
-    retryFixFromError(bug: BugReport, previousFix: FixPlan, buildError: string, currentFiles: FileContent[], attempt: number): Promise<FixPlan | null>;
-    /**
-     * Generate a new fix based on user feedback
-     */
-    retryFixWithFeedback(bug: BugReport, previousFix: FixPlan, feedback: string, allSourceFiles: string[], currentFiles: FileContent[]): Promise<FixPlan | null>;
-}
-//# sourceMappingURL=ai.d.ts.map

package/dist/agents/giuseppe/ai.js

@@ -1,466 +0,0 @@
-"use strict";
-/**
- * Giuseppe AI Module - Claude API interactions for bug analysis and fix generation
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GiuseppeAI = void 0;
-const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
-const logger_1 = require("../../lib/logger");
-const prompt_1 = require("./prompt");
-const logger = (0, logger_1.createLogger)({ component: 'giuseppe-ai' });
-class GiuseppeAI {
-    anthropic;
-    constructor(apiKey) {
-        if (apiKey) {
-            this.anthropic = new sdk_1.default({ apiKey });
-        }
-    }
-    get isAvailable() {
-        return !!this.anthropic;
-    }
-    /**
-     * Classify a report as bug or feature request
-     */
-    async classifyReport(bug) {
-        if (!this.anthropic) {
-            return { classification: 'unclear', reason: 'No AI available for classification' };
-        }
-        try {
-            const prompt = `Classify this report as either a BUG or a FEATURE REQUEST.
-
-**Title:** ${bug.name}
-**Description:** ${bug.description || 'No description'}
-${bug.stepsToReproduce ? `**Steps:** ${bug.stepsToReproduce}` : ''}
-${bug.expectedBehavior ? `**Expected:** ${bug.expectedBehavior}` : ''}
-${bug.actualBehavior ? `**Actual:** ${bug.actualBehavior}` : ''}
-
-A BUG is something BROKEN - it was working or should work but doesn't.
-Examples: "button doesn't respond", "crashes when clicking", "data not saving", "display is wrong"
-
-A FEATURE REQUEST is asking for something NEW or DIFFERENT - not broken, just wanted.
-Examples: "change color to blue", "add dark mode", "make it bigger", "add new button"
-
-Respond with JSON only:
-{
-  "classification": "bug" | "feature_request" | "unclear",
-  "reason": "One sentence explaining why"
-}`;
-            const response = await this.anthropic.messages.create({
-                model: 'claude-haiku-4-5-20251001',
-                max_tokens: 200,
-                messages: [{ role: 'user', content: prompt }]
-            });
-            const content = response.content[0];
-            if (content.type !== 'text') {
-                return { classification: 'unclear', reason: 'Could not classify' };
-            }
-            const parsed = JSON.parse(content.text.replace(/```json\n?|\n?```/g, ''));
-            return {
-                classification: parsed.classification || 'unclear',
-                reason: parsed.reason || 'No reason provided'
-            };
-        }
-        catch (error) {
-            logger.error('Classification failed', { error });
-            return { classification: 'unclear', reason: 'Classification error' };
-        }
-    }
-    /**
-     * Detect user intent from a message (replaces magic word detection)
-     * Returns the intent and confidence level
-     */
-    async detectIntent(message, context) {
-        if (!this.anthropic) {
-            // Fallback to simple keyword matching
-            const lower = message.toLowerCase().trim();
-            if (context === 'classification') {
-                if (lower.includes('fix') && !lower.includes('don\'t') && !lower.includes('not')) {
-                    return { intent: 'fix_it', confidence: 'medium', explanation: 'Contains "fix"' };
-                }
-                if (lower.includes('not a bug') || lower.includes('feature')) {
-                    return { intent: 'not_a_bug', confidence: 'medium', explanation: 'Contains "not a bug" or "feature"' };
-                }
-            }
-            else {
-                if (lower === 'approved' || lower === 'yes' || lower === 'ship it' || lower === 'deploy') {
-                    return { intent: 'approved', confidence: 'medium', explanation: 'Approval keyword' };
-                }
-                if (lower === 'denied' || lower === 'no' || lower === 'revert' || lower === 'cancel') {
-                    return { intent: 'denied', confidence: 'medium', explanation: 'Denial keyword' };
-                }
-            }
-            return { intent: 'unknown', confidence: 'low', explanation: 'No matching keywords' };
-        }
-        try {
-            const contextDescription = context === 'classification'
-                ? `Giuseppe classified a bug report and is waiting for the user to confirm:
-- "fix_it" = User wants Giuseppe to proceed with fixing the bug
-- "not_a_bug" = User says this isn't a bug, it's a feature request or not an issue
-- "clarify" = User is asking a question or providing more info
-- "unknown" = Can't determine intent`
-                : `Giuseppe has created a fix and is waiting for approval to publish:
-- "approved" = User approves publishing to production
-- "denied" = User rejects the fix or wants changes
-- "retry" = User wants Giuseppe to try a different approach
-- "question" = User is asking about the fix
-- "unknown" = Can't determine intent`;
-            const prompt = `Detect the user's intent from this message.
-
-Context: ${contextDescription}
-
-User message: "${message}"
-
-Respond with JSON only (no markdown):
-{"intent": "...", "confidence": "high|medium|low", "explanation": "brief reason"}`;
-            const response = await this.anthropic.messages.create({
-                model: 'claude-haiku-4-5-20251001',
-                max_tokens: 150,
-                messages: [{ role: 'user', content: prompt }]
-            });
-            const content = response.content[0];
-            if (content.type !== 'text') {
-                return { intent: 'unknown', confidence: 'low', explanation: 'AI response error' };
-            }
-            const parsed = JSON.parse(content.text.replace(/```json\n?|\n?```/g, '').trim());
-            logger.info('Intent detected', {
-                message: message.substring(0, 50),
-                intent: parsed.intent,
-                confidence: parsed.confidence
-            });
-            return {
-                intent: parsed.intent || 'unknown',
-                confidence: parsed.confidence || 'low',
-                explanation: parsed.explanation || ''
-            };
-        }
-        catch (error) {
-            logger.error('Intent detection failed', { error, message: message.substring(0, 50) });
-            return { intent: 'unknown', confidence: 'low', explanation: 'Detection error' };
-        }
-    }
-    /**
-     * Extract keywords from bug description for LSP filtering
-     */
-    extractKeywords(description) {
-        // Common technical terms to look for
-        const techTerms = [
-            'click', 'drag', 'drop', 'scroll', 'hover', 'focus', 'blur',
-            'render', 'update', 'load', 'save', 'delete', 'create',
-            'button', 'input', 'form', 'modal', 'menu', 'list', 'table',
-            'position', 'animation', 'transition', 'style', 'color',
-            'error', 'crash', 'freeze', 'slow', 'lag', 'broken'
-        ];
-        const words = description.toLowerCase()
-            .replace(/[^\w\s]/g, ' ')
-            .split(/\s+/)
-            .filter(w => w.length > 2);
-        // Find matching tech terms
-        const matchedTerms = techTerms.filter(term => words.some(w => w.includes(term) || term.includes(w)));
-        // Also include unique words from description (nouns/verbs likely)
-        const uniqueWords = words.filter(w => w.length > 4 && !['the', 'and', 'but', 'for', 'not', 'with', 'this', 'that', 'when', 'have', 'from'].includes(w));
-        return [...new Set([...matchedTerms, ...uniqueWords])].slice(0, 10);
-    }
-    /**
-     * Analyze bug and generate fix plan using Claude (two-phase approach)
-     * Phase 1: Send file list -> Claude picks relevant files
-     * Phase 2: Send those files -> Claude generates fix
-     */
-    async analyzeAndPlanFix(bug, app, allFiles, readFiles, runLspAnalysis) {
-        if (!this.anthropic) {
-            logger.warn('Anthropic client not initialized - cannot generate fix');
-            return null;
-        }
-        try {
-            // Phase 1: Get file list and ask Claude which files to examine
-            logger.info('Phase 1: Asking Claude which files to examine', { fileCount: allFiles.length });
-            const phase1Prompt = `
-Bug Report:
-- Title: ${bug.name}
-- Description: ${bug.description}
-${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
-${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
-${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
-
-App: ${app.name}
-
-Source files in this project:
-${allFiles.map(f => `- ${f}`).join('\n')}
-
-Based on the bug description, which files should I examine to fix this bug?
-Return ONLY a JSON array of file paths, maximum 10 files. Example: ["src/App.tsx", "src/components/Player.tsx"]`;
-            const phase1Response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 1024,
-                system: 'You are a code analyst. Return only a JSON array of file paths that are most relevant to the bug. No explanation.',
-                messages: [{ role: 'user', content: phase1Prompt }]
-            });
-            const phase1Content = phase1Response.content[0];
-            if (phase1Content.type !== 'text')
-                return null;
-            // Parse file list from response
-            let relevantFiles = [];
-            try {
-                // Try to extract JSON array
-                const jsonMatch = phase1Content.text.match(/\[[\s\S]*?\]/);
-                if (jsonMatch) {
-                    relevantFiles = JSON.parse(jsonMatch[0]);
-                }
-            }
-            catch {
-                logger.warn('Could not parse file list from Phase 1', { response: phase1Content.text });
-                // Fallback: take first 5 files from src/
-                relevantFiles = allFiles.filter(f => f.startsWith('src/')).slice(0, 5);
-            }
-            logger.info('Phase 1 complete: Files to examine', { files: relevantFiles });
-            // Phase 1.5: Run TARGETED LSP analysis on relevant files only
-            // Extract keywords from bug description for filtering
-            const bugKeywords = this.extractKeywords(bug.description);
-            logger.info('Extracted bug keywords for LSP filtering', { keywords: bugKeywords });
-            let lspFindings = null;
-            if (runLspAnalysis) {
-                lspFindings = await runLspAnalysis(relevantFiles, bugKeywords);
-                logger.info('Targeted LSP analysis complete', {
-                    files: relevantFiles.length,
-                    unusedProps: lspFindings.unusedProps.length,
-                    issues: lspFindings.issues.length
-                });
-            }
-            // Phase 2: Read selected files and generate fix
-            const sourceFiles = await readFiles(relevantFiles);
-            logger.info('Phase 2: Generating fix', { filesRead: sourceFiles.length });
-            // Build LSP findings section if available
-            let lspSection = '';
-            if (lspFindings && (lspFindings.unusedProps.length > 0 || lspFindings.issues.length > 0)) {
-                lspSection = '\n\n=== LSP CODE ANALYSIS (HIGH PRIORITY) ===\n';
-                lspSection += 'IMPORTANT: These are REAL code issues detected by static analysis. Fix these FIRST.\n\n';
-                if (lspFindings.unusedProps.length > 0) {
-                    lspSection += 'UNUSED PROPS (declared in interface but never used in component):\n';
-                    lspFindings.unusedProps.forEach(p => {
-                        lspSection += `- ${p.file}:${p.line} - prop "${p.name}" is declared but never destructured/used\n`;
-                        // Add hint if prop name matches bug keywords
-                        if (bug.description.toLowerCase().includes(p.name.toLowerCase())) {
-                            lspSection += `  ^ THIS PROP NAME MATCHES THE BUG DESCRIPTION - VERY LIKELY THE ROOT CAUSE!\n`;
-                        }
-                    });
-                }
-                if (lspFindings.issues.length > 0) {
-                    lspSection += '\nDEAD CODE (functions/variables declared but never called):\n';
-                    lspFindings.issues.forEach(i => {
-                        lspSection += `- ${i.file}:${i.line} - ${i.message}\n`;
-                    });
-                }
-                lspSection += '\nThe fix should USE these unused props/functions, not add workaround code.\n';
-            }
-            const phase2Prompt = `
-Bug Report:
-- Title: ${bug.name}
-- Description: ${bug.description}
-${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
-${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
-${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
-- Priority: ${bug.priority || 'unknown'}
-${lspSection}
-App: ${app.name}
-Project path: ${app.projectPath}
-
-Source files:
-${sourceFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
-
-Analyze this bug and provide a fix. Output JSON only.`;
-            const phase2Response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                system: prompt_1.GIUSEPPE_SYSTEM_PROMPT,
-                messages: [{ role: 'user', content: phase2Prompt }]
-            });
-            // Extract JSON from response
-            const content = phase2Response.content[0];
-            if (content.type !== 'text')
-                return null;
-            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
-            if (!jsonMatch) {
-                // Try parsing whole response as JSON
-                try {
-                    return JSON.parse(content.text);
-                }
-                catch {
-                    logger.warn('Could not parse fix plan from response');
-                    return null;
-                }
-            }
-            return JSON.parse(jsonMatch[1]);
-        }
-        catch (error) {
-            logger.error('Failed to analyze bug', { error });
-            return null;
-        }
-    }
-    /**
-     * Retry fix based on apply error (search string not found) - re-reads file and generates new fix
-     */
-    async retryFixFromApplyError(bug, previousFix, applyError, currentFiles, attempt) {
-        if (!this.anthropic)
-            return null;
-        try {
-            logger.info('Retrying fix after apply error', { attempt, error: applyError });
-            const retryPrompt = `
-The previous fix attempt FAILED to apply with this error:
-\`\`\`
-${applyError}
-\`\`\`
-
-This usually means the search string didn't match the actual file content.
-
-Previous fix that was attempted:
-${JSON.stringify(previousFix.fix, null, 2)}
-
-Bug Report:
-- Title: ${bug.name}
-- Description: ${bug.description}
-
-CURRENT state of the files (read just now):
-${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
-
-Please analyze the current file content and provide a CORRECTED fix.
-Make sure the "search" strings EXACTLY match what's in the current files.
-Output JSON only.`;
-            const response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                system: prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: Your previous fix could not be applied because the search string was not found. Read the CURRENT file content carefully and make sure your search strings match EXACTLY.',
-                messages: [{ role: 'user', content: retryPrompt }]
-            });
-            const content = response.content[0];
-            if (content.type !== 'text')
-                return null;
-            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
-            if (!jsonMatch) {
-                try {
-                    return JSON.parse(content.text);
-                }
-                catch {
-                    return null;
-                }
-            }
-            return JSON.parse(jsonMatch[1]);
-        }
-        catch (error) {
-            logger.error('Failed to generate retry fix from apply error', { error });
-            return null;
-        }
-    }
-    /**
-     * Retry fix based on build error - sends error to Claude to generate corrected fix
-     */
-    async retryFixFromError(bug, previousFix, buildError, currentFiles, attempt) {
-        if (!this.anthropic)
-            return null;
-        try {
-            logger.info('Retrying fix based on build error', { attempt, error: buildError.substring(0, 200) });
-            const retryPrompt = `
-The previous fix attempt FAILED with this build error:
-\`\`\`
-${buildError}
-\`\`\`
-
-Previous fix that was attempted:
-${JSON.stringify(previousFix.fix, null, 2)}
-
-Bug Report:
-- Title: ${bug.name}
-- Description: ${bug.description}
-
-Current state of the files after the failed fix:
-${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
-
-Please analyze the build error and provide a CORRECTED fix.
-The fix must resolve the TypeScript/build error while still addressing the original bug.
-Output JSON only.`;
-            const response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                system: prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: Your previous fix caused a build error. Analyze the error carefully and provide a corrected fix that compiles successfully.',
-                messages: [{ role: 'user', content: retryPrompt }]
-            });
-            const content = response.content[0];
-            if (content.type !== 'text')
-                return null;
-            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
-            if (!jsonMatch) {
-                try {
-                    return JSON.parse(content.text);
-                }
-                catch {
-                    return null;
-                }
-            }
-            return JSON.parse(jsonMatch[1]);
-        }
-        catch (error) {
-            logger.error('Failed to generate retry fix', { error });
-            return null;
-        }
-    }
-    /**
-     * Generate a new fix based on user feedback
-     */
-    async retryFixWithFeedback(bug, previousFix, feedback, allSourceFiles, currentFiles) {
-        if (!this.anthropic)
-            return null;
-        try {
-            const prompt = `
-The previous fix was REJECTED by the user. Here's their feedback:
-
-**User feedback:**
-${feedback}
-
-**Original bug:**
-- Title: ${bug.name}
-- Description: ${bug.description}
-${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
-${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
-${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
-
-**Previous fix that was rejected:**
-${JSON.stringify(previousFix.fix, null, 2)}
-
-**AVAILABLE SOURCE FILES (use ONLY these exact paths):**
-${allSourceFiles.map(f => `- ${f}`).join('\n')}
-
-**Relevant source files (searched based on your feedback):**
-${currentFiles.map(f => `--- ${f.path} ---\n${f.content}\n`).join('\n')}
-
-Based on the user's feedback, generate a DIFFERENT fix that addresses their concerns.
-IMPORTANT: Use ONLY file paths from the AVAILABLE SOURCE FILES list above.
-Output JSON only.`;
-            const response = await this.anthropic.messages.create({
-                model: 'claude-sonnet-4-20250514',
-                max_tokens: 4096,
-                system: prompt_1.GIUSEPPE_SYSTEM_PROMPT + '\n\nIMPORTANT: The user rejected the previous fix. Read their feedback carefully and try a different approach.',
-                messages: [{ role: 'user', content: prompt }]
-            });
-            const content = response.content[0];
-            if (content.type !== 'text')
-                return null;
-            const jsonMatch = content.text.match(/```json\n([\s\S]*?)\n```/);
-            if (!jsonMatch) {
-                try {
-                    return JSON.parse(content.text);
-                }
-                catch {
-                    return null;
-                }
-            }
-            return JSON.parse(jsonMatch[1]);
-        }
-        catch (error) {
-            logger.error('Failed to generate retry fix with feedback', { error });
-            return null;
-        }
-    }
-}
-exports.GiuseppeAI = GiuseppeAI;
-//# sourceMappingURL=ai.js.map

package/dist/agents/giuseppe/bot.d.ts

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