@hailer/mcp 0.1.15 → 0.1.16

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

@@ -0,0 +1,617 @@
+"use strict";
+/**
+ * Giuseppe Daemon - LLM-Driven Bug Fixer Agent
+ *
+ * A fully autonomous AI agent for fixing bugs in Hailer apps.
+ * Unlike the old GiuseppeBot with hardcoded magic words, this daemon:
+ * - Understands natural language (no "fix it" / "approved" keywords)
+ * - Reasons about problems (git conflicts, build failures)
+ * - Decides when to ask for approval vs proceed
+ * - Has tools for all bug-fixing operations
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiuseppeDaemon = void 0;
+const base_1 = require("../../client/agents/base");
+const logger_1 = require("../../lib/logger");
+const discussion_lock_1 = require("../../lib/discussion-lock");
+// Giuseppe-specific tools
+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");
+class GiuseppeDaemon extends base_1.ChatAgentDaemon {
+    giuseppeLogger;
+    bugMonitor;
+    userContext;
+    appsBasePath;
+    // Sub-modules for operations
+    ai;
+    git;
+    files;
+    lsp;
+    // Track which discussions are bug reports
+    bugDiscussions = new Map();
+    constructor(config) {
+        super(config);
+        this.bugMonitor = config.bugMonitor;
+        this.userContext = config.userContext;
+        this.appsBasePath = config.appsBasePath;
+        this.giuseppeLogger = (0, logger_1.createLogger)({
+            component: "GiuseppeDaemon",
+            botId: config.botClient.userId,
+        });
+        // Initialize sub-modules
+        this.ai = new giuseppe_ai_1.GiuseppeAI();
+        this.git = new giuseppe_git_1.GiuseppeGit();
+        this.files = new giuseppe_files_1.GiuseppeFiles(this.appsBasePath);
+        this.lsp = new giuseppe_lsp_1.GiuseppeLsp();
+    }
+    /**
+     * Register a bug discussion so Giuseppe knows to respond to it
+     */
+    registerBugDiscussion(discussionId, bugId, bugName, workflowId) {
+        this.bugDiscussions.set(discussionId, { bugId, bugName, workflowId });
+        // Acquire lock to prevent HAL from responding
+        (0, discussion_lock_1.acquireDiscussionLock)(discussionId, 'giuseppe', 30 * 60 * 1000); // 30 min lock
+        this.giuseppeLogger.info("Registered bug discussion", { discussionId, bugId, bugName });
+    }
+    /**
+     * Unregister a bug discussion (bug resolved/closed)
+     */
+    unregisterBugDiscussion(discussionId) {
+        this.bugDiscussions.delete(discussionId);
+        this.giuseppeLogger.info("Unregistered bug discussion", { discussionId });
+    }
+    // ===== OVERRIDES =====
+    getAgentName() {
+        return { firstName: "Giuseppe", lastName: "Bot" };
+    }
+    getAgentDescription() {
+        return "Giuseppe - Autonomous bug fixer for Hailer apps. I analyze bugs, write fixes, test them, and deploy to production.";
+    }
+    getPositionDetails() {
+        return {
+            name: "Bug Fixer",
+            purpose: "Autonomously fix bugs in Hailer apps by analyzing code, generating fixes, and deploying them.",
+            personaTone: "Technical but friendly. Explains what I'm doing and asks for approval on important actions.",
+            coreCapabilities: `- Analyze bug reports and understand the issue
+- Read and understand React/TypeScript code
+- Generate fixes using Claude AI
+- Run builds and catch errors
+- Handle git operations (commit, push, pull)
+- Publish apps to production
+- Move bugs through workflow phases`,
+            boundaries: `- Always ask before publishing to production
+- Revert changes if builds fail
+- Never commit secrets or credentials
+- Explain my reasoning before making changes`,
+        };
+    }
+    /**
+     * Only respond to messages in registered bug discussions
+     */
+    async extractIncomingMessage(signal) {
+        const message = await super.extractIncomingMessage(signal);
+        if (!message)
+            return null;
+        // Only respond to bug discussions
+        const bugInfo = this.bugDiscussions.get(message.discussionId);
+        if (!bugInfo) {
+            return null; // Not a bug discussion, ignore
+        }
+        // All bug discussion messages are high priority for Giuseppe
+        message.priority = "high";
+        message.priorityReason = `Bug discussion: ${bugInfo.bugName}`;
+        this.giuseppeLogger.info("Processing bug discussion message", {
+            discussionId: message.discussionId,
+            bugId: bugInfo.bugId,
+            from: message.senderName,
+            preview: message.content.substring(0, 50),
+        });
+        return message;
+    }
+    /**
+     * Giuseppe's tools for bug fixing
+     */
+    getToolWhitelist() {
+        return [
+            // Standard Hailer tools
+            "list_activities",
+            "show_activity_by_id",
+            "update_activity",
+            "add_discussion_message",
+            "fetch_discussion_messages",
+            "get_activity_from_discussion",
+            // Giuseppe will use custom tools defined in getTools()
+        ];
+    }
+    /**
+     * Custom tools for bug fixing operations
+     */
+    getTools() {
+        const baseTools = super.getTools();
+        const giuseppeTools = [
+            {
+                name: "find_app_project",
+                description: "Find the app project directory from a bug report title or app name. Returns the project path if found.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        bugTitle: {
+                            type: "string",
+                            description: "The bug report title (e.g., 'Bug Report - Lineup Manager')"
+                        },
+                        appName: {
+                            type: "string",
+                            description: "Direct app name to search for (optional)"
+                        }
+                    },
+                    required: ["bugTitle"]
+                }
+            },
+            {
+                name: "analyze_code",
+                description: "Analyze source files to understand the bug. Uses LSP for accurate code intelligence.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        bugDescription: {
+                            type: "string",
+                            description: "Description of the bug to analyze"
+                        }
+                    },
+                    required: ["projectPath", "bugDescription"]
+                }
+            },
+            {
+                name: "generate_fix",
+                description: "Generate a code fix for the bug. Returns the fix plan with file changes.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        bugDescription: {
+                            type: "string",
+                            description: "Full description of the bug"
+                        },
+                        relevantFiles: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "List of relevant source files to examine"
+                        }
+                    },
+                    required: ["projectPath", "bugDescription"]
+                }
+            },
+            {
+                name: "apply_fix",
+                description: "Apply code changes to fix the bug. Writes the new code to files.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        changes: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    filePath: { type: "string" },
+                                    newContent: { type: "string" }
+                                }
+                            },
+                            description: "Array of file changes to apply"
+                        }
+                    },
+                    required: ["projectPath", "changes"]
+                }
+            },
+            {
+                name: "run_build",
+                description: "Run the build to check if the fix compiles without errors.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "git_status",
+                description: "Check git status - shows branch, pending changes, and sync state with remote.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "git_pull",
+                description: "Pull latest changes from remote. Use when local is behind remote.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "git_commit",
+                description: "Stage and commit all changes with a message.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        message: {
+                            type: "string",
+                            description: "Commit message"
+                        }
+                    },
+                    required: ["projectPath", "message"]
+                }
+            },
+            {
+                name: "git_push",
+                description: "Push commits to remote repository.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "git_revert",
+                description: "Revert uncommitted changes in specified files.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        files: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Files to revert (empty = all files)"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "publish_app",
+                description: "Publish the app to Hailer production. IMPORTANT: Ask user for approval before using this.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        }
+                    },
+                    required: ["projectPath"]
+                }
+            },
+            {
+                name: "move_bug_to_phase",
+                description: "Move the bug to a different workflow phase (inProgress, fixed, closed, declined).",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        bugId: {
+                            type: "string",
+                            description: "Bug activity ID"
+                        },
+                        phase: {
+                            type: "string",
+                            enum: ["inProgress", "fixed", "closed", "declined"],
+                            description: "Target phase"
+                        }
+                    },
+                    required: ["bugId", "phase"]
+                }
+            },
+            {
+                name: "read_file",
+                description: "Read a source file to understand the code.",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the app project"
+                        },
+                        filePath: {
+                            type: "string",
+                            description: "Relative path to the file"
+                        }
+                    },
+                    required: ["projectPath", "filePath"]
+                }
+            }
+        ];
+        return [...baseTools, ...giuseppeTools];
+    }
+    /**
+     * Execute Giuseppe's custom tools
+     */
+    async executeCustomTool(name, rawInput) {
+        // Cast to generic record for property access
+        const input = rawInput;
+        try {
+            switch (name) {
+                case "find_app_project": {
+                    const app = await this.files.findAppFromBugTitle(input.bugTitle);
+                    if (app) {
+                        return { success: true, result: { found: true, ...app } };
+                    }
+                    return { success: true, result: { found: false, message: "App project not found" } };
+                }
+                case "analyze_code": {
+                    const projectPath = input.projectPath;
+                    const bugDescription = input.bugDescription;
+                    // Get source files
+                    const allFiles = await this.files.scanSourceFiles(projectPath);
+                    // Extract keywords for targeted LSP
+                    const keywords = bugDescription.toLowerCase()
+                        .replace(/[^\w\s]/g, ' ')
+                        .split(/\s+/)
+                        .filter(w => w.length > 3);
+                    // Run LSP analysis
+                    const analysis = await this.lsp.analyzeProject(projectPath);
+                    return {
+                        success: true,
+                        result: {
+                            fileCount: allFiles.length,
+                            files: allFiles.slice(0, 20), // First 20 files
+                            lspIssues: analysis.issues.slice(0, 10),
+                            unusedProps: analysis.unusedProps.slice(0, 10),
+                            keywords
+                        }
+                    };
+                }
+                case "generate_fix": {
+                    const projectPath = input.projectPath;
+                    const bugDescription = input.bugDescription;
+                    const relevantFiles = input.relevantFiles || [];
+                    // Use AI to generate fix (it reads files internally)
+                    const fixPlan = await this.ai.analyzeAndPlanFix({
+                        id: 'temp',
+                        name: 'Bug Fix',
+                        description: bugDescription,
+                        workflowId: '',
+                        phaseId: '',
+                        createdAt: new Date().toISOString()
+                    }, { name: 'app', projectPath }, relevantFiles, async (paths) => this.files.readSelectedFiles(projectPath, paths));
+                    return { success: true, result: fixPlan };
+                }
+                case "apply_fix": {
+                    const projectPath = input.projectPath;
+                    const changes = input.changes;
+                    for (const change of changes) {
+                        await this.files.writeFile(projectPath, change.filePath, change.newContent);
+                    }
+                    return { success: true, result: { filesWritten: changes.length } };
+                }
+                case "run_build": {
+                    const projectPath = input.projectPath;
+                    const result = await this.lsp.validateFix(projectPath);
+                    return { success: result.valid, result };
+                }
+                case "git_status": {
+                    const projectPath = input.projectPath;
+                    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                    try {
+                        const status = execSync('git status', { cwd: projectPath, encoding: 'utf-8' });
+                        const branch = execSync('git branch --show-current', { cwd: projectPath, encoding: 'utf-8' }).trim();
+                        return { success: true, result: { branch, status } };
+                    }
+                    catch (error) {
+                        return { success: false, result: { error: error.message } };
+                    }
+                }
+                case "git_pull": {
+                    const projectPath = input.projectPath;
+                    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                    try {
+                        const output = execSync('git pull', { cwd: projectPath, encoding: 'utf-8' });
+                        return { success: true, result: { output } };
+                    }
+                    catch (error) {
+                        return { success: false, result: { error: error.stderr || error.message } };
+                    }
+                }
+                case "git_commit": {
+                    const projectPath = input.projectPath;
+                    const message = input.message;
+                    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                    try {
+                        execSync('git add -A', { cwd: projectPath });
+                        execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: projectPath });
+                        const hash = execSync('git rev-parse --short HEAD', { cwd: projectPath, encoding: 'utf-8' }).trim();
+                        return { success: true, result: { hash, message } };
+                    }
+                    catch (error) {
+                        return { success: false, result: { error: error.stderr || error.stdout || error.message } };
+                    }
+                }
+                case "git_push": {
+                    const projectPath = input.projectPath;
+                    const pushed = await this.git.push(projectPath);
+                    return { success: pushed, result: { pushed } };
+                }
+                case "git_revert": {
+                    const projectPath = input.projectPath;
+                    const files = input.files || [];
+                    const app = { name: 'app', projectPath };
+                    await this.git.revertChanges(app, files);
+                    return { success: true, result: { reverted: files.length || 'all' } };
+                }
+                case "publish_app": {
+                    const projectPath = input.projectPath;
+                    // Use the publish_hailer_app tool's execute method
+                    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 isError = result.content?.some((c) => c.text?.includes('❌'));
+                    return { success: !isError, result };
+                }
+                case "move_bug_to_phase": {
+                    const bugId = input.bugId;
+                    const phase = input.phase;
+                    const moved = await this.bugMonitor.moveBugToPhase(bugId, phase);
+                    return { success: moved, result: { bugId, phase, moved } };
+                }
+                case "read_file": {
+                    const projectPath = input.projectPath;
+                    const filePath = input.filePath;
+                    const content = await this.files.readFile(projectPath, filePath);
+                    return { success: !!content, result: { filePath, content } };
+                }
+                default:
+                    return { success: false, result: { error: `Unknown tool: ${name}` } };
+            }
+        }
+        catch (error) {
+            this.giuseppeLogger.error("Tool execution failed", { tool: name, error: error.message });
+            return { success: false, result: { error: error.message } };
+        }
+    }
+    /**
+     * System prompt for Giuseppe - natural conversation about bug fixing
+     */
+    getSystemPrompt() {
+        const now = new Date();
+        return `You are Giuseppe, an autonomous AI agent specialized in fixing bugs in Hailer apps.
+
+<identity>
+- Name: Giuseppe
+- Role: Bug Fixer
+- Style: Technical but friendly, explain what you're doing
+- Autonomy: You can analyze, fix, build, and commit without asking. But ALWAYS ask before publishing to production.
+</identity>
+
+<current_context>
+- Time: ${now.toISOString()}
+- Bot ID: ${this.botClient.userId}
+- Apps directory: ${this.appsBasePath}
+</current_context>
+
+<workflow>
+When a user reports or discusses a bug:
+
+1. **Understand the bug** - Read the description, ask clarifying questions if needed
+2. **Find the app** - Use find_app_project to locate the codebase
+3. **Analyze the code** - Use analyze_code and read_file to understand the issue
+4. **Check git status** - Use git_status to see if there are pending changes or sync issues
+5. **Fix git problems** - If behind remote, use git_pull. If dirty, decide whether to commit or revert
+6. **Generate fix** - Use generate_fix to create a solution
+7. **Apply and test** - Use apply_fix then run_build to verify
+8. **Commit** - Use git_commit with a descriptive message
+9. **Ask to publish** - Tell the user what you fixed and ask if they want to publish
+
+If builds fail, analyze the error, try again, or ask for help.
+If git has conflicts, explain and ask the user what to do.
+</workflow>
+
+<natural_language>
+You understand natural language. Users might say:
+- "fix this" / "go ahead" / "do it" → Proceed with the fix
+- "publish it" / "deploy" / "ship it" → Publish to production (after asking)
+- "wait" / "hold on" / "not yet" → Pause and wait for further input
+- "revert" / "undo" / "cancel" → Revert changes
+- "what's the status?" → Report current progress
+
+You do NOT need exact phrases. Understand intent.
+</natural_language>
+
+<response_format>
+- Be concise but informative
+- Show what you're doing: "Analyzing the codebase..." / "Found the issue in Ball.tsx..."
+- Ask before destructive actions
+- Report errors clearly with suggestions
+</response_format>
+
+<tools>
+You have these tools:
+- find_app_project: Find app from bug title
+- analyze_code: LSP analysis of codebase
+- generate_fix: AI-powered fix generation
+- apply_fix: Write code changes
+- run_build: Test compilation
+- git_status: Check repo state
+- git_pull: Pull from remote
+- git_commit: Commit changes
+- git_push: Push to remote
+- git_revert: Undo changes
+- publish_app: Deploy to production (ASK FIRST!)
+- move_bug_to_phase: Update bug status
+- read_file: Read source files
+</tools>`;
+    }
+}
+exports.GiuseppeDaemon = GiuseppeDaemon;
+//# sourceMappingURL=giuseppe-daemon.js.map

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

