@hailer/mcp 0.2.3 → 0.2.5

package/dist/mcp/tools/bug-fixer-tools.js

@@ -39,7 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bugFixerTools = exports.bugFixerPublishAppTool = exports.bugFixerGitRevertTool = exports.bugFixerGitPushTool = exports.bugFixerGitCommitTool = exports.bugFixerGitPullTool = exports.bugFixerGitStatusTool = exports.bugFixerRunBuildTool = exports.bugFixerApplyFixTool = exports.bugFixerWriteFileTool = exports.bugFixerReadFileTool = exports.bugFixerListFilesTool = exports.bugFixerFindAppTool = void 0;
+exports.bugFixerTools = exports.bugFixerRetryFixTool = exports.bugFixerPublishFixTool = exports.bugFixerMarkDeclinedTool = exports.bugFixerStartFixTool = exports.bugFixerAnalyzeBugTool = exports.bugFixerPublishAppTool = exports.bugFixerGitRevertTool = exports.bugFixerGitPushTool = exports.bugFixerGitCommitTool = exports.bugFixerGitPullTool = exports.bugFixerGitStatusTool = exports.bugFixerRunBuildTool = exports.bugFixerApplyFixTool = exports.bugFixerWriteFileTool = exports.bugFixerReadFileTool = exports.bugFixerListFilesTool = exports.bugFixerFindAppTool = void 0;
 const zod_1 = require("zod");
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs/promises"));
@@ -47,36 +47,76 @@ const path = __importStar(require("path"));
 const tool_registry_1 = require("../tool-registry");
 const logger_1 = require("../../lib/logger");
 const config_1 = require("../../config");
+const pending_classification_1 = require("../../agents/bug-fixer/registries/pending-classification");
+const pending_fix_1 = require("../../agents/bug-fixer/registries/pending-fix");
 const logger = (0, logger_1.createLogger)({ component: "bug-fixer-tools" });
