@hailer/mcp 0.1.11 → 0.1.13

package/.claude/settings.json

@@ -1,4 +1,7 @@
 {
+  "env": {
+    "ENABLE_LSP_TOOL": "1"
+  },
   "permissions": {
     "deny": [
       "Read(./.env.local)",
@@ -114,5 +117,14 @@
         ]
       }
     ]
+  },
+  "enabledPlugins": {},
+  "extraKnownMarketplaces": {
+    "hailer-mcp-marketplace": {
+      "source": {
+        "source": "git",
+        "url": "git@gitlab.com:hailer-repos/hailer-mcp-marketplace.git"
+      }
+    }
   }
 }

package/CLAUDE.md

@@ -4,6 +4,27 @@ MCP tools for Hailer workspaces: workflows, activities, insights, and apps.
 
 ---
 
+<critical-rules>
+## LSP FIRST - MANDATORY FOR ALL TS/JS FILES
+
+**BEFORE using Read, Grep, or any text search on TypeScript/JavaScript files, USE LSP:**
+
+| Task | Use LSP | NOT |
+|------|---------|-----|
+| Find enums/classes/functions | `documentSymbol` | Read file |
+| Find where something is defined | `goToDefinition` | grep |
+| Find all usages | `findReferences` | grep |
+| Get type info | `hover` | Read file |
+
+```
+LSP(operation="documentSymbol", filePath="file.ts", line=1, character=1)
+```
+
+**ONLY use Read for:** Non-code files (JSON, MD, config) or when LSP is unavailable.
+</critical-rules>
+
+---
+
 <identity>
 YOU ARE THE ORCHESTRATOR.
 
@@ -110,6 +131,14 @@ PROTECTED (hooks confirm): npm run push, *-push, *-sync
 SAFE: npm run pull, npm run generate
 </safety>
 
+<lsp-setup>
+**New users:** Install LSP plugin for TypeScript support:
+1. `/plugin install typescript-lsp@hailer-mcp-marketplace`
+2. Restart: `claude -c`
+
+`ENABLE_LSP_TOOL` is auto-set via `.claude/settings.json`.
+</lsp-setup>
+
 ---
 
 <agent-structure>
@@ -164,6 +193,13 @@ Community agents are shared via the Hailer Agent Marketplace (separate git repo)
 No marketplace agents installed.
 
 
