@hailer/mcp 0.1.15 → 0.1.16

package/dist/agents/giuseppe/monitor.js

@@ -0,0 +1,621 @@
+"use strict";
+/**
+ * Bug Reports Module - Bug Monitor Service
+ *
+ * Polls for new bug reports and dispatches them for processing.
+ * No hardcoded IDs - discovers workflow by name pattern.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BugMonitor = void 0;
+const logger_1 = require("../../lib/logger");
+const config_1 = require("./config");
+const bot_config_1 = require("../../mcp/tools/bot-config");
+const hailer_clients_1 = require("../../mcp/hailer-clients");
+const logger = (0, logger_1.createLogger)({ component: 'bug-monitor' });
+class BugMonitor {
+    userContext;
+    interval;
+    unsubscribeFromSignals;
+    config;
+    discovery;
+    processedBugIds = new Map(); // id -> timestamp
+    processedMessageIds = new Map(); // id -> timestamp
+    static PROCESSED_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+    handlers = [];
+    messageHandlers = [];
+    giuseppeDisabledHandlers = [];
+    watchedDiscussions = new Map(); // discussionId -> watch start timestamp
+    botUserIds = new Set(); // Bot user IDs to ignore
+    skipNotifications = false; // Skip old-style notifications (for conversational mode)
+    constructor(userContext) {
+        this.userContext = userContext;
+    }
+    /**
+     * Disable old-style notifications (for conversational mode)
+     * Daemon will handle introductions instead
+     */
+    setSkipNotifications(skip) {
+        this.skipNotifications = skip;
+        logger.debug('Skip notifications set', { skip });
+    }
+    /**
+     * Register a bot user ID to ignore messages from
+     */
+    registerBotUser(userId) {
+        this.botUserIds.add(userId);
+        logger.debug('Registered bot user to ignore', { userId });
+    }
+    /**
+     * Register a handler for new bugs
+     */
+    onNewBug(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * Register a handler for discussion messages
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a handler for when Giuseppe is disabled but a bug is found
+     */
+    onGiuseppeDisabled(handler) {
+        this.giuseppeDisabledHandlers.push(handler);
+    }
+    /**
+     * Start watching a discussion for approval messages
+     */
+    watchDiscussion(discussionId) {
+        this.watchedDiscussions.set(discussionId, Date.now());
+        logger.info('Watching discussion for approval', { discussionId });
+    }
+    /**
+     * Stop watching a discussion
+     */
+    unwatchDiscussion(discussionId) {
+        this.watchedDiscussions.delete(discussionId);
+    }
+    /**
+     * Clean up old entries from processed ID caches to prevent memory leaks
+     */
+    cleanupProcessedCaches() {
+        const now = Date.now();
+        const maxAge = BugMonitor.PROCESSED_MAX_AGE_MS;
+        for (const [id, timestamp] of this.processedBugIds.entries()) {
+            if (now - timestamp > maxAge) {
+                this.processedBugIds.delete(id);
+            }
+        }
+        for (const [id, timestamp] of this.processedMessageIds.entries()) {
+            if (now - timestamp > maxAge) {
+                this.processedMessageIds.delete(id);
+            }
+        }
+    }
+    /**
+     * Start monitoring for bugs
+     */
+    async start() {
+        logger.info('Starting Bug Monitor...');
+        try {
+            // Load config
+            this.config = await (0, config_1.loadConfig)(this.userContext);
+            if (!this.config.enabled) {
+                logger.info('Bug Monitor is disabled in config');
+                return;
+            }
+            // Discover workflow
+            this.discovery = await (0, config_1.discoverWorkflow)(this.userContext, this.config) ?? undefined;
+            if (!this.discovery) {
+                logger.warn(`Bug Reports workflow not found (pattern: "${this.config.workflowNamePattern}")`);
+                return;
+            }
+            if (!this.discovery.phases.new) {
+                logger.warn('No "New" phase found in Bug Reports workflow');
+                return;
+            }
+            logger.info('Bug Monitor started', {
+                workflowName: this.discovery.workflowName,
+                autoFix: this.config.autoFix
+            });
+            // Initial check for any bugs that arrived while offline
+            await this.checkForNewBugs();
+            // Subscribe to activity creation signals (replaces polling)
+            const activityUnsubscribe = (0, hailer_clients_1.subscribeToSignal)(this.userContext.apiKey, 'activities.created', (eventData) => this.handleActivitySignal(eventData));
+            // Subscribe to message signals for watched discussions
+            const messageUnsubscribe = (0, hailer_clients_1.subscribeToSignal)(this.userContext.apiKey, 'messenger.new', (eventData) => this.handleMessageSignal(eventData));
+            // Store unsubscribe functions
+            const unsubscribers = [];
+            if (activityUnsubscribe) {
+                unsubscribers.push(activityUnsubscribe);
+                logger.info('Subscribed to activity signals for real-time bug detection');
+            }
+            else {
+                logger.warn('No activity signal subscription available - falling back to polling');
+                // Fallback to polling if signal subscription fails
+                this.interval = setInterval(async () => {
+                    await this.checkForNewBugs();
+                }, this.config.intervalMs);
+            }
+            if (messageUnsubscribe) {
+                unsubscribers.push(messageUnsubscribe);
+                logger.info('Subscribed to message signals for watched discussions');
+            }
+            if (unsubscribers.length > 0) {
+                this.unsubscribeFromSignals = () => {
+                    for (const unsub of unsubscribers) {
+                        unsub();
+                    }
+                };
+            }
+        }
+        catch (error) {
+            logger.error('Failed to start Bug Monitor', { error });
+        }
+    }
+    /**
+     * Stop monitoring
+     */
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        if (this.unsubscribeFromSignals) {
+            this.unsubscribeFromSignals();
+            this.unsubscribeFromSignals = undefined;
+        }
+        logger.info('Bug Monitor stopped');
+    }
+    /**
+     * Get current config
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Get workflow discovery result
+     */
+    getDiscovery() {
+        return this.discovery;
+    }
+    /**
+     * Check for new bugs in the "New" phase
+     */
+    async checkForNewBugs() {
+        if (!this.discovery?.phases.new)
+            return;
+        try {
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchActivityList(this.discovery.workflowId, this.discovery.phases.new, 50);
+            const activities = result?.activities || result || [];
+            const newBugs = activities.filter((a) => !this.processedBugIds.has(a._id));
+            if (newBugs.length > 0) {
+                logger.info(`Found ${newBugs.length} new bug report(s)`);
+                for (const activity of newBugs) {
+                    const bug = await this.parseActivity(activity);
+                    const wasProcessed = await this.processBug(bug);
+                    if (wasProcessed) {
+                        this.processedBugIds.set(bug.id, Date.now());
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Failed to check for bugs', { error });
+        }
+    }
+    /**
+     * Check for new messages in watched discussions
+     */
+    async checkForNewMessages() {
+        // Skip message processing if Giuseppe is disabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            return;
+        }
+        if (this.watchedDiscussions.size === 0)
+            return;
+        // Periodic cleanup of old processed IDs
+        this.cleanupProcessedCaches();
+        const { hailer } = this.userContext;
+        for (const [discussionId, watchStartTime] of this.watchedDiscussions) {
+            try {
+                const result = await hailer.fetchDiscussionMessages(discussionId, 10);
+                const messages = result?.messages || [];
+                for (const msg of messages) {
+                    const msgId = msg._id;
+                    const msgTime = new Date(msg.createdHumanReadable || msg.created).getTime();
+                    // Message content can be in 'content', 'msg', or 'message' field
+                    const content = (msg.content || msg.msg || msg.message || '').trim();
+                    const now = Date.now();
+                    // Skip already processed messages
+                    if (this.processedMessageIds.has(msgId))
+                        continue;
+                    this.processedMessageIds.set(msgId, Date.now());
+                    // Skip messages sent BEFORE we started watching
+                    if (msgTime < watchStartTime)
+                        continue;
+                    // Skip messages older than 60 seconds (stale)
+                    if (now - msgTime > 60000)
+                        continue;
+                    // Skip empty messages
+                    if (!content)
+                        continue;
+                    // Skip messages from bot users (only process human messages)
+                    // Try both 'user' and 'uid' fields for sender ID
+                    const senderId = msg.user || msg.uid;
+                    logger.debug('Message sender check', {
+                        discussionId,
+                        msgUser: msg.user,
+                        msgUid: msg.uid,
+                        senderId,
+                        botUserIds: Array.from(this.botUserIds),
+                        isBot: this.botUserIds.has(senderId)
+                    });
+                    if (senderId && this.botUserIds.has(senderId)) {
+                        logger.debug('Skipping bot message', { discussionId, sender: senderId });
+                        continue;
+                    }
+                    logger.info('Processing approval message', {
+                        discussionId,
+                        messageId: msgId,
+                        sender: senderId,
+                        content: content.substring(0, 50)
+                    });
+                    // Notify message handlers
+                    for (const handler of this.messageHandlers) {
+                        try {
+                            await handler(discussionId, content, senderId);
+                        }
+                        catch (error) {
+                            logger.error('Message handler failed', { discussionId, error });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to check messages', { discussionId, error });
+            }
+        }
+    }
+    /**
+     * Handle incoming message signal (real-time, replaces polling)
+     */
+    async handleMessageSignal(signalData) {
+        // Check if Giuseppe is disabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            return;
+        }
+        const discussionId = signalData?.discussion;
+        if (!discussionId)
+            return;
+        // Check if we're watching this discussion
+        if (!this.watchedDiscussions.has(discussionId)) {
+            return;
+        }
+        const senderId = signalData?.uid;
+        // Skip bot messages
+        if (senderId && this.botUserIds.has(senderId)) {
+            return;
+        }
+        const msgId = signalData?.msg_id;
+        if (!msgId)
+            return;
+        // Skip already processed messages
+        if (this.processedMessageIds.has(msgId)) {
+            return;
+        }
+        this.processedMessageIds.set(msgId, Date.now());
+        try {
+            // Fetch full message content
+            const { hailer } = this.userContext;
+            const result = await hailer.fetchDiscussionMessages(discussionId, 5);
+            const messages = result?.messages || [];
+            const msg = messages.find((m) => m._id === msgId);
+            if (!msg)
+                return;
+            const content = (msg.content || msg.msg || msg.message || '').trim();
+            if (!content)
+                return;
+            // Skip stale messages (older than 60 seconds)
+            const msgTime = new Date(msg.createdHumanReadable || msg.created).getTime();
+            if (Date.now() - msgTime > 60000)
+                return;
+            logger.debug('Processing message from signal', { discussionId, msgId, senderId });
+            // Dispatch to handlers
+            for (const handler of this.messageHandlers) {
+                try {
+                    await handler(discussionId, content, senderId);
+                }
+                catch (error) {
+                    logger.error('Message handler failed', { discussionId, error });
+                }
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to handle message signal', { discussionId, msgId, error });
+        }
+    }
+    /**
+     * Handle incoming activity created signal (real-time, replaces polling)
+     */
+    async handleActivitySignal(signalData) {
+        if (!this.discovery?.phases.new)
+            return;
+        // Extract activity ID from signal - can be _id, id, or activity_id (array)
+        let activityId = signalData?._id || signalData?.id;
+        if (!activityId && Array.isArray(signalData?.activity_id) && signalData.activity_id.length > 0) {
+            activityId = signalData.activity_id[0];
+        }
+        if (!activityId) {
+            logger.debug('Activity signal missing ID', { signalData: JSON.stringify(signalData).slice(0, 200) });
+            return;
+        }
+        // Early filter using signal data (avoid API call if not our workflow/phase)
+        const signalWorkflowId = signalData?.processId;
+        const signalPhaseId = signalData?.phase;
+        if (signalWorkflowId && signalWorkflowId !== this.discovery.workflowId) {
+            // Not our bug workflow, skip silently
+            return;
+        }
+        if (signalPhaseId && signalPhaseId !== this.discovery.phases.new) {
+            // Not in "New" phase, skip silently
+            return;
+        }
+        // Skip if already processed
+        if (this.processedBugIds.has(activityId)) {
+            return;
+        }
+        logger.info('Processing activity signal', { activityId, signalWorkflowId, signalPhaseId });
+        try {
+            const { hailer } = this.userContext;
+            // Fetch full activity to verify and get details
+            const activity = await hailer.fetchActivityById(activityId);
+            // Double-check workflow (in case signal didn't include it)
+            if (activity.processId !== this.discovery.workflowId) {
+                return;
+            }
+            // Double-check phase (in case signal didn't include it)
+            if (activity.phaseId !== this.discovery.phases.new) {
+                logger.debug('Activity not in New phase, skipping', {
+                    activityId,
+                    phaseId: activity.phaseId,
+                    expectedPhaseId: this.discovery.phases.new
+                });
+                return;
+            }
+            logger.info('New bug detected via signal', { activityId, name: activity.name });
+            // Parse and process
+            const bug = await this.parseActivity(activity);
+            const wasProcessed = await this.processBug(bug);
+            if (wasProcessed) {
+                this.processedBugIds.set(bug.id, Date.now());
+            }
+        }
+        catch (error) {
+            logger.warn('Failed to handle activity signal', { activityId, error });
+        }
+    }
+    /**
+     * Parse activity into BugReport
+     */
+    async parseActivity(activity) {
+        const { hailer } = this.userContext;
+        // Get full activity details
+        const fullActivity = await hailer.fetchActivityById(activity._id);
+        const fields = fullActivity.fields || {};
+        // Extract field values using discovered field mappings
+        const bug = {
+            id: activity._id,
+            name: activity.name || 'Untitled Bug',
+            workflowId: this.discovery.workflowId,
+            phaseId: this.discovery.phases.new,
+            discussionId: fullActivity.discussion,
+            createdAt: activity.createdHumanReadable || new Date().toISOString(),
+            createdBy: fullActivity.createdBy || activity.createdBy,
+            description: '',
+            rawFields: fields
+        };
+        // Map fields by discovered field IDs
+        const fieldMapping = this.discovery.fields;
+        for (const [fieldId, fieldData] of Object.entries(fields)) {
+            const value = fieldData.value;
+            if (fieldId === fieldMapping.appId) {
+                bug.appId = String(value);
+            }
+            else if (fieldId === fieldMapping.appName) {
+                bug.appName = String(value);
+            }
+            else if (fieldId === fieldMapping.description) {
+                bug.description = String(value);
+            }
+            else if (fieldId === fieldMapping.stepsToReproduce) {
+                bug.stepsToReproduce = String(value);
+            }
+            else if (fieldId === fieldMapping.expectedBehavior) {
+                bug.expectedBehavior = String(value);
+            }
+            else if (fieldId === fieldMapping.actualBehavior) {
+                bug.actualBehavior = String(value);
+            }
+            else if (fieldId === fieldMapping.reportedBy) {
+                bug.reportedBy = String(value);
+            }
+            else if (fieldId === fieldMapping.priority) {
+                bug.priority = this.parsePriority(value);
+            }
+        }
+        // Fallback: try to extract info from unmatched fields
+        if (!bug.description) {
+            bug.description = this.extractDescription(fields);
+            logger.debug('Used fallback description extraction', {
+                bugId: bug.id,
+                descriptionLength: bug.description.length,
+                fieldIds: Object.keys(fields)
+            });
+        }
+        logger.debug('Parsed bug report', {
+            bugId: bug.id,
+            name: bug.name,
+            appName: bug.appName,
+            descriptionPreview: bug.description?.substring(0, 50)
+        });
+        return bug;
+    }
+    /**
+     * Parse priority value
+     */
+    parsePriority(value) {
+        const v = String(value).toLowerCase();
+        if (v.includes('critical') || v.includes('urgent'))
+            return 'critical';
+        if (v.includes('high'))
+            return 'high';
+        if (v.includes('medium') || v.includes('normal'))
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Extract description from fields as fallback
+     */
+    extractDescription(fields) {
+        // Skip values that look like IDs (24 char hex)
+        const isLikelyId = (v) => /^[a-f0-9]{24}$/i.test(v);
+        // First: look for field with "description" in key/label
+        for (const [fieldId, fieldData] of Object.entries(fields)) {
+            const label = (fieldData.label || fieldData.key || fieldId || '').toLowerCase();
+            if (label.includes('description') && typeof fieldData.value === 'string' && !isLikelyId(fieldData.value)) {
+                return fieldData.value;
+            }
+        }
+        // Second: find longest text that's not an ID
+        let longest = '';
+        for (const fieldData of Object.values(fields)) {
+            const value = fieldData.value;
+            if (typeof value === 'string' && value.length > longest.length && !isLikelyId(value)) {
+                longest = value;
+            }
+        }
+        return longest;
+    }
+    /**
+     * Process a bug through all handlers
+     */
+    async processBug(bug) {
+        // Check if Giuseppe bot is enabled
+        const botState = (0, bot_config_1.getBotState)();
+        if (!botState.giuseppe) {
+            logger.debug('Giuseppe is disabled, skipping bug processing', { bugId: bug.id });
+            // Notify handlers (HAL can respond naturally)
+            for (const handler of this.giuseppeDisabledHandlers) {
+                try {
+                    await handler(bug);
+                }
+                catch (error) {
+                    logger.error('Giuseppe disabled handler failed', { bugId: bug.id, error });
+                }
+            }
+            return false; // Bug was NOT processed
+        }
+        logger.info('Processing bug', {
+            id: bug.id,
+            name: bug.name,
+            appId: bug.appId,
+            priority: bug.priority
+        });
+        // Notify in discussion if enabled (skip in conversational mode - daemon handles intro)
+        if (this.config?.notifyOnNew && bug.discussionId && !this.skipNotifications) {
+            await this.postNotification(bug);
+        }
+        // Dispatch to handlers
+        for (const handler of this.handlers) {
+            try {
+                await handler(bug, this.userContext);
+            }
+            catch (error) {
+                // Properly serialize error for logging (Error objects don't JSON.stringify well)
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const errorStack = error instanceof Error ? error.stack : undefined;
+                logger.error('Bug handler failed', {
+                    bugId: bug.id,
+                    errorMessage,
+                    errorStack
+                });
+            }
+        }
+        return true; // Bug WAS processed
+    }
+    /**
+     * Post notification to bug discussion
+     */
+    async postNotification(bug) {
+        try {
+            const { hailer } = this.userContext;
+            // Check if already notified (look for our notification message)
+            if (bug.discussionId) {
+                try {
+                    const result = await hailer.fetchDiscussionMessages(bug.discussionId, 20);
+                    const messages = result?.messages || [];
+                    const alreadyNotified = messages.some((msg) => {
+                        const content = msg.content || msg.msg || msg.message || '';
+                        return content.includes('Bug Monitor: New bug detected') || content.includes('**Classification:');
+                    });
+                    if (alreadyNotified) {
+                        logger.debug('Bug already notified, skipping notification', { bugId: bug.id });
+                        return;
+                    }
+                }
+                catch {
+                    // Continue if check fails
+                }
+            }
+            // Join the discussion first (required to post messages)
+            try {
+                await hailer.joinActivityDiscussion(bug.id);
+            }
+            catch {
+                // May already be a member, continue
+            }
+            const message = [
+                '🐛 **Bug Monitor: New bug detected!**',
+                '',
+                bug.appId ? `**App:** ${bug.appName || 'Unknown'} (\`${bug.appId}\`)` : '',
+                bug.reportedBy ? `**Reported by:** ${bug.reportedBy}` : '',
+                bug.priority ? `**Priority:** ${bug.priority}` : '',
+                '',
+                bug.description ? `**Description:**\n${bug.description.substring(0, 500)}` : '',
+                '',
+                this.config?.autoFix ? '🔧 Auto-fix is enabled. Analyzing...' : '📋 Awaiting manual review.'
+            ].filter(Boolean).join('\n');
+            await hailer.sendDiscussionMessage(bug.discussionId, message);
+        }
+        catch (error) {
+            logger.warn('Failed to post notification', { bugId: bug.id, error });
+        }
+    }
+    /**
+     * Move bug to a different phase
+     */
+    async moveBugToPhase(bugId, phase) {
+        const phaseId = this.discovery?.phases[phase];
+        if (!phaseId) {
+            logger.warn(`Phase "${phase}" not found`);
+            return false;
+        }
+        try {
+            const { hailer } = this.userContext;
+            await hailer.updateActivities([{ _id: bugId, phaseId }]);
+            logger.info('Moved bug to phase', { bugId, phase });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to move bug', { bugId, phase, error });
+            return false;
+        }
+    }
+}
+exports.BugMonitor = BugMonitor;
+//# sourceMappingURL=monitor.js.map

package/dist/agents/giuseppe/prompt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Giuseppe System Prompt - Expert TypeScript/React debugger prompt
+ */
+export declare const GIUSEPPE_SYSTEM_PROMPT = "<identity>\nYou are Giuseppe, an expert TypeScript/React debugger for Hailer apps.\nYou fix bugs by TRACING code paths, not by guessing.\n</identity>\n\n<expertise>\nTYPESCRIPT: Strict types, interfaces, generics, type guards\nREACT: Hooks, state, effects, memoization, dependency arrays\nCHAKRA UI: Box, Flex, useColorModeValue, responsive props\nHAILER SDK: useHailerContext, useActivity, useWorkflows, activity fields\nCANVAS: 2D context, drawing, hit detection, coordinate systems\n</expertise>\n\n<debugging-process>\nSTEP 1: TRACE THE CODE PATH\n- What function handles the user action? (onClick, onMouseMove, etc.)\n- What state/props does it use?\n- What conditions might fail?\n\nSTEP 2: CHECK REACT REACTIVITY\n- Is state being SET? (setState called)\n- Is component RE-RENDERING? (check useCallback/useMemo deps)\n- Are closures STALE? (missing deps = old values)\n\nSTEP 3: IDENTIFY EXACT FAILURE POINT\nGOOD: \"handleClick uses selectedId but renderList deps array is missing selectedId\"\nBAD: \"Something might be wrong with the click handler\"\n\nSTEP 4: MINIMAL FIX\n- Add missing dependency to array\n- Add missing prop to component\n- Fix the one broken thing - don't refactor\n</debugging-process>\n\n<react-patterns>\nDEPENDENCY ARRAY BUGS (most common!):\n- useCallback/useMemo/useEffect use state but deps array missing it\n- Symptom: UI doesn't update when state changes\n- Fix: Add ALL used state variables to deps array\n\nSTATE UPDATE BUGS:\n- setState called but component doesn't re-render\n- Check if state is used in memoized callback with stale closure\n\nPROP DRILLING BUGS:\n- Prop passed but not used in child\n- Prop used but not passed from parent\n\nEVENT HANDLER BUGS:\n- Handler defined but not connected to element\n- Handler connected but wrong event type\n</react-patterns>\n\n<hailer-sdk>\nuseHailerContext() - workspace, user, permissions\nuseActivity(id) - load single activity by ID\nuseWorkflows() - list available workflows\nActivity fields keyed by FIELD ID not label\nAlways handle loading states\nuseToast() for notifications\n</hailer-sdk>\n\n<output-format>\n{\n  \"debugTrace\": \"Step-by-step: function X calls Y, which uses state Z, but useCallback deps missing Z\",\n  \"failurePoint\": \"File.tsx line N - deps array missing stateVariable\",\n  \"rootCause\": \"Stale closure - useCallback keeps old value of stateVariable\",\n  \"fix\": {\n    \"files\": [{\n      \"path\": \"src/components/File.tsx\",\n      \"action\": \"edit\",\n      \"search\": \"exact code to find\",\n      \"replace\": \"fixed code\"\n    }]\n  },\n  \"explanation\": \"Added stateVariable to deps array so callback updates when state changes\",\n  \"testSuggestions\": [\"How to verify the fix works\"]\n}\n</output-format>\n\n<rules>\n1. TRACE before fixing - follow the code path\n2. CHECK DEPS ARRAYS - most common React bug\n3. Fix ONE thing - minimal change\n4. Use EXACT file paths from provided code\n5. Search string must EXACTLY match file content\n</rules>";
+//# sourceMappingURL=prompt.d.ts.map