@hailer/mcp 0.1.10 → 0.1.12

package/dist/modules/bug-reports/bug-config.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Bug Reports Module - Configuration Discovery
+ *
+ * Discovers Bug Reports workflow by name pattern.
+ * No hardcoded IDs - works in any workspace.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverWorkflow = discoverWorkflow;
+exports.loadConfig = loadConfig;
+exports.getDefaultConfig = getDefaultConfig;
+exports.saveConfig = saveConfig;
+const logger_1 = require("../../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'bug-reports-config' });
+/**
+ * Discover Bug Reports workflow in a workspace
+ */
+async function discoverWorkflow(userContext, config) {
+    const { workspaceCache } = userContext;
+    // Find workflow by name pattern
+    const workflows = Object.values(workspaceCache.rawInit.processes || {});
+    const bugWorkflow = workflows.find((w) => w.name?.toLowerCase().includes(config.workflowNamePattern.toLowerCase()));
+    if (!bugWorkflow) {
+        logger.warn(`Workflow matching "${config.workflowNamePattern}" not found`);
+        return null;
+    }
+    logger.info('Found Bug Reports workflow', {
+        id: bugWorkflow._id,
+        name: bugWorkflow.name
+    });
+    // Discover phases by name
+    const phases = Object.values(bugWorkflow.phases || {});
+    const phaseMap = {
+        new: phases.find((p) => p.name?.toLowerCase() === config.phaseNames.new.toLowerCase())?._id,
+        inProgress: phases.find((p) => p.name?.toLowerCase() === config.phaseNames.inProgress.toLowerCase())?._id,
+        fixed: phases.find((p) => p.name?.toLowerCase() === config.phaseNames.fixed.toLowerCase())?._id,
+        closed: phases.find((p) => p.name?.toLowerCase() === config.phaseNames.closed.toLowerCase())?._id,
+        declined: phases.find((p) => p.name?.toLowerCase() === config.phaseNames.declined.toLowerCase())?._id
+    };
+    // Discover fields by label pattern
+    const fieldMap = await discoverFields(bugWorkflow);
+    const result = {
+        workflowId: bugWorkflow._id,
+        workflowName: bugWorkflow.name,
+        phases: phaseMap,
+        fields: fieldMap
+    };
+    logger.info('Workflow discovery complete', {
+        workflowId: result.workflowId,
+        phases: Object.entries(result.phases).filter(([, v]) => v).map(([k]) => k),
+        fields: Object.entries(result.fields).filter(([, v]) => v).map(([k]) => k)
+    });
+    return result;
+}
+/**
+ * Discover field IDs by label patterns
+ */
+async function discoverFields(workflow) {
+    const fields = {};
+    // Get all fields from all phases
+    const allFields = [];
+    for (const phase of Object.values(workflow.phases || {})) {
+        for (const field of Object.values(phase.fields || {})) {
+            allFields.push(field);
+        }
+    }
+    // Match fields by label patterns
+    const patterns = {
+        appId: /app\s*(id|identifier)/i,
+        appName: /app\s*name/i,
+        description: /description|details|bug\s*description/i,
+        stepsToReproduce: /steps|reproduce|how\s*to|repro/i,
+        expectedBehavior: /expected|should/i,
+        actualBehavior: /actual|instead|result/i,
+        reportedBy: /reported\s*by|reporter|submitter|author/i,
+        priority: /priority|severity|urgency/i
+    };
+    for (const field of allFields) {
+        const label = field.label || field.key || '';
+        for (const [key, pattern] of Object.entries(patterns)) {
+            if (!fields[key] && pattern.test(label)) {
+                fields[key] = field._id;
+                logger.debug(`Mapped field "${label}" -> ${key}`, { fieldId: field._id });
+            }
+        }
+    }
+    return fields;
+}
+/**
+ * Load config from MCP Config workflow or environment
+ */
+async function loadConfig(userContext) {
+    const { workspaceCache, hailer } = userContext;
+    // Try to load from MCP Config workflow
+    try {
+        const workflows = Object.values(workspaceCache.rawInit.processes || {});
+        const mcpConfigWorkflow = workflows.find((w) => w.name?.toLowerCase().includes('mcp config'));
+        if (mcpConfigWorkflow) {
+            const phases = Object.values(mcpConfigWorkflow.phases || {});
+            if (phases.length > 0) {
+                const result = await hailer.fetchActivityList(mcpConfigWorkflow._id, phases[0]._id, 100);
+                const activities = result?.activities || result || [];
+                const configActivity = activities.find((a) => a.name === 'Bug Monitor Service' || a.name === 'Bug Reports Config');
+                if (configActivity) {
+                    const fullActivity = await hailer.fetchActivityById(configActivity._id);
+                    const configJson = extractJsonFromFields(fullActivity.fields);
+                    if (configJson) {
+                        logger.info('Loaded Bug Reports config from Hailer');
+                        return {
+                            ...getDefaultConfig(),
+                            ...configJson
+                        };
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.warn('Failed to load config from Hailer, using defaults', { error });
+    }
+    // Fall back to environment variables
+    return loadConfigFromEnv();
+}
+/**
+ * Extract JSON config from activity fields
+ */
+function extractJsonFromFields(fields) {
+    for (const fieldData of Object.values(fields || {})) {
+        if (fieldData.type === 'textarea' && fieldData.value) {
+            try {
+                return JSON.parse(fieldData.value);
+            }
+            catch {
+                // Not JSON, continue
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Load config from environment variables
+ */
+function loadConfigFromEnv() {
+    return {
+        enabled: process.env.BUG_MONITOR_ENABLED === 'true',
+        workflowNamePattern: process.env.BUG_MONITOR_WORKFLOW_PATTERN || 'Bug Reports',
+        phaseNames: {
+            new: process.env.BUG_MONITOR_PHASE_NEW || 'New',
+            inProgress: process.env.BUG_MONITOR_PHASE_IN_PROGRESS || 'In Progress',
+            fixed: process.env.BUG_MONITOR_PHASE_FIXED || 'Fixed',
+            closed: process.env.BUG_MONITOR_PHASE_CLOSED || 'Closed',
+            declined: process.env.BUG_MONITOR_PHASE_DECLINED || 'Declined'
+        },
+        intervalMs: parseInt(process.env.BUG_MONITOR_INTERVAL_MS || '300000', 10),
+        autoFix: process.env.BUG_MONITOR_AUTO_FIX === 'true',
+        notifyOnNew: process.env.BUG_MONITOR_NOTIFY !== 'false',
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY
+    };
+}
+/**
+ * Get default configuration
+ */
+function getDefaultConfig() {
+    return {
+        enabled: false,
+        workflowNamePattern: 'Bug Reports',
+        phaseNames: {
+            new: 'New',
+            inProgress: 'In Progress',
+            fixed: 'Fixed',
+            closed: 'Closed',
+            declined: 'Declined'
+        },
+        intervalMs: 300000,
+        autoFix: false,
+        notifyOnNew: true
+    };
+}
+/**
+ * Save config back to Hailer (creates/updates config activity)
+ */
+async function saveConfig(userContext, config) {
+    // TODO: Implement save config to MCP Config workflow
+    logger.warn('saveConfig not yet implemented');
+    return false;
+}
+//# sourceMappingURL=bug-config.js.map

package/dist/modules/bug-reports/bug-monitor.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Bug Reports Module - Bug Monitor Service
+ *
+ * Polls for new bug reports and dispatches them for processing.
+ * No hardcoded IDs - discovers workflow by name pattern.
+ */
+import type { UserContext } from '../../mcp/UserContextCache';
+import type { BugReportsConfig, BugReport, WorkflowDiscoveryResult } from './types';
+export type BugHandler = (bug: BugReport, userContext: UserContext) => Promise<void>;
+export type MessageHandler = (discussionId: string, message: string, senderId: string) => Promise<void>;
+export type GiuseppeDisabledHandler = (bug: BugReport) => Promise<void>;
+export declare class BugMonitor {
+    private userContext;
+    private interval?;
+    private unsubscribeFromSignals?;
+    private config?;
+    private discovery?;
+    private processedBugIds;
+    private processedMessageIds;
+    private static readonly PROCESSED_MAX_AGE_MS;
+    private handlers;
+    private messageHandlers;
+    private giuseppeDisabledHandlers;
+    private watchedDiscussions;
+    private botUserIds;
+    constructor(userContext: UserContext);
+    /**
+     * Register a bot user ID to ignore messages from
+     */
+    registerBotUser(userId: string): void;
+    /**
+     * Register a handler for new bugs
+     */
+    onNewBug(handler: BugHandler): void;
+    /**
+     * Register a handler for discussion messages
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Register a handler for when Giuseppe is disabled but a bug is found
+     */
+    onGiuseppeDisabled(handler: GiuseppeDisabledHandler): void;
+    /**
+     * Start watching a discussion for approval messages
+     */
+    watchDiscussion(discussionId: string): void;
+    /**
+     * Stop watching a discussion
+     */
+    unwatchDiscussion(discussionId: string): void;
+    /**
+     * Clean up old entries from processed ID caches to prevent memory leaks
+     */
+    private cleanupProcessedCaches;
+    /**
+     * Start monitoring for bugs
+     */
+    start(): Promise<void>;
+    /**
+     * Stop monitoring
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current config
+     */
+    getConfig(): BugReportsConfig | undefined;
+    /**
+     * Get workflow discovery result
+     */
+    getDiscovery(): WorkflowDiscoveryResult | undefined;
+    /**
+     * Check for new bugs in the "New" phase
+     */
+    private checkForNewBugs;
+    /**
+     * Check for new messages in watched discussions
+     */
+    private checkForNewMessages;
+    /**
+     * Handle incoming message signal (real-time, replaces polling)
+     */
+    private handleMessageSignal;
+    /**
+     * Parse activity into BugReport
+     */
+    private parseActivity;
+    /**
+     * Parse priority value
+     */
+    private parsePriority;
+    /**
+     * Extract description from fields as fallback
+     */
+    private extractDescription;
+    /**
+     * Process a bug through all handlers
+     */
+    private processBug;
+    /**
+     * Post notification to bug discussion
+     */
+    private postNotification;
+    /**
+     * Move bug to a different phase
+     */
+    moveBugToPhase(bugId: string, phase: 'inProgress' | 'fixed' | 'closed' | 'declined'): Promise<boolean>;
+}
+//# sourceMappingURL=bug-monitor.d.ts.map