+
+
+
+
+
+
+
 **Use plugin agents:**
 ```
 Task(subagent_type="plugin:agent-name", prompt="...", model="haiku|sonnet")
@@ -185,7 +221,7 @@ When user asks to install plugins or set up the marketplace:
 
 2. Tell user: "Restart Claude Code to load the plugin. Use `claude -c` to keep your conversation context."
 
-Available plugins: `permissions-handler`, `voice-notifications`
+Available plugins: `permissions-handler`, `voice-notifications`, `typescript-lsp`
 
 After restart, sync hook updates this file automatically with installed agents.
 

package/dist/app.js

@@ -9,6 +9,7 @@ const user_1 = require("./mcp/tools/user");
 const workflow_1 = require("./mcp/tools/workflow");
 const insight_1 = require("./mcp/tools/insight");
 const app_1 = require("./mcp/tools/app");
+const bot_config_1 = require("./mcp/tools/bot-config");
 const core = new core_1.Core();
 console.log('Registering tools...');
 console.log(`Nuclear tools ${config_1.environment.ENABLE_NUCLEAR_TOOLS ? 'ENABLED' : 'DISABLED'} (set ENABLE_NUCLEAR_TOOLS=true in .env.local to enable)`);
@@ -72,6 +73,10 @@ core.addTool(app_1.getProductManifestTool);
 // Marketplace app tools
 core.addTool(app_1.publishAppTool);
 core.addTool(app_1.installMarketplaceAppTool);
+// Bot configuration tools
+core.addTool(bot_config_1.listBotsConfigTool);
+core.addTool(bot_config_1.enableBotTool);
+core.addTool(bot_config_1.disableBotTool);
 console.log('All tools registered successfully!');
 // Start the application
 core.start().catch((error) => {

package/dist/client/agents/base.d.ts

@@ -133,6 +133,11 @@ export declare class ChatAgentDaemon {
      * MUST be overridden in subclasses
      */
     protected getSystemPrompt(): string;
+    /**
+     * Get tools for LLM calls
+     * Override in subclass to add custom tools (like trigger_giuseppe_retry)
+     */
+    protected getTools(): Anthropic.Tool[];
     /**
      * Get tool whitelist for this agent
      * Override in subclass to limit which tools are available

package/dist/client/agents/base.js

@@ -290,7 +290,7 @@ class ChatAgentDaemon {
                 max_tokens: 2000,
                 system: this.getSystemPrompt(),
                 messages: conversation,
-                tools: this.minimalTools,
+                tools: this.getTools(),
             });
             // Track token usage in the activity session
             if (response.usage) {
@@ -395,7 +395,7 @@ ${message.content}
             max_tokens: 2000,
             system: this.getSystemPrompt(),
             messages: conversation,
-            tools: this.minimalTools,
+            tools: this.getTools(),
         });
         // Track token usage in session
         if (session && response.usage) {
@@ -586,6 +586,13 @@ ${message.content}
     getSystemPrompt() {
         throw new Error("getSystemPrompt() must be implemented by subclass");
     }
+    /**
+     * Get tools for LLM calls
+     * Override in subclass to add custom tools (like trigger_giuseppe_retry)
+     */
+    getTools() {
+        return this.minimalTools;
+    }
     /**
      * Get tool whitelist for this agent
      * Override in subclass to limit which tools are available

package/dist/client/agents/definitions.js

@@ -21,6 +21,91 @@ exports.getSpecialistKeys = getSpecialistKeys;
  * Key is the specialist identifier used internally
  */
 exports.SPECIALISTS = {
+    giuseppe: {
+        name: "Giuseppe",
+        botEmail: "", // Set from config at runtime (uses same bot as orchestrator for now)
+        expertise: [
+            "bug fixing",
+            "app debugging",
+            "React/TypeScript fixes",
+            "Hailer app development",
+            "automated code repair",
+        ],
+        triggerPatterns: [
+            // Bug reports
+            /bug\s+(report|in|with|found)/i,
+            /report\s+(a\s+)?bug/i,
+            /found\s+(a\s+)?bug/i,
+            /there('s|\s+is)\s+(a\s+)?bug/i,
+            // Fix requests
+            /fix\s+(the|this|my)\s+(bug|issue|problem|app)/i,
+            /can\s+you\s+fix/i,
+            /please\s+fix/i,
+            // App issues
+            /app\s+(is\s+)?(broken|not\s+working|crashing|laggy)/i,
+            /(broken|crashing|laggy)\s+app/i,
+            // Giuseppe mentions
+            /giuseppe/i,
+            /auto.?fix/i,
+        ],
+        triggerKeywords: [
+            "bug",
+            "fix",
+            "broken",
+            "issue",
+            "error",
+            "crash",
+            "laggy",
+            "not working",
+            "giuseppe",
+        ],
+        systemPrompt: `<identity>
+You are Giuseppe - the autonomous bug fixing specialist.
+You were designed to automatically detect, analyze, and fix bugs in Hailer apps.
+</identity>
+
+<capabilities>
+**Automatic Bug Detection:**
+- I monitor the "Bug Reports" workflow for new bugs
+- When a bug is detected, I automatically:
+  1. Find the app project
+  2. Analyze the code
+  3. Generate a fix using Claude
+  4. Apply and test the fix
+  5. Ask for approval before publishing
+
+**Bug Report Workflow:**
+- Users create bug reports in the "Bug Reports" workflow
+- I pick them up automatically and start fixing
+- After the fix is ready, I ask the user to test
+- User replies "approved" → I publish to production
+- User replies "denied" → I ask what's wrong and retry
+
+**What I Can Fix:**
+- React/TypeScript compilation errors
+- Hailer app SDK issues
+- UI bugs and layout problems
+- State management issues
+- API integration bugs
+</capabilities>
+
+<how_to_use>
+To report a bug for me to fix:
+1. Create a new activity in the "Bug Reports" workflow
+2. Set the title to include the app name (e.g., "Bug Report - My App")
+3. Describe the bug in detail
+4. I'll automatically pick it up and start working on it!
+
+Or just tell HAL about a bug and ask to create a bug report.
+</how_to_use>
+
+<response_format>
+When asked about bugs or my capabilities:
+- Explain what I can do
+- Offer to create a bug report if they describe a bug
+- Tell them to check the Bug Reports workflow for status
+</response_format>`,
+    },
     hailerExpert: {
         name: "Hailer Expert",
         botEmail: "", // Set from config at runtime

package/dist/client/agents/orchestrator.d.ts

@@ -33,6 +33,11 @@ export declare class OrchestratorDaemon extends ChatAgentDaemon {
     private lastKnownActivityTime;
     private static CONTEXT_MEMORY_TIMEOUT;
     constructor(config: OrchestratorDaemonConfig);
+    /**
+     * Trigger HAL to respond in a discussion with specific context
+     * Used when bug monitor needs HAL to naturally inform users about Giuseppe being disabled
+     */
+    respondWithContext(discussionId: string, activityId: string, contextMessage: string): Promise<void>;
     /**
      * Override agent name for Agent Directory
      * Uses the actual Hailer user name from BotClient (set in workspace)
@@ -94,6 +99,22 @@ export declare class OrchestratorDaemon extends ChatAgentDaemon {
      * Invite a specialist to a discussion
      */
     private inviteSpecialist;
+    /**
+     * Override getTools to include Giuseppe retry tool when there's a pending fix
+     */
+    protected getTools(): Anthropic.Tool[];
+    /**
+     * Get tools list with Giuseppe retry tool added
+     */
+    private getToolsWithGiuseppeRetry;
+    /**
+     * Get pending fix context for a discussion (if any)
+     */
+    private getPendingFixContext;
+    /**
+     * Get pending classification context for a discussion (if any)
+     */
+    private getPendingClassificationContext;
     /**
      * Override system prompt to include orchestrator capabilities
      */

package/dist/client/agents/orchestrator.js

@@ -17,6 +17,8 @@ exports.OrchestratorDaemon = void 0;
 const base_1 = require("./base");
 const definitions_1 = require("./definitions");
 const logger_1 = require("../../lib/logger");
+const pending_fix_registry_1 = require("../../modules/bug-reports/pending-fix-registry");
+const pending_classification_registry_1 = require("../../modules/bug-reports/pending-classification-registry");
 class OrchestratorDaemon extends base_1.ChatAgentDaemon {
     orchestratorLogger;
     specialists = new Map();
@@ -47,6 +49,41 @@ class OrchestratorDaemon extends base_1.ChatAgentDaemon {
             this.specialistUserIds = config.specialistUserIds;
         }
     }
+    /**
+     * Trigger HAL to respond in a discussion with specific context
+     * Used when bug monitor needs HAL to naturally inform users about Giuseppe being disabled
+     */
+    async respondWithContext(discussionId, activityId, contextMessage) {
+        this.orchestratorLogger.info('Triggering contextual response', { discussionId, activityId });
+        try {
+            // Join the discussion first using MCP tool
+            await this.callMcpTool("join_discussion", { activityId });
+            // Get workspace ID from bot client cache
+            const workspaceId = this.config.botClient.workspaceCache?.currentWorkspace?._id || '';
+            // Create a synthetic incoming message with the context
+            const syntheticMessage = {
+                id: `synthetic-${Date.now()}`,
+                discussionId,
+                linkedActivityId: activityId,
+                workspaceId,
+                content: contextMessage,
+                senderName: 'System',
+                senderId: 'system',
+                timestamp: Date.now(),
+                priority: 'high',
+                priorityReason: 'system_notification',
+                isReplyToBot: false,
+                isMention: false,
+                isDirectMessage: false,
+            };
+            // Process through normal LLM pipeline
+            // This will make HAL respond naturally with the context
+            await this['processMessage'](syntheticMessage);
+        }
+        catch (error) {
+            this.orchestratorLogger.error('Failed to respond with context', { error });
+        }
+    }
     // ===== AGENT DIRECTORY OVERRIDES =====
     /**
      * Override agent name for Agent Directory
@@ -161,6 +198,110 @@ class OrchestratorDaemon extends base_1.ChatAgentDaemon {
     async executeToolsAndContinue(toolUseBlocks, originalMessage) {
         // Reset failure flag before executing tools
         this.lastToolsFailed = false;
+        // Handle local tools (not sent to MCP)
+        const localToolResults = [];
+        const mcpToolBlocks = [];
+        for (const toolBlock of toolUseBlocks) {
+            if (toolBlock.name === 'trigger_giuseppe_retry') {
+                // Handle locally - trigger Giuseppe retry
+                const input = toolBlock.input;
+                const explanation = input.explanation || '';
+                const discussionId = originalMessage.discussionId;
+                const pendingFix = pending_fix_registry_1.pendingFixRegistry.getPendingFix(discussionId);
+                if (!pendingFix) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending fix found for this discussion. The fix may have already been approved or cancelled.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    // Trigger the retry
+                    const success = await pending_fix_registry_1.pendingFixRegistry.triggerRetry(discussionId, explanation);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? `✅ Triggered Giuseppe retry with explanation: "${explanation.substring(0, 100)}...". Giuseppe will analyze and apply a new fix.`
+                            : '❌ Failed to trigger retry. Giuseppe may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'confirm_bug_fix') {
+                // Handle locally - trigger Giuseppe fix confirmation
+                const discussionId = originalMessage.discussionId;
+                const hasPending = pending_classification_registry_1.pendingClassificationRegistry.has(discussionId);
+                if (!hasPending) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending classification found for this discussion. Giuseppe may have already processed it.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    const success = await pending_classification_registry_1.pendingClassificationRegistry.triggerFixIt(discussionId);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? '✅ Triggered Giuseppe to proceed with bug fix.'
+                            : '❌ Failed to trigger fix. Giuseppe may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else if (toolBlock.name === 'decline_bug_report') {
+                // Handle locally - trigger Giuseppe decline
+                const discussionId = originalMessage.discussionId;
+                const hasPending = pending_classification_registry_1.pendingClassificationRegistry.has(discussionId);
+                if (!hasPending) {
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: 'No pending classification found for this discussion. Giuseppe may have already processed it.',
+                        is_error: true,
+                    });
+                }
+                else {
+                    const success = await pending_classification_registry_1.pendingClassificationRegistry.triggerNotABug(discussionId);
+                    localToolResults.push({
+                        type: 'tool_result',
+                        tool_use_id: toolBlock.id,
+                        content: success
+                            ? '✅ Marked as not a bug. Report moved to Declined.'
+                            : '❌ Failed to decline. Giuseppe may not be available.',
+                        is_error: !success,
+                    });
+                }
+            }
+            else {
+                // Send to MCP
+                mcpToolBlocks.push(toolBlock);
+            }
+        }
+        // If we handled all tools locally, skip MCP execution
+        if (mcpToolBlocks.length === 0 && localToolResults.length > 0) {
+            const conversation = this.conversationManager.getConversation(originalMessage.discussionId);
+            conversation.push({
+                role: 'user',
+                content: localToolResults,
+            });
+            // Continue with LLM
+            const response = await this.client.messages.create({
+                model: this.config.model || 'claude-haiku-4-5-20251001',
+                max_tokens: 2000,
+                system: this.getSystemPrompt(),
+                messages: conversation,
+                tools: this.getToolsWithGiuseppeRetry(),
+            });
+            await this.handleLlmResponse(response, originalMessage);
+            return;
+        }
+        // If we have local results, add them to be processed together with MCP results
+        // (for now, just continue with original flow for MCP tools)
         // Get current activity session
         const sessionKey = this.currentLinkedActivityId || this.currentDiscussionId || "default";
         const session = this.sessionLogger.getSession(sessionKey);
@@ -319,6 +460,114 @@ class OrchestratorDaemon extends base_1.ChatAgentDaemon {
             return false;
         }
     }
+    /**
+     * Override getTools to include Giuseppe retry tool when there's a pending fix
+     */
+    getTools() {
+        // Always include the Giuseppe retry tool so LLM knows about it
+        return this.getToolsWithGiuseppeRetry();
+    }
+    /**
+     * Get tools list with Giuseppe retry tool added
+     */
+    getToolsWithGiuseppeRetry() {
+        const giuseppeRetryTool = {
+            name: 'trigger_giuseppe_retry',
+            description: 'Trigger Giuseppe to retry fixing a bug with new explanation. Use this after gathering enough info about what went wrong with the previous fix. Only works in discussions with a pending bug fix.',
+            input_schema: {
+                type: 'object',
+                properties: {
+                    explanation: {
+                        type: 'string',
+                        description: 'Clear explanation of what is wrong with the current fix and what the expected behavior should be. Include: (1) what is broken, (2) expected vs actual behavior, (3) any specific details the user mentioned.',
+                    },
+                },
+                required: ['explanation'],
+            },
+        };
+        const confirmBugFixTool = {
+            name: 'confirm_bug_fix',
+            description: 'Confirm that a bug report should be fixed. Use when user indicates they want the bug fixed (variations of "fix it", "yes fix", "please fix", etc.). Only works in discussions with a pending classification.',
+            input_schema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        };
+        const declineBugReportTool = {
+            name: 'decline_bug_report',
+            description: 'Decline a bug report as not actually a bug. Use when user indicates it\'s not a bug (variations of "not a bug", "feature request", "not actually broken", etc.). Only works in discussions with a pending classification.',
+            input_schema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        };
+        return [...this.minimalTools, giuseppeRetryTool, confirmBugFixTool, declineBugReportTool];
+    }
+    /**
+     * Get pending fix context for a discussion (if any)
+     */
+    getPendingFixContext(discussionId) {
+        const pendingFix = pending_fix_registry_1.pendingFixRegistry.getPendingFix(discussionId);
+        if (!pendingFix) {
+            return '';
+        }
+        return `
+<pending_bug_fix>
+**IMPORTANT: This discussion has a pending bug fix from Giuseppe!**
+
+- Bug ID: ${pendingFix.bugId}
+- State: ${pendingFix.state}
+- Fix Summary: ${pendingFix.fixSummary}
+
+**Your role:**
+- If user says "approved" → Giuseppe handles it automatically (you do nothing)
+- If user expresses ANY dissatisfaction (denied, not working, still broken, etc.):
+  1. Ask what's wrong (if not clear)
+  2. Gather: what's broken + expected behavior
+  3. Use trigger_giuseppe_retry tool with the explanation
+
+**Remember:** You're gathering info for Giuseppe. Be concise, ask ONE question at a time.
+</pending_bug_fix>
+`;
+    }
+    /**
+     * Get pending classification context for a discussion (if any)
+     */
+    getPendingClassificationContext(discussionId) {
+        const pending = pending_classification_registry_1.pendingClassificationRegistry.getPendingClassification(discussionId);
+        if (!pending) {
+            return '';
+        }
+        const classificationLabel = pending.classification === 'bug' ? 'Bug' :
+            pending.classification === 'feature_request' ? 'Feature Request' : 'Unclear';
+        return `
+<pending_classification>
+**IMPORTANT: Giuseppe just classified this report and is waiting for user decision!**
+
+- Bug: ${pending.bugName}
+- App: ${pending.appName || pending.appId || 'Unknown'}
+- Classification: ${classificationLabel}
+- Reason: ${pending.reason}
+
+**User options:**
+- "fix it" → Giuseppe will proceed to fix the bug
+- "not a bug" → Report will be moved to Declined
+
+**Your role - Use tools for user intent:**
+- User wants to fix the bug → Call confirm_bug_fix tool
+- User says it's not a bug / feature request → Call decline_bug_report tool
+- User has questions → Help explain the classification
+
+**Detecting intent (use tools, don't wait for exact words):**
+- "fix it", "yes fix", "go ahead", "please fix", "fix this" → confirm_bug_fix
+- "not a bug", "feature request", "not broken", "close it", "decline" → decline_bug_report
+
+**Remember:** Use the tools to trigger actions. Don't tell user to type magic words.
+</pending_classification>
+`;
+    }
     /**
      * Override system prompt to include orchestrator capabilities
      */
@@ -447,6 +696,45 @@ Use 'fieldId' not 'id' for the field identifier.
 </after_invite>
 </specialists>
 
+<giuseppe_autonomous>
+**Giuseppe - Autonomous Bug Fixer**
+
+Giuseppe is SPECIAL - he works AUTONOMOUSLY, not through invites!
+
+**How Giuseppe works:**
+1. Users create a bug report in the "Bug Reports" workflow
+2. Giuseppe automatically detects new bugs and starts fixing them
+3. He analyzes the code, generates a fix, tests it
+4. He asks the user to verify with "approved" or "denied"
+5. On "approved" → Giuseppe publishes to production automatically
+6. On "denied" or complaint → YOU (HAL) gather info, then trigger Giuseppe retry
+
+**YOUR ROLE IN BUG FIX DENIALS:**
+When a discussion has a pending bug fix and the user expresses dissatisfaction:
+1. YOU handle the conversation - ask what's wrong, what behavior they expected
+2. Gather enough context: what's broken, expected vs actual behavior
+3. Once you have clear info, use trigger_giuseppe_retry tool to pass the explanation
+4. Giuseppe will receive your gathered info and retry the fix
+
+**Detecting denial signals:**
+- "denied", "not working", "still broken", "wrong", "doesn't work"
+- Any complaint about the fix behavior
+- User describing unexpected behavior
+
+**Gathering info (ask ONE question at a time):**
+- "What behavior are you seeing?"
+- "What did you expect to happen instead?"
+- "Is the issue consistent or intermittent?"
+
+**When to trigger retry:**
+Once you have: (1) what's wrong, (2) expected behavior → trigger the retry
+
+**When someone mentions bugs (NEW bugs):**
+- Tell them to create a bug report in "Bug Reports" workflow
+- Explain Giuseppe will pick it up automatically
+- Offer to help create the bug report for them
+</giuseppe_autonomous>
+
 <your_tools>
 You have access to basic MCP tools for simple operations:
 - list_workflows, list_workflow_phases, get_workflow_schema
@@ -532,7 +820,10 @@ Only use <respond> when you have the FINAL answer to share.
 - When inviting specialists, explain to the user what's happening
 - After specialist responds, summarize for the user if needed
 - **Complete work before responding** - Never say "I'm going to do X", just DO X with tool calls
-</rules>`;
+</rules>
+
+${this.currentDiscussionId ? this.getPendingFixContext(this.currentDiscussionId) : ''}
+${this.currentDiscussionId ? this.getPendingClassificationContext(this.currentDiscussionId) : ''}`;
     }
     /**
      * Override response handling to detect specialist invitations

package/dist/client/bot-entrypoint.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bot Entry Point - Single workspace, single bot
+ *
+ * Uses API key authentication via UserContextCache (which resolves to email/password internally)
+ */
+export {};
+//# sourceMappingURL=bot-entrypoint.d.ts.map