@hailer/mcp 1.1.12 → 1.1.13

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

@@ -0,0 +1,1096 @@
+"use strict";
+/**
+ * Bug Fixer MCP Tools
+ *
+ * Bug-fixing tools for Bug Fixer specialist daemon.
+ * These tools handle file operations, git, and build commands.
+ */
+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.bugFixerTools = exports.markBugFixedTool = exports.markBugDeclinedTool = 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"));
+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" });
+// 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 = [];
+    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 {
+                        const content = await fs.readFile(path.join(appPath, "manifest.json"), "utf-8");
+                        manifest = JSON.parse(content);
+                    }
+                    catch {
+                        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 });
+        }
+    }
+    // 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
+exports.bugFixerFindAppTool = {
+    name: "bug_fixer_find_app",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    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(),
+        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 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) ||
+                searchTerm.includes(app.name.toLowerCase())) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ found: true, name: app.name, path: app.path }) }]
+                };
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ found: false, availableApps: apps.map(a => a.name) }) }]
+        };
+    }
+};
+// List Files Tool
+exports.bugFixerListFilesTool = {
+    name: "bug_fixer_list_files",
+    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").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"];
+        const scan = async (dir, depth = 0) => {
+            if (depth > 5)
+                return;
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(appPath, fullPath);
+                    if (entry.isDirectory()) {
+                        if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith(".")) {
+                            await scan(fullPath, depth + 1);
+                        }
+                    }
+                    else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                        if (!entry.name.includes(".test.") && !entry.name.includes(".spec.")) {
+                            files.push(relativePath);
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        };
+        await scan(appPath);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ files: files.slice(0, 50), total: files.length }) }]
+        };
+    }
+};
+// Read File Tool
+exports.bugFixerReadFileTool = {
+    name: "bug_fixer_read_file",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Read a source file from the app",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        filePath: zod_1.z.string().describe("Relative path to the file")
+    }),
+    async execute(args, _context) {
+        try {
+            const fullPath = path.join(args.appPath, args.filePath);
+            const content = await fs.readFile(fullPath, "utf-8");
+            return {
+                content: [{ type: "text", text: JSON.stringify({ content }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Write File Tool
+exports.bugFixerWriteFileTool = {
+    name: "bug_fixer_write_file",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Write/update a source file in the app",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        filePath: zod_1.z.string().describe("Relative path to the file"),
+        content: zod_1.z.string().describe("New file content")
+    }),
+    async execute(args, _context) {
+        try {
+            const fullPath = path.join(args.appPath, args.filePath);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, args.content, "utf-8");
+            logger.info("Bug Fixer wrote file", { filePath: args.filePath });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, path: args.filePath }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Apply Fix Tool (search/replace pattern - calls existing bot logic)
+const fixFileSchema = zod_1.z.object({
+    path: zod_1.z.string().describe("Relative file path (e.g., 'src/App.tsx')"),
+    action: zod_1.z.enum(["edit", "create", "delete"]).describe("Action: edit (search/replace), create (new file), delete"),
+    search: zod_1.z.string().optional().describe("For 'edit': the exact code snippet to find"),
+    replace: zod_1.z.string().optional().describe("For 'edit': the code to replace it with"),
+    content: zod_1.z.string().optional().describe("For 'create': the full file content")
+});
+exports.bugFixerApplyFixTool = {
+    name: "bug_fixer_apply_fix",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: `Apply code fixes using search/replace pattern. More token-efficient than rewriting entire files.
+
+**For 'edit' action:** Provide search (code to find) and replace (code to replace with).
+**For 'create' action:** Provide content (full file content).
+**For 'delete' action:** Just provide path.
+
+Example:
+\`\`\`json
+{
+  "appPath": "lineup-manager",
+  "fixes": [{
+    "path": "src/App.tsx",
+    "action": "edit",
+    "search": "const handleDragEnd = () => {\\n  // old code\\n}",
+    "replace": "const handleDragEnd = () => {\\n  // fixed code\\n}"
+  }]
+}
+\`\`\``,
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("App folder name or path (e.g., 'lineup-manager')"),
+        fixes: zod_1.z.array(fixFileSchema).describe("Array of file operations to apply")
+    }),
+    async execute(args, _context) {
+        try {
+            // Resolve app path - try absolute first, then search in configured directories
+            let appFullPath = args.appPath;
+            if (!path.isAbsolute(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 {
+                await fs.access(appFullPath);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: `App not found at: ${appFullPath}`
+                            }) }]
+                };
+            }
+            const modifiedFiles = [];
+            const errors = [];
+            for (const fix of args.fixes) {
+                const filePath = path.join(appFullPath, fix.path);
+                try {
+                    if (fix.action === 'edit' && fix.search && fix.replace !== undefined) {
+                        // Read file
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        // Try exact match first
+                        if (content.includes(fix.search)) {
+                            const newContent = content.replace(fix.search, fix.replace);
+                            await fs.writeFile(filePath, newContent, 'utf-8');
+                            modifiedFiles.push(fix.path);
+                            logger.info("Bug Fixer applied fix (exact match)", { path: fix.path });
+                        }
+                        else {
+                            // Try normalized whitespace match
+                            const normalizeWs = (s) => s.replace(/\s+/g, ' ').trim();
+                            const normalizedContent = normalizeWs(content);
+                            const normalizedSearch = normalizeWs(fix.search);
+                            if (normalizedContent.includes(normalizedSearch)) {
+                                // Line-by-line search
+                                const searchLines = fix.search.split('\n').map((l) => l.trim()).filter((l) => l);
+                                const contentLines = content.split('\n');
+                                let found = false;
+                                for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+                                    const candidateLines = contentLines.slice(i, i + searchLines.length);
+                                    if (candidateLines.every((line, j) => line.trim() === searchLines[j])) {
+                                        const before = contentLines.slice(0, i);
+                                        const after = contentLines.slice(i + searchLines.length);
+                                        const replaceLines = fix.replace.split('\n');
+                                        const newContent = [...before, ...replaceLines, ...after].join('\n');
+                                        await fs.writeFile(filePath, newContent, 'utf-8');
+                                        modifiedFiles.push(fix.path);
+                                        found = true;
+                                        logger.info("Bug Fixer applied fix (normalized match)", { path: fix.path });
+                                        break;
+                                    }
+                                }
+                                if (!found) {
+                                    errors.push(`${fix.path}: Search string not found (whitespace mismatch)`);
+                                }
+                            }
+                            else {
+                                errors.push(`${fix.path}: Search string not found`);
+                            }
+                        }
+                    }
+                    else if (fix.action === 'create' && fix.content) {
+                        await fs.mkdir(path.dirname(filePath), { recursive: true });
+                        await fs.writeFile(filePath, fix.content, 'utf-8');
+                        modifiedFiles.push(fix.path);
+                        logger.info("Bug Fixer created file", { path: fix.path });
+                    }
+                    else if (fix.action === 'delete') {
+                        await fs.unlink(filePath);
+                        modifiedFiles.push(fix.path);
+                        logger.info("Bug Fixer deleted file", { path: fix.path });
+                    }
+                    else {
+                        errors.push(`${fix.path}: Invalid action or missing required fields`);
+                    }
+                }
+                catch (e) {
+                    errors.push(`${fix.path}: ${e.message}`);
+                }
+            }
+            if (errors.length > 0) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                modifiedFiles,
+                                errors,
+                                hint: "Check that 'search' exactly matches the code in the file (including whitespace)"
+                            }) }]
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: true,
+                            modifiedFiles,
+                            message: `Applied ${modifiedFiles.length} fix(es). Run bug_fixer_run_build to verify.`
+                        }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// Run Build Tool
+exports.bugFixerRunBuildTool = {
+    name: "bug_fixer_run_build",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Run TypeScript build to check for errors",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const output = (0, child_process_1.execSync)("npm run build 2>&1", { cwd: args.appPath, encoding: "utf-8", timeout: 60000 });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, output: output.slice(-2000) }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: (e.stdout || e.stderr || e.message).slice(-2000) }) }]
+            };
+        }
+    }
+};
+// Git Status Tool
+exports.bugFixerGitStatusTool = {
+    name: "bug_fixer_git_status",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Check git status - branch, changes, sync with remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const status = (0, child_process_1.execSync)("git status --short", { cwd: args.appPath, encoding: "utf-8" });
+            const branch = (0, child_process_1.execSync)("git branch --show-current", { cwd: args.appPath, encoding: "utf-8" }).trim();
+            let behind = 0, ahead = 0;
+            try {
+                const revList = (0, child_process_1.execSync)("git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null", { cwd: args.appPath, encoding: "utf-8" }).trim().split(/\s+/);
+                ahead = parseInt(revList[0]) || 0;
+                behind = parseInt(revList[1]) || 0;
+            }
+            catch { /* no upstream */ }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ branch, status: status || "clean", ahead, behind }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Git Pull Tool
+exports.bugFixerGitPullTool = {
+    name: "bug_fixer_git_pull",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Pull latest changes from remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const output = (0, child_process_1.execSync)("git pull", { cwd: args.appPath, encoding: "utf-8" });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, output }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.message }) }]
+            };
+        }
+    }
+};
+// Git Commit Tool
+exports.bugFixerGitCommitTool = {
+    name: "bug_fixer_git_commit",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Stage all changes and commit",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        message: zod_1.z.string().describe("Commit message")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git add -A", { cwd: args.appPath });
+            (0, child_process_1.execSync)(`git commit -m "${args.message.replace(/"/g, '\\"')}"`, { cwd: args.appPath });
+            const hash = (0, child_process_1.execSync)("git rev-parse --short HEAD", { cwd: args.appPath, encoding: "utf-8" }).trim();
+            logger.info("Bug Fixer committed", { hash, message: args.message });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, hash }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.stdout || e.message }) }]
+            };
+        }
+    }
+};
+// Git Push Tool
+exports.bugFixerGitPushTool = {
+    name: "bug_fixer_git_push",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Push commits to remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git push", { cwd: args.appPath, encoding: "utf-8", stdio: "pipe" });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.message }) }]
+            };
+        }
+    }
+};
+// Git Revert Tool
+exports.bugFixerGitRevertTool = {
+    name: "bug_fixer_git_revert",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Discard all uncommitted changes",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git checkout -- .", { cwd: args.appPath });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// Publish App Tool
+exports.bugFixerPublishAppTool = {
+    name: "bug_fixer_publish_app",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Publish app to Hailer production - ALWAYS ASK USER FIRST",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, context) {
+        try {
+            const { publishHailerAppTool } = await Promise.resolve().then(() => __importStar(require("./app-scaffold")));
+            const result = await publishHailerAppTool.execute({ projectDirectory: args.appPath }, context);
+            return result;
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// ============================================================================
+// 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 }) }]
+            };
+        }
+    }
+};
+// Mark Bug Declined Tool - handles everything automatically
+exports.markBugDeclinedTool = {
+    name: "mark_bug_declined",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Mark a bug as declined (not a bug / won't fix). Automatically sets phase to Declined, status to 'Won't Fix', and leaves the discussion.",
+    schema: zod_1.z.object({
+        bugId: zod_1.z.string().describe("The bug activity ID"),
+        workflowId: zod_1.z.string().describe("The workflow ID for the Bug Reports workflow"),
+        discussionId: zod_1.z.string().describe("The discussion ID to leave after marking declined"),
+        reason: zod_1.z.string().optional().describe("Optional reason for declining"),
+    }),
+    async execute(args, context) {
+        const { bugId, workflowId, discussionId, reason } = args;
+        const { hailer } = context;
+        try {
+            // 1. Get workflow phases from cached init data (reliable method used by list_workflow_phases)
+            const workflowData = context.init.processes?.find((p) => p._id === workflowId);
+            if (!workflowData) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: `Workflow ${workflowId} not found`
+                            }) }]
+                };
+            }
+            const phases = workflowData.phases || {};
+            const declinedPhase = Object.entries(phases).find(([_, phase]) => phase.name?.toLowerCase() === 'declined');
+            if (!declinedPhase) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: "Could not find 'Declined' phase in workflow",
+                                availablePhases: Object.values(phases).map((p) => p.name)
+                            }) }]
+                };
+            }
+            const [declinedPhaseId, declinedPhaseData] = declinedPhase;
+            // 2. Get workflow schema to find status field ID
+            const schema = await hailer.getWorkflowSchema(workflowId, declinedPhaseId);
+            const statusField = Object.entries(schema.fields || {}).find(([_, f]) => f.key === 'status' || f.label?.toLowerCase() === 'status');
+            // 3. Update activity with phase AND status
+            const updateData = {
+                _id: bugId,
+                phaseId: declinedPhaseId,
+            };
+            if (statusField) {
+                updateData.fields = { [statusField[0]]: "Won't Fix" };
+            }
+            await hailer.updateActivities([updateData]);
+            // 4. Leave the discussion
+            try {
+                await hailer.leaveDiscussion(discussionId);
+            }
+            catch (e) {
+                // Ignore leave errors - might already be out
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: true,
+                            phase: "Declined",
+                            status: "Won't Fix",
+                            leftDiscussion: true,
+                            reason: reason || "Not a bug"
+                        }) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error)
+                        }) }]
+            };
+        }
+    }
+};
+// Mark Bug Fixed Tool - handles everything automatically
+exports.markBugFixedTool = {
+    name: "mark_bug_fixed",
+    group: tool_registry_1.ToolGroup.BOT_INTERNAL,
+    description: "Mark a bug as fixed. Automatically sets phase to Fixed, status to 'Fixed', and leaves the discussion. Only use AFTER fix is published and user confirmed it works!",
+    schema: zod_1.z.object({
+        bugId: zod_1.z.string().describe("The bug activity ID"),
+        workflowId: zod_1.z.string().describe("The workflow ID for the Bug Reports workflow"),
+        discussionId: zod_1.z.string().describe("The discussion ID to leave after marking fixed"),
+        fixSummary: zod_1.z.string().optional().describe("Optional summary of what was fixed"),
+    }),
+    async execute(args, context) {
+        const { bugId, workflowId, discussionId, fixSummary } = args;
+        const { hailer } = context;
+        try {
+            // 1. Get workflow phases from cached init data (reliable method used by list_workflow_phases)
+            const workflowData = context.init.processes?.find((p) => p._id === workflowId);
+            if (!workflowData) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: `Workflow ${workflowId} not found`
+                            }) }]
+                };
+            }
+            const phases = workflowData.phases || {};
+            const fixedPhase = Object.entries(phases).find(([_, phase]) => phase.name?.toLowerCase() === 'fixed');
+            if (!fixedPhase) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: "Could not find 'Fixed' phase in workflow",
+                                availablePhases: Object.values(phases).map((p) => p.name)
+                            }) }]
+                };
+            }
+            const [fixedPhaseId, fixedPhaseData] = fixedPhase;
+            // 2. Get workflow schema to find status field ID
+            const schema = await hailer.getWorkflowSchema(workflowId, fixedPhaseId);
+            const statusField = Object.entries(schema.fields || {}).find(([_, f]) => f.key === 'status' || f.label?.toLowerCase() === 'status');
+            // 3. Update activity with phase AND status
+            const updateData = {
+                _id: bugId,
+                phaseId: fixedPhaseId,
+            };
+            if (statusField) {
+                updateData.fields = { [statusField[0]]: "Fixed" };
+            }
+            await hailer.updateActivities([updateData]);
+            // 4. Leave the discussion
+            try {
+                await hailer.leaveDiscussion(discussionId);
+            }
+            catch (e) {
+                // Ignore leave errors - might already be out
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: true,
+                            phase: "Fixed",
+                            status: "Fixed",
+                            leftDiscussion: true,
+                            fixSummary: fixSummary || "Bug fixed"
+                        }) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: false,
+                            error: error instanceof Error ? error.message : String(error)
+                        }) }]
+            };
+        }
+    }
+};
+// Export all tools
+exports.bugFixerTools = [
+    // Low-level tools
+    exports.bugFixerFindAppTool,
+    exports.bugFixerListFilesTool,
+    exports.bugFixerReadFileTool,
+    exports.bugFixerWriteFileTool,
+    exports.bugFixerApplyFixTool,
+    exports.bugFixerRunBuildTool,
+    exports.bugFixerGitStatusTool,
+    exports.bugFixerGitPullTool,
+    exports.bugFixerGitCommitTool,
+    exports.bugFixerGitPushTool,
+    exports.bugFixerGitRevertTool,
+    exports.bugFixerPublishAppTool,
+    // High-level workflow tools (LLM-driven)
+    exports.bugFixerAnalyzeBugTool,
+    exports.bugFixerStartFixTool,
+    exports.bugFixerMarkDeclinedTool,
+    exports.bugFixerPublishFixTool,
+    exports.bugFixerRetryFixTool,
+    // Standalone phase/status tools (no registry dependency)
+    exports.markBugDeclinedTool,
+    exports.markBugFixedTool,
+];
+//# sourceMappingURL=bug-fixer-tools.js.map