@@ -48,5 +48,17 @@ export declare class GiuseppeFiles {
      * Find app project by appId, appName, or bug title
      */
     findAppProject(bug: BugReport, appsRegistry: Map<string, AppRegistryEntry>): Promise<AppRegistryEntry | null>;
+    /**
+     * Find app project from bug title alone (simplified interface for daemon)
+     */
+    findAppFromBugTitle(bugTitle: string): Promise<AppRegistryEntry | null>;
+    /**
+     * Read a single file
+     */
+    readFile(projectPath: string, filePath: string): Promise<string | null>;
+    /**
+     * Write a file
+     */
+    writeFile(projectPath: string, filePath: string, content: string): Promise<boolean>;
 }
 //# sourceMappingURL=giuseppe-files.d.ts.map

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

@@ -333,6 +333,43 @@ class GiuseppeFiles {
         }
         return null;
     }
+    /**
+     * Find app project from bug title alone (simplified interface for daemon)
+     */
+    async findAppFromBugTitle(bugTitle) {
+        return this.findAppProject({ id: '', name: bugTitle, description: '', workflowId: '', phaseId: '', createdAt: '' }, new Map());
+    }
+    /**
+     * Read a single file
+     */
+    async readFile(projectPath, filePath) {
+        try {
+            const fullPath = path.join(projectPath, filePath);
+            const content = await fs.readFile(fullPath, 'utf-8');
+            logger.debug('Read file', { path: filePath, size: content.length });
+            return content;
+        }
+        catch (error) {
+            logger.warn('Could not read file', { path: filePath, error });
+            return null;
+        }
+    }
+    /**
+     * Write a file
+     */
+    async writeFile(projectPath, filePath, content) {
+        try {
+            const fullPath = path.join(projectPath, filePath);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content, 'utf-8');
+            logger.info('Wrote file', { path: filePath, size: content.length });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to write file', { path: filePath, error });
+            return false;
+        }
+    }
 }
 exports.GiuseppeFiles = GiuseppeFiles;
 //# sourceMappingURL=giuseppe-files.js.map