@hailer/mcp 0.1.15 → 0.1.16

package/dist/mcp-server.js

@@ -49,6 +49,7 @@ const logger_1 = require("./lib/logger");
 const config_1 = require("./config");
 const UserContextCache_1 = require("./mcp/UserContextCache");
 const tool_registry_1 = require("./mcp/tool-registry");
+const webhook_handler_1 = require("./mcp/webhook-handler");
 class MCPServerService {
     app;
     server;
@@ -325,12 +326,61 @@ class MCPServerService {
                 res.status(500).json({ error: 'Failed to toggle bot' });
             }
         });
-        this.logger.info('Routes configured', {
+        // ===== Bot Config Webhook API =====
+        // Get secure webhook path (auto-generated token)
+        const webhookPath = (0, webhook_handler_1.getWebhookPath)();
+        // POST /webhook/{token} - Receives updates from Hailer workflow webhooks
+        this.app.post(webhookPath, (req, res) => {
+            req.logger.info('Bot config webhook received', {
+                activityId: req.body?._id,
+                activityName: req.body?.name,
+                workspaceId: req.body?.cid,
+            });
+            try {
+                const result = (0, webhook_handler_1.handleBotConfigWebhook)(req.body);
+                if (result.success) {
+                    req.logger.info('Bot config updated via webhook', {
+                        action: result.action,
+                        workspaceId: result.workspaceId,
+                        botType: result.botType,
+                    });
+                    res.status(200).json(result);
+                }
+                else {
+                    req.logger.warn('Bot config webhook failed', { error: result.error });
+                    res.status(400).json(result);
+                }
+            }
+            catch (error) {
+                req.logger.error('Bot config webhook error', { error });
+                res.status(500).json({
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Internal error',
+                });
+            }
+        });
+        // GET /webhook/{token}/status - Status endpoint to see all workspace configs
+        this.app.get(`${webhookPath}/status`, (_req, res) => {
+            const configs = (0, webhook_handler_1.listWorkspaceConfigs)();
+            res.json({
+                timestamp: new Date().toISOString(),
+                workspaceCount: configs.length,
+                workspaces: configs.map((c) => ({
+                    workspaceId: c.workspaceId,
+                    workspaceName: c.workspaceName,
+                    hasOrchestrator: !!c.orchestrator,
+                    specialistCount: c.specialists.length,
+                    enabledSpecialists: c.specialists.filter((s) => s.enabled).length,
+                    lastSynced: c.lastSynced,
+                })),
+            });
+        });
+        this.logger.debug('Routes configured', {
             routes: [
-                '/health - Server health check',
-                '/daemon/status - Daemon context monitor',
-                '/api/mcp - MCP protocol (JSON-RPC 2.0)',
-                '/api/bots - Bot configuration API'
+                '/health',
+                '/daemon/status',
+                '/api/mcp',
+                '/api/bots'
             ]
         });
     }

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

@@ -0,0 +1,58 @@
+/**
+ * Giuseppe Agent - Full Conversational Bug Fixer
+ *
+ * A natural language agent that handles bug fixing through conversation.
+ * No keywords, no intent detection - just natural dialogue with tools.
+ */
+import type { UserContext } from '../../mcp/UserContextCache';
+import type { BugReport } from './types';
+import type { BugMonitor } from './bug-monitor';
+export declare class GiuseppeAgent {
+    private userContext;
+    private monitor;
+    private appsBasePath;
+    private anthropic;
+    private conversations;
+    private bugContexts;
+    private files;
+    private git;
+    private lsp;
+    constructor(userContext: UserContext, monitor: BugMonitor, appsBasePath: string, apiKey?: string);
+    /**
+     * Handle a new bug - start the conversation
+     */
+    handleNewBug(bug: BugReport): Promise<void>;
+    /**
+     * Handle any message in the bug discussion
+     */
+    handleMessage(discussionId: string, message: string, senderName: string): Promise<void>;
+    /**
+     * Chat with the LLM - handles tool calls automatically
+     */
+    private chat;
+    /**
+     * Execute tool calls and return results
+     */
+    private executeToolCalls;
+    /**
+     * Execute a single tool
+     */
+    private executeTool;
+    /**
+     * Post message to discussion
+     */
+    private postMessage;
+    /**
+     * Build initial prompt with bug context
+     */
+    private buildInitialPrompt;
+    /**
+     * System prompt for natural conversation
+     */
+    private getSystemPrompt;
+    /**
+     * Tool definitions
+     */
+    private getTools;
+}
+//# sourceMappingURL=giuseppe-agent.d.ts.map

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

@@ -0,0 +1,467 @@
+"use strict";
+/**
+ * Giuseppe Agent - Full Conversational Bug Fixer
+ *
+ * A natural language agent that handles bug fixing through conversation.
+ * No keywords, no intent detection - just natural dialogue with tools.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiuseppeAgent = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const child_process_1 = require("child_process");
+const logger_1 = require("../../lib/logger");
+const giuseppe_files_1 = require("./giuseppe-files");
+const giuseppe_git_1 = require("./giuseppe-git");
+const giuseppe_lsp_1 = require("./giuseppe-lsp");
+const logger = (0, logger_1.createLogger)({ component: 'giuseppe-agent' });
+class GiuseppeAgent {
+    userContext;
+    monitor;
+    appsBasePath;
+    anthropic;
+    conversations = new Map();
+    bugContexts = new Map();
+    // Sub-modules
+    files;
+    git;
+    lsp;
+    constructor(userContext, monitor, appsBasePath, apiKey) {
+        this.userContext = userContext;
+        this.monitor = monitor;
+        this.appsBasePath = appsBasePath;
+        this.anthropic = new sdk_1.default({ apiKey: apiKey || process.env.ANTHROPIC_API_KEY });
+        this.files = new giuseppe_files_1.GiuseppeFiles(appsBasePath);
+        this.git = new giuseppe_git_1.GiuseppeGit();
+        this.lsp = new giuseppe_lsp_1.GiuseppeLsp();
+    }
+    /**
+     * Handle a new bug - start the conversation
+     */
+    async handleNewBug(bug) {
+        if (!bug.discussionId) {
+            logger.warn('Bug has no discussion, cannot start conversation', { bugId: bug.id });
+            return;
+        }
+        // Store bug context
+        this.bugContexts.set(bug.discussionId, { bug });
+        // Find the app
+        const app = await this.files.findAppFromBugTitle(bug.name);
+        if (app) {
+            this.bugContexts.get(bug.discussionId).app = app;
+        }
+        // Start fresh conversation
+        this.conversations.set(bug.discussionId, []);
+        // Send initial message with bug context
+        const initialPrompt = this.buildInitialPrompt(bug, app);
+        const response = await this.chat(bug.discussionId, initialPrompt, true);
+        // Post response to discussion
+        await this.postMessage(bug.discussionId, response);
+    }
+    /**
+     * Handle any message in the bug discussion
+     */
+    async handleMessage(discussionId, message, senderName) {
+        const context = this.bugContexts.get(discussionId);
+        if (!context) {
+            logger.debug('No bug context for discussion, ignoring', { discussionId });
+            return;
+        }
+        // Add user message to conversation
+        const userMessage = `${senderName}: ${message}`;
+        const response = await this.chat(discussionId, userMessage, false);
+        // Post response
+        await this.postMessage(discussionId, response);
+    }
+    /**
+     * Chat with the LLM - handles tool calls automatically
+     */
+    async chat(discussionId, userMessage, isSystemContext) {
+        const conversation = this.conversations.get(discussionId) || [];
+        // Add user message
+        conversation.push({ role: 'user', content: userMessage });
+        // Keep conversation manageable
+        if (conversation.length > 30) {
+            conversation.splice(0, conversation.length - 20);
+        }
+        try {
+            const response = await this.anthropic.messages.create({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                system: this.getSystemPrompt(),
+                messages: conversation,
+                tools: this.getTools(),
+            });
+            // Handle tool calls
+            let finalResponse = response;
+            while (finalResponse.stop_reason === 'tool_use') {
+                const toolResults = await this.executeToolCalls(finalResponse.content, discussionId);
+                // Add assistant response and tool results
+                conversation.push({ role: 'assistant', content: finalResponse.content });
+                conversation.push({ role: 'user', content: toolResults });
+                // Continue conversation
+                finalResponse = await this.anthropic.messages.create({
+                    model: 'claude-sonnet-4-20250514',
+                    max_tokens: 4096,
+                    system: this.getSystemPrompt(),
+                    messages: conversation,
+                    tools: this.getTools(),
+                });
+            }
+            // Extract text response
+            const textContent = finalResponse.content
+                .filter((block) => block.type === 'text')
+                .map(block => block.text)
+                .join('\n');
+            // Save final response
+            conversation.push({ role: 'assistant', content: finalResponse.content });
+            this.conversations.set(discussionId, conversation);
+            return textContent || "I'm not sure how to respond to that.";
+        }
+        catch (error) {
+            logger.error('Chat failed', { error, discussionId });
+            return "Sorry, I encountered an error. Please try again.";
+        }
+    }
+    /**
+     * Execute tool calls and return results
+     */
+    async executeToolCalls(content, discussionId) {
+        const toolUses = content.filter((block) => block.type === 'tool_use');
+        const results = [];
+        const context = this.bugContexts.get(discussionId);
+        for (const tool of toolUses) {
+            try {
+                const result = await this.executeTool(tool.name, tool.input, context);
+                results.push({
+                    type: 'tool_result',
+                    tool_use_id: tool.id,
+                    content: JSON.stringify(result),
+                });
+            }
+            catch (error) {
+                results.push({
+                    type: 'tool_result',
+                    tool_use_id: tool.id,
+                    content: JSON.stringify({ error: error.message }),
+                    is_error: true,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute a single tool
+     */
+    async executeTool(name, input, context) {
+        const projectPath = context?.app?.projectPath || input.projectPath;
+        switch (name) {
+            case 'check_git_status': {
+                try {
+                    const status = (0, child_process_1.execSync)('git status --short', { cwd: projectPath, encoding: 'utf-8' });
+                    const branch = (0, child_process_1.execSync)('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim();
+                    const behindAhead = (0, child_process_1.execSync)('git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null || echo "0 0"', { cwd: projectPath, encoding: 'utf-8' }).trim().split(/\s+/);
+                    return {
+                        branch,
+                        status: status || 'clean',
+                        behind: parseInt(behindAhead[1]) || 0,
+                        ahead: parseInt(behindAhead[0]) || 0
+                    };
+                }
+                catch (e) {
+                    return { error: e.message };
+                }
+            }
+            case 'git_pull': {
+                try {
+                    const output = (0, child_process_1.execSync)('git pull', { cwd: projectPath, encoding: 'utf-8' });
+                    return { success: true, output };
+                }
+                catch (e) {
+                    return { success: false, error: e.stderr || e.message };
+                }
+            }
+            case 'git_commit': {
+                try {
+                    (0, child_process_1.execSync)('git add -A', { cwd: projectPath });
+                    const msg = input.message || 'fix: bug fix by Giuseppe';
+                    (0, child_process_1.execSync)(`git commit -m "${msg.replace(/"/g, '\\"')}"`, { cwd: projectPath });
+                    const hash = (0, child_process_1.execSync)('git rev-parse --short HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
+                    return { success: true, hash };
+                }
+                catch (e) {
+                    return { success: false, error: e.stderr || e.stdout || e.message };
+                }
+            }
+            case 'git_push': {
+                const pushed = await this.git.push(projectPath);
+                return { success: pushed };
+            }
+            case 'git_revert': {
+                try {
+                    (0, child_process_1.execSync)('git checkout -- .', { cwd: projectPath });
+                    return { success: true };
+                }
+                catch (e) {
+                    return { success: false, error: e.message };
+                }
+            }
+            case 'list_files': {
+                const files = await this.files.scanSourceFiles(projectPath);
+                return { files: files.slice(0, 50), total: files.length };
+            }
+            case 'read_file': {
+                const content = await this.files.readFile(projectPath, input.path);
+                return content ? { content } : { error: 'File not found' };
+            }
+            case 'write_file': {
+                const success = await this.files.writeFile(projectPath, input.path, input.content);
+                return { success };
+            }
+            case 'run_build': {
+                const result = await this.lsp.validateFix(projectPath);
+                return result;
+            }
+            case 'analyze_code': {
+                const analysis = await this.lsp.analyzeProject(projectPath);
+                return {
+                    issues: analysis.issues.slice(0, 10),
+                    unusedProps: analysis.unusedProps.slice(0, 10),
+                    summary: analysis.summary
+                };
+            }
+            case 'publish_app': {
+                try {
+                    const appScaffold = await Promise.resolve().then(() => __importStar(require('../../mcp/tools/app-scaffold')));
+                    const tool = appScaffold.publishHailerAppTool;
+                    const result = await tool.execute({ projectDirectory: projectPath }, this.userContext);
+                    const text = result.content?.[0]?.text || '';
+                    return {
+                        success: !text.includes('❌'),
+                        message: text.substring(0, 500)
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: e.message };
+                }
+            }
+            case 'move_bug_phase': {
+                const phase = input.phase;
+                const bugId = context?.bug.id || input.bugId;
+                const moved = await this.monitor.moveBugToPhase(bugId, phase);
+                return { success: moved, phase };
+            }
+            default:
+                return { error: `Unknown tool: ${name}` };
+        }
+    }
+    /**
+     * Post message to discussion
+     */
+    async postMessage(discussionId, message) {
+        try {
+            await this.userContext.hailer.sendDiscussionMessage(discussionId, message);
+        }
+        catch (error) {
+            logger.error('Failed to post message', { discussionId, error });
+        }
+    }
+    /**
+     * Build initial prompt with bug context
+     */
+    buildInitialPrompt(bug, app) {
+        return `A new bug report has been filed. Here are the details:
+
+**Bug Report**
+- Title: ${bug.name}
+- Description: ${bug.description || 'No description provided'}
+${bug.stepsToReproduce ? `- Steps to reproduce: ${bug.stepsToReproduce}` : ''}
+${bug.expectedBehavior ? `- Expected: ${bug.expectedBehavior}` : ''}
+${bug.actualBehavior ? `- Actual: ${bug.actualBehavior}` : ''}
+
+**App Info**
+${app ? `- Found app: ${app.name} at ${app.projectPath}` : '- Could not find matching app project'}
+
+Please introduce yourself, analyze this bug report, and let the user know what you think. Ask any clarifying questions if needed.`;
+    }
+    /**
+     * System prompt for natural conversation
+     */
+    getSystemPrompt() {
+        return `You are Giuseppe, a friendly AI assistant specialized in fixing bugs in React/TypeScript applications.
+
+**Your personality:**
+- Friendly and conversational
+- Technical but explains things clearly
+- Proactive - you take initiative but ask before destructive actions
+- Honest about limitations and errors
+
+**Your workflow:**
+1. When a bug is reported, analyze it and share your understanding
+2. Ask clarifying questions if the bug is unclear
+3. Check git status before making changes
+4. If git is behind, pull first
+5. Read relevant files to understand the code
+6. Make fixes by writing to files
+7. Run the build to verify the fix works
+8. Commit the changes
+9. Ask the user if they want to publish to production
+10. Only publish when the user confirms
+
+**Important rules:**
+- ALWAYS ask before publishing to production
+- If the build fails, explain the error and try to fix it
+- If git has issues, explain and resolve them
+- Keep the user informed of what you're doing
+- Be conversational - this is a chat, not a report
+
+**Tools available:**
+- check_git_status: See branch, changes, sync status
+- git_pull: Pull latest from remote
+- git_commit: Stage and commit changes
+- git_push: Push to remote
+- git_revert: Discard uncommitted changes
+- list_files: See source files in the project
+- read_file: Read a file's contents
+- write_file: Write/update a file
+- run_build: Check if code compiles
+- analyze_code: LSP analysis for issues
+- publish_app: Deploy to Hailer (ASK FIRST!)
+- move_bug_phase: Update bug status (inProgress, fixed, closed, declined)
+
+Start by understanding the bug, then work through fixing it naturally.`;
+    }
+    /**
+     * Tool definitions
+     */
+    getTools() {
+        return [
+            {
+                name: 'check_git_status',
+                description: 'Check git status - branch, changes, sync with remote',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'git_pull',
+                description: 'Pull latest changes from remote',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'git_commit',
+                description: 'Stage all changes and commit',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        message: { type: 'string', description: 'Commit message' }
+                    },
+                    required: ['message']
+                }
+            },
+            {
+                name: 'git_push',
+                description: 'Push commits to remote',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'git_revert',
+                description: 'Discard all uncommitted changes',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'list_files',
+                description: 'List source files in the project',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'read_file',
+                description: 'Read a source file',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Relative path to file' }
+                    },
+                    required: ['path']
+                }
+            },
+            {
+                name: 'write_file',
+                description: 'Write content to a file',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Relative path to file' },
+                        content: { type: 'string', description: 'New file content' }
+                    },
+                    required: ['path', 'content']
+                }
+            },
+            {
+                name: 'run_build',
+                description: 'Run TypeScript build to check for errors',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'analyze_code',
+                description: 'Run LSP analysis to find issues',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'publish_app',
+                description: 'Publish app to Hailer production - ALWAYS ASK USER FIRST',
+                input_schema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'move_bug_phase',
+                description: 'Move bug to a different phase',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        phase: {
+                            type: 'string',
+                            enum: ['inProgress', 'fixed', 'closed', 'declined'],
+                            description: 'Target phase'
+                        }
+                    },
+                    required: ['phase']
+                }
+            }
+        ];
+    }
+}
+exports.GiuseppeAgent = GiuseppeAgent;
+//# sourceMappingURL=giuseppe-agent.js.map

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

@@ -37,12 +37,36 @@ export declare class GiuseppeAI {
      * 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[]>): Promise<FixPlan | null>;
+    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
      */