-const appsBasePath = config_1.environment.DEV_APPS_PATH || process.cwd();
-// Helper to scan for apps
+// Parse all configured app paths
+function getAppPaths() {
+    const paths = [];
+    // Multiple paths (comma-separated)
+    if (config_1.environment.DEV_APPS_PATHS) {
+        paths.push(...config_1.environment.DEV_APPS_PATHS.split(',').map(p => p.trim()).filter(p => p.length > 0));
+    }
+    // Single path (fallback)
+    if (config_1.environment.DEV_APPS_PATH && !paths.includes(config_1.environment.DEV_APPS_PATH)) {
+        paths.push(config_1.environment.DEV_APPS_PATH);
+    }
+    // Default to cwd if nothing configured
+    if (paths.length === 0) {
+        paths.push(process.cwd());
+    }
+    return paths;
+}
+// Cache for scanned apps
+let appsCache = null;
+// Helper to scan for apps across all configured directories
 async function scanApps() {
+    // Return cached if available
+    if (appsCache)
+        return appsCache;
     const apps = [];
-    try {
-        const entries = await fs.readdir(appsBasePath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() && !entry.name.startsWith(".") && !["node_modules", "dist"].includes(entry.name)) {
-                const appPath = path.join(appsBasePath, entry.name);
-                // Check for manifest.json (Hailer app indicator)
-                try {
-                    await fs.access(path.join(appPath, "manifest.json"));
-                    apps.push({ name: entry.name, path: appPath });
-                }
-                catch {
+    const appPaths = getAppPaths();
+    for (const basePath of appPaths) {
+        try {
+            const entries = await fs.readdir(basePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !entry.name.startsWith(".") && !["node_modules", "dist"].includes(entry.name)) {
+                    const appPath = path.join(basePath, entry.name);
+                    // Try to read manifest for appId
+                    let manifest = null;
                     try {
-                        await fs.access(path.join(appPath, "public", "manifest.json"));
-                        apps.push({ name: entry.name, path: appPath });
+                        const content = await fs.readFile(path.join(appPath, "manifest.json"), "utf-8");
+                        manifest = JSON.parse(content);
                     }
                     catch {
-                        // Not a Hailer app
+                        try {
+                            const content = await fs.readFile(path.join(appPath, "public", "manifest.json"), "utf-8");
+                            manifest = JSON.parse(content);
+                        }
+                        catch {
+                            // Not a Hailer app
+                        }
+                    }
+                    if (manifest) {
+                        apps.push({
+                            name: manifest.name || entry.name,
+                            path: appPath,
+                            appId: manifest.appId
+                        });
                     }
                 }
             }
         }
+        catch (e) {
+            logger.warn("Failed to scan apps directory", { path: basePath, error: e });
+        }
     }
-    catch (e) {
-        logger.warn("Failed to scan apps", { error: e });
-    }
+    // Cache results
+    appsCache = apps;
+    logger.info("Scanned apps for bug fixer tools", {
+        paths: appPaths,
+        found: apps.map(a => ({ name: a.name, appId: a.appId?.substring(0, 8) || "none" }))
+    });
     return apps;
 }
 // Find App Tool
@@ -86,13 +126,14 @@ exports.bugFixerFindAppTool = {
     description: "Find a Hailer app project by name or from bug title",
     schema: zod_1.z.object({
         searchTerm: zod_1.z.string().describe("App name or bug title to search for").optional(),
-        name: zod_1.z.string().describe("Alias for searchTerm - app name to search for").optional()
-    }).refine(data => data.searchTerm || data.name, {
-        message: "Either searchTerm or name is required"
+        name: zod_1.z.string().describe("Alias for searchTerm - app name to search for").optional(),
+        appName: zod_1.z.string().describe("Alias for searchTerm - app name to search for").optional()
+    }).refine(data => data.searchTerm || data.name || data.appName, {
+        message: "Either searchTerm, name, or appName is required"
     }),
     async execute(args, _context) {
-        // Accept either searchTerm or name
-        const searchTerm = (args.searchTerm || args.name || '').toLowerCase();
+        // Accept searchTerm, name, or appName
+        const searchTerm = (args.searchTerm || args.name || args.appName || '').toLowerCase();
         const apps = await scanApps();
         for (const app of apps) {
             if (app.name.toLowerCase().includes(searchTerm) ||
@@ -113,9 +154,14 @@ exports.bugFixerListFilesTool = {
     group: tool_registry_1.ToolGroup.BOT_INTERNAL,
     description: "List source files in a Hailer app project",
     schema: zod_1.z.object({
-        appPath: zod_1.z.string().describe("Path to the app project")
+        appPath: zod_1.z.string().describe("Path to the app project").optional(),
+        app: zod_1.z.string().describe("Alias for appPath - path to the app project").optional()
+    }).refine(data => data.appPath || data.app, {
+        message: "Either appPath or app is required"
     }),
     async execute(args, _context) {
+        // Accept either appPath or app
+        const appPath = args.appPath || args.app || '';
         const files = [];
         const extensions = [".tsx", ".ts", ".jsx", ".js"];
         const ignoreDirs = ["node_modules", "dist", "build", ".git"];
@@ -126,7 +172,7 @@ exports.bugFixerListFilesTool = {
                 const entries = await fs.readdir(dir, { withFileTypes: true });
                 for (const entry of entries) {
                     const fullPath = path.join(dir, entry.name);
-                    const relativePath = path.relative(args.appPath, fullPath);
+                    const relativePath = path.relative(appPath, fullPath);
                     if (entry.isDirectory()) {
                         if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith(".")) {
                             await scan(fullPath, depth + 1);
@@ -141,7 +187,7 @@ exports.bugFixerListFilesTool = {
             }
             catch { /* skip */ }
         };
-        await scan(args.appPath);
+        await scan(appPath);
         return {
             content: [{ type: "text", text: JSON.stringify({ files: files.slice(0, 50), total: files.length }) }]
         };
@@ -233,10 +279,21 @@ Example:
     }),
     async execute(args, _context) {
         try {
-            // Resolve app path
+            // Resolve app path - try absolute first, then search in configured directories
             let appFullPath = args.appPath;
             if (!path.isAbsolute(args.appPath)) {
-                appFullPath = path.join(appsBasePath, args.appPath);
+                // Try to find in scanned apps
+                const apps = await scanApps();
+                const matchedApp = apps.find(a => a.name.toLowerCase() === args.appPath.toLowerCase() ||
+                    a.path.endsWith(`/${args.appPath}`));
+                if (matchedApp) {
+                    appFullPath = matchedApp.path;
+                }
+                else {
+                    // Fallback: try first configured path
+                    const basePaths = getAppPaths();
+                    appFullPath = path.join(basePaths[0], args.appPath);
+                }
             }
             // Check app exists
             try {
@@ -507,13 +564,366 @@ exports.bugFixerPublishAppTool = {
         }
     }
 };
+// ============================================================================
+// HIGH-LEVEL WORKFLOW TOOLS (LLM-driven workflow control)
+// ============================================================================
+/**
+ * Analyze Bug Tool - Read bug report and get classification info
+ * The LLM uses this to understand the bug and decide next steps
+ */
+exports.bugFixerAnalyzeBugTool = {
+    name: "bug_fixer_analyze_bug",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Read a bug report and get classification information.
+Returns the bug details and classification if already analyzed.
+Use this to understand the current state of a bug discussion.`,
+    schema: zod_1.z.object({
+        discussionId: zod_1.z.string().describe("The discussion ID for the bug report").optional(),
+        activityId: zod_1.z.string().describe("Alias - the bug activity ID (will look up discussion)").optional()
+    }).refine(data => data.discussionId || data.activityId, {
+        message: "Either discussionId or activityId is required"
+    }),
+    async execute(args, context) {
+        try {
+            // Accept either discussionId or look up from activityId
+            let discussionId = args.discussionId;
+            if (!discussionId && args.activityId) {
+                // Try to find discussionId from pending registries by activityId
+                const allPending = pending_classification_1.pendingClassificationRegistry.getAll();
+                for (const pending of allPending) {
+                    if (pending.bugId === args.activityId) {
+                        discussionId = pending.discussionId;
+                        break;
+                    }
+                }
+                // If still not found, fetch activity to get discussion
+                if (!discussionId) {
+                    const activity = await context.hailer.fetchActivityById(args.activityId);
+                    if (activity?.discussion) {
+                        discussionId = activity.discussion;
+                    }
+                }
+            }
+            if (!discussionId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "error",
+                                message: "Could not find discussion for the given ID"
+                            })
+                        }]
+                };
+            }
+            // Check if we have pending classification info
+            const pending = pending_classification_1.pendingClassificationRegistry.get(discussionId);
+            if (pending) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "pending_confirmation",
+                                bugId: pending.bugId,
+                                bugName: pending.bugName,
+                                appId: pending.appId,
+                                appName: pending.appName,
+                                classification: pending.classification,
+                                reason: pending.reason,
+                                description: pending.bug.description,
+                                stepsToReproduce: pending.bug.stepsToReproduce,
+                                message: "Bug has been classified. Waiting for user to confirm whether to proceed with fix."
+                            })
+                        }]
+                };
+            }
+            // Check if we have a pending fix
+            const pendingFix = pending_fix_1.pendingFixRegistry.get(args.discussionId);
+            if (pendingFix) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: pendingFix.state === "awaiting_test" ? "fix_applied" : "awaiting_explanation",
+                                bugId: pendingFix.bugId,
+                                appId: pendingFix.appId,
+                                fixSummary: pendingFix.fixSummary,
+                                filesModified: pendingFix.filesModified,
+                                message: pendingFix.state === "awaiting_test"
+                                    ? "Fix has been applied. Waiting for user to test and approve."
+                                    : "Fix was rejected. Waiting for user to explain what's wrong."
+                            })
+                        }]
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            status: "not_found",
+                            message: "No pending bug found for this discussion. The bug may have already been processed."
+                        })
+                    }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+/**
+ * Start Fix Tool - Begin the bug fix process
+ * This triggers the full fix workflow: find app → analyze → apply fix → build
+ */
+exports.bugFixerStartFixTool = {
+    name: "bug_fixer_start_fix",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Start the bug fix process. Call this when the user confirms they want you to fix the bug.
+This will: find the app, analyze the code, generate and apply a fix, and run the build.
+The user should test the fix afterward.`,
+    schema: zod_1.z.object({
+        discussionId: zod_1.z.string().describe("The discussion ID for the bug report")
+    }),
+    async execute(args, _context) {
+        try {
+            const pending = pending_classification_1.pendingClassificationRegistry.get(args.discussionId);
+            if (!pending) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "No pending bug classification found for this discussion. Cannot start fix."
+                            })
+                        }]
+                };
+            }
+            // Trigger the fix via the registry callback
+            const triggered = await pending_classification_1.pendingClassificationRegistry.triggerFixIt(args.discussionId);
+            if (triggered) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Fix process started. The bot will analyze and apply the fix, then notify the user to test."
+                            })
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Failed to trigger fix process. The callback may not be registered."
+                            })
+                        }]
+                };
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+/**
+ * Mark Declined Tool - Mark bug as not-a-bug and close it
+ */
+exports.bugFixerMarkDeclinedTool = {
+    name: "bug_fixer_mark_declined",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Mark a bug report as "not a bug" and move it to the Declined phase.
+Call this when the user confirms it's actually a feature request or not a real bug.`,
+    schema: zod_1.z.object({
+        discussionId: zod_1.z.string().describe("The discussion ID for the bug report")
+    }),
+    async execute(args, _context) {
+        try {
+            const pending = pending_classification_1.pendingClassificationRegistry.get(args.discussionId);
+            if (!pending) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "No pending bug classification found for this discussion."
+                            })
+                        }]
+                };
+            }
+            // Trigger the not-a-bug action via the registry callback
+            const triggered = await pending_classification_1.pendingClassificationRegistry.triggerNotABug(args.discussionId);
+            if (triggered) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                bugId: pending.bugId,
+                                message: "Bug marked as declined (not a bug). Moved to Declined phase."
+                            })
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Failed to decline bug. The callback may not be registered."
+                            })
+                        }]
+                };
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+/**
+ * Publish Fix Tool - Publish the fix to production
+ */
+exports.bugFixerPublishFixTool = {
+    name: "bug_fixer_publish_fix",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Publish a tested fix to production and mark the bug as Fixed.
+Call this ONLY after the user has tested the fix and approved it.`,
+    schema: zod_1.z.object({
+        discussionId: zod_1.z.string().describe("The discussion ID for the bug report")
+    }),
+    async execute(args, _context) {
+        try {
+            // Trigger approval via the registry callback
+            const triggered = await pending_fix_1.pendingFixRegistry.triggerApproval(args.discussionId);
+            if (triggered) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Fix is being published to production. This may take a moment."
+                            })
+                        }]
+                };
+            }
+            else {
+                // Get more info about why it failed
+                const pending = pending_fix_1.pendingFixRegistry.get(args.discussionId);
+                if (!pending) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: "No pending fix found for this discussion. Cannot publish."
+                                })
+                            }]
+                    };
+                }
+                if (pending.state !== "awaiting_test") {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: `Cannot publish - fix is in state '${pending.state}'. User must test and approve first.`
+                                })
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Failed to trigger publish. The approval callback may not be registered."
+                            })
+                        }]
+                };
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+/**
+ * Retry Fix Tool - Retry a fix with additional context/explanation
+ */
+exports.bugFixerRetryFixTool = {
+    name: "bug_fixer_retry_fix",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Retry fixing a bug with additional context from the user.
+Call this when the user explains why the previous fix didn't work.`,
+    schema: zod_1.z.object({
+        discussionId: zod_1.z.string().describe("The discussion ID for the bug report"),
+        explanation: zod_1.z.string().describe("User's explanation of what's still broken or wrong")
+    }),
+    async execute(args, _context) {
+        try {
+            const pending = pending_fix_1.pendingFixRegistry.get(args.discussionId);
+            if (!pending) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "No pending fix found for this discussion."
+                            })
+                        }]
+                };
+            }
+            // Trigger retry via the registry callback
+            const triggered = await pending_fix_1.pendingFixRegistry.triggerRetry(args.discussionId, args.explanation);
+            if (triggered) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Retry started with user feedback. The bot will generate a new fix."
+                            })
+                        }]
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Failed to trigger retry. The callback may not be registered."
+                            })
+                        }]
+                };
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
 // Export all tools
 exports.bugFixerTools = [
+    // Low-level tools
     exports.bugFixerFindAppTool,
     exports.bugFixerListFilesTool,
     exports.bugFixerReadFileTool,
     exports.bugFixerWriteFileTool,
-    exports.bugFixerApplyFixTool, // New: search/replace (preferred)
+    exports.bugFixerApplyFixTool,
     exports.bugFixerRunBuildTool,
     exports.bugFixerGitStatusTool,
     exports.bugFixerGitPullTool,
@@ -521,5 +931,11 @@ exports.bugFixerTools = [
     exports.bugFixerGitPushTool,
     exports.bugFixerGitRevertTool,
     exports.bugFixerPublishAppTool,
+    // High-level workflow tools (LLM-driven)
+    exports.bugFixerAnalyzeBugTool,
+    exports.bugFixerStartFixTool,
+    exports.bugFixerMarkDeclinedTool,
+    exports.bugFixerPublishFixTool,
+    exports.bugFixerRetryFixTool,
 ];
 //# sourceMappingURL=bug-fixer-tools.js.map

package/dist/mcp/tools/file.d.ts

@@ -1,5 +1,5 @@
 /**
- * Upload Files Tool - Clean Architecture Implementation
+ * File Tools - Clean Architecture Implementation
  *
  * Demonstrates the new tool architecture pattern:
  * - Direct Tool<TSchema> interface implementation
@@ -12,4 +12,8 @@ import { Tool } from '../tool-registry';
  * Upload Files Tool - Clean implementation following new architecture
  */
 export declare const uploadFilesTool: Tool;
+/**
+ * Download File Tool - Clean implementation
+ */
+export declare const downloadFileTool: Tool;
 //# sourceMappingURL=file.d.ts.map