@hailer/mcp 0.1.10 → 0.1.12

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

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Bug Reports Module
+ *
+ * Self-contained module for bug monitoring and auto-fixing.
+ * No hardcoded IDs - discovers workflow by name pattern.
+ *
+ * Usage:
+ *   import { BugReportsModule } from './modules/bug-reports';
+ *
+ *   const module = new BugReportsModule(userContext);
+ *   await module.start();
+ *
+ * Configuration (in order of precedence):
+ * 1. Hailer "MCP Config" workflow activity named "Bug Reports Config"
+ * 2. Environment variables (BUG_MONITOR_*)
+ * 3. Default values
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIUSEPPE_SYSTEM_PROMPT = exports.GiuseppeFiles = exports.GiuseppeGit = exports.GiuseppeAI = exports.pendingClassificationRegistry = exports.pendingFixRegistry = exports.PendingRegistry = exports.getDefaultConfig = exports.discoverWorkflow = exports.loadConfig = exports.GiuseppeBot = exports.BugMonitor = exports.BugReportsModule = void 0;
+const logger_1 = require("../../lib/logger");
+const bug_monitor_1 = require("./bug-monitor");
+const giuseppe_bot_1 = require("./giuseppe-bot");
+const bug_config_1 = require("./bug-config");
+const logger = (0, logger_1.createLogger)({ component: 'bug-reports-module' });
+class BugReportsModule {
+    userContext;
+    monitor;
+    giuseppe;
+    config;
+    started = false;
+    constructor(userContext) {
+        this.userContext = userContext;
+    }
+    /**
+     * Register a bot user ID to ignore messages from
+     * Call this before start() to ensure all bots are registered
+     */
+    registerBotUser(userId) {
+        if (this.monitor) {
+            this.monitor.registerBotUser(userId);
+        }
+        else {
+            // Store for later if monitor not created yet
+            this._pendingBotUsers = this._pendingBotUsers || [];
+            this._pendingBotUsers.push(userId);
+        }
+    }
+    _pendingBotUsers;
+    /**
+     * Register a handler for when Giuseppe is disabled but a bug is found
+     * Call this before start() to ensure handler is registered
+     */
+    onGiuseppeDisabled(handler) {
+        if (this.monitor) {
+            this.monitor.onGiuseppeDisabled(handler);
+        }
+        else {
+            // Store for later if monitor not created yet
+            this._pendingGiuseppeDisabledHandlers = this._pendingGiuseppeDisabledHandlers || [];
+            this._pendingGiuseppeDisabledHandlers.push(handler);
+        }
+    }
+    _pendingGiuseppeDisabledHandlers;
+    /**
+     * Start the bug reports module
+     */
+    async start() {
+        if (this.started) {
+            logger.warn('BugReportsModule already started');
+            return;
+        }
+        logger.info('Starting Bug Reports Module...');
+        try {
+            // Load configuration
+            this.config = await (0, bug_config_1.loadConfig)(this.userContext);
+            if (!this.config.enabled) {
+                logger.info('Bug Reports Module is disabled');
+                return;
+            }
+            // Create monitor
+            this.monitor = new bug_monitor_1.BugMonitor(this.userContext);
+            // Register any pending bot users
+            if (this._pendingBotUsers) {
+                for (const userId of this._pendingBotUsers) {
+                    this.monitor.registerBotUser(userId);
+                }
+                this._pendingBotUsers = undefined;
+            }
+            // Register any pending giuseppe disabled handlers
+            if (this._pendingGiuseppeDisabledHandlers) {
+                for (const handler of this._pendingGiuseppeDisabledHandlers) {
+                    this.monitor.onGiuseppeDisabled(handler);
+                }
+                this._pendingGiuseppeDisabledHandlers = undefined;
+            }
+            // Create Giuseppe bot if auto-fix is enabled
+            if (this.config.autoFix) {
+                if (!this.config.anthropicApiKey && !process.env.ANTHROPIC_API_KEY) {
+                    logger.warn('Auto-fix enabled but no ANTHROPIC_API_KEY - Giuseppe disabled');
+                }
+                else {
+                    this.giuseppe = new giuseppe_bot_1.GiuseppeBot(this.userContext, this.config, this.monitor);
+                    // Initialize registry callback for HAL coordination
+                    this.giuseppe.initializeRegistryCallback();
+                    this.giuseppe.initializeClassificationCallbacks();
+                    // Register Giuseppe as bug handler
+                    this.monitor.onNewBug(async (bug) => {
+                        const result = await this.giuseppe.handleBug(bug);
+                        logger.info('Giuseppe fix result', {
+                            bugId: bug.id,
+                            success: result.success,
+                            summary: result.summary
+                        });
+                    });
+                    // Register Giuseppe as message handler (for approval messages)
+                    this.monitor.onMessage(async (discussionId, message, senderId) => {
+                        const result = await this.giuseppe.handleDiscussionMessage(discussionId, message, senderId);
+                        if (result.approved) {
+                            logger.info('Fix approved', {
+                                discussionId,
+                                published: result.published,
+                                error: result.error
+                            });
+                        }
+                    });
+                    logger.info('Giuseppe Bot enabled for auto-fixing');
+                }
+            }
+            // Start monitoring
+            await this.monitor.start();
+            this.started = true;
+            logger.info('Bug Reports Module started', {
+                autoFix: !!this.giuseppe,
+                notifyOnNew: this.config.notifyOnNew,
+                intervalMs: this.config.intervalMs
+            });
+        }
+        catch (error) {
+            logger.error('Failed to start Bug Reports Module', { error });
+        }
+    }
+    /**
+     * Stop the module
+     */
+    async stop() {
+        if (this.monitor) {
+            await this.monitor.stop();
+        }
+        this.started = false;
+        logger.info('Bug Reports Module stopped');
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return this.config || (0, bug_config_1.getDefaultConfig)();
+    }
+    /**
+     * Check if module is running
+     */
+    isRunning() {
+        return this.started;
+    }
+    /**
+     * Manually trigger a bug fix (for testing or manual dispatch)
+     */
+    async fixBug(bug) {
+        if (!this.giuseppe) {
+            return {
+                success: false,
+                summary: 'Giuseppe Bot not initialized (autoFix disabled or no API key)'
+            };
+        }
+        return this.giuseppe.handleBug(bug);
+    }
+    /**
+     * Register a custom bug handler
+     */
+    onNewBug(handler) {
+        if (this.monitor) {
+            this.monitor.onNewBug(handler);
+        }
+        else {
+            logger.warn('Cannot register handler - monitor not initialized');
+        }
+    }
+}
+exports.BugReportsModule = BugReportsModule;
+var bug_monitor_2 = require("./bug-monitor");
+Object.defineProperty(exports, "BugMonitor", { enumerable: true, get: function () { return bug_monitor_2.BugMonitor; } });
+var giuseppe_bot_2 = require("./giuseppe-bot");
+Object.defineProperty(exports, "GiuseppeBot", { enumerable: true, get: function () { return giuseppe_bot_2.GiuseppeBot; } });
+var bug_config_2 = require("./bug-config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return bug_config_2.loadConfig; } });
+Object.defineProperty(exports, "discoverWorkflow", { enumerable: true, get: function () { return bug_config_2.discoverWorkflow; } });
+Object.defineProperty(exports, "getDefaultConfig", { enumerable: true, get: function () { return bug_config_2.getDefaultConfig; } });
+var pending_registry_1 = require("./pending-registry");
+Object.defineProperty(exports, "PendingRegistry", { enumerable: true, get: function () { return pending_registry_1.PendingRegistry; } });
+var pending_fix_registry_1 = require("./pending-fix-registry");
+Object.defineProperty(exports, "pendingFixRegistry", { enumerable: true, get: function () { return pending_fix_registry_1.pendingFixRegistry; } });
+var pending_classification_registry_1 = require("./pending-classification-registry");
+Object.defineProperty(exports, "pendingClassificationRegistry", { enumerable: true, get: function () { return pending_classification_registry_1.pendingClassificationRegistry; } });
+// Export extracted Giuseppe modules
+var giuseppe_ai_1 = require("./giuseppe-ai");
+Object.defineProperty(exports, "GiuseppeAI", { enumerable: true, get: function () { return giuseppe_ai_1.GiuseppeAI; } });
+var giuseppe_git_1 = require("./giuseppe-git");
+Object.defineProperty(exports, "GiuseppeGit", { enumerable: true, get: function () { return giuseppe_git_1.GiuseppeGit; } });
+var giuseppe_files_1 = require("./giuseppe-files");
+Object.defineProperty(exports, "GiuseppeFiles", { enumerable: true, get: function () { return giuseppe_files_1.GiuseppeFiles; } });
+var giuseppe_prompt_1 = require("./giuseppe-prompt");
+Object.defineProperty(exports, "GIUSEPPE_SYSTEM_PROMPT", { enumerable: true, get: function () { return giuseppe_prompt_1.GIUSEPPE_SYSTEM_PROMPT; } });
+//# sourceMappingURL=index.js.map

package/dist/modules/bug-reports/pending-classification-registry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pending Classification Registry - Tracks bug classifications awaiting confirmation
+ */
+import { PendingRegistry, PendingItem } from './pending-registry';
+import type { BugReport } from './types';
+export interface PendingClassificationInfo extends PendingItem {
+    bugId: string;
+    bugName: string;
+    appId?: string;
+    appName?: string;
+    classification: 'bug' | 'feature_request' | 'unclear';
+    reason: string;
+    bug: BugReport;
+}
+declare class PendingClassificationRegistry extends PendingRegistry<PendingClassificationInfo> {
+    private fixItCallback?;
+    private notABugCallback?;
+    constructor();
+    setCallbacks(fixItCallback: (discussionId: string) => Promise<void>, notABugCallback: (discussionId: string) => Promise<void>): void;
+    triggerFixIt(discussionId: string): Promise<boolean>;
+    triggerNotABug(discussionId: string): Promise<boolean>;
+    hasPendingClassification(discussionId: string): boolean;
+    getPendingClassification(discussionId: string): PendingClassificationInfo | undefined;
+    getAllPendingClassifications(): PendingClassificationInfo[];
+}
+export declare const pendingClassificationRegistry: PendingClassificationRegistry;
+export {};
+//# sourceMappingURL=pending-classification-registry.d.ts.map

package/dist/modules/bug-reports/pending-classification-registry.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Pending Classification Registry - Tracks bug classifications awaiting confirmation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingClassificationRegistry = void 0;
+const pending_registry_1 = require("./pending-registry");
+class PendingClassificationRegistry extends pending_registry_1.PendingRegistry {
+    fixItCallback;
+    notABugCallback;
+    constructor() {
+        super('pending-classification-registry');
+    }
+    setCallbacks(fixItCallback, notABugCallback) {
+        this.fixItCallback = fixItCallback;
+        this.notABugCallback = notABugCallback;
+    }
+    async triggerFixIt(discussionId) {
+        if (!this.fixItCallback) {
+            this.logger.warn('No fixIt callback registered', { discussionId });
+            return false;
+        }
+        if (!this.has(discussionId)) {
+            this.logger.warn('No pending classification to fix', { discussionId });
+            return false;
+        }
+        this.logger.info('Triggering fix it', { discussionId });
+        await this.fixItCallback(discussionId);
+        return true;
+    }
+    async triggerNotABug(discussionId) {
+        if (!this.notABugCallback) {
+            this.logger.warn('No notABug callback registered', { discussionId });
+            return false;
+        }
+        if (!this.has(discussionId)) {
+            this.logger.warn('No pending classification to decline', { discussionId });
+            return false;
+        }
+        this.logger.info('Triggering not a bug', { discussionId });
+        await this.notABugCallback(discussionId);
+        return true;
+    }
+    // Backward-compatible aliases
+    hasPendingClassification(discussionId) { return this.has(discussionId); }
+    getPendingClassification(discussionId) { return this.get(discussionId); }
+    getAllPendingClassifications() { return this.getAll(); }
+}
+exports.pendingClassificationRegistry = new PendingClassificationRegistry();
+//# sourceMappingURL=pending-classification-registry.js.map

package/dist/modules/bug-reports/pending-fix-registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pending Fix Registry - Tracks bug fixes awaiting approval
+ */
+import { PendingRegistry, PendingItem } from './pending-registry';
+import type { BugReport, AppRegistryEntry } from './types';
+import type { FixPlan } from './giuseppe-ai';
+export interface PendingFixInfo extends PendingItem {
+    bugId: string;
+    appId: string;
+    state: 'awaiting_test' | 'awaiting_explanation';
+    fixSummary: string;
+    bug: BugReport;
+    app: AppRegistryEntry;
+    fixPlan: FixPlan;
+    filesModified: string[];
+    commitHash?: string;
+}
+declare class PendingFixRegistry extends PendingRegistry<PendingFixInfo> {
+    private retryCallback?;
+    constructor();
+    updateState(discussionId: string, state: PendingFixInfo['state']): void;
+    setRetryCallback(callback: (discussionId: string, explanation: string) => Promise<void>): void;
+    triggerRetry(discussionId: string, explanation: string): Promise<boolean>;
+    hasPendingFix(discussionId: string): boolean;
+    getPendingFix(discussionId: string): PendingFixInfo | undefined;
+    getAllPendingFixes(): PendingFixInfo[];
+}
+export declare const pendingFixRegistry: PendingFixRegistry;
+export {};
+//# sourceMappingURL=pending-fix-registry.d.ts.map

package/dist/modules/bug-reports/pending-fix-registry.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Pending Fix Registry - Tracks bug fixes awaiting approval
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingFixRegistry = void 0;
+const pending_registry_1 = require("./pending-registry");
+class PendingFixRegistry extends pending_registry_1.PendingRegistry {
+    retryCallback;
+    constructor() {
+        super('pending-fix-registry');
+    }
+    updateState(discussionId, state) {
+        const fix = this.get(discussionId);
+        if (fix) {
+            fix.state = state;
+            this.logger.debug('Updated pending fix state', { discussionId, state });
+        }
+    }
+    setRetryCallback(callback) {
+        this.retryCallback = callback;
+    }
+    async triggerRetry(discussionId, explanation) {
+        if (!this.retryCallback) {
+            this.logger.warn('No retry callback registered', { discussionId });
+            return false;
+        }
+        if (!this.has(discussionId)) {
+            this.logger.warn('No pending fix to retry', { discussionId });
+            return false;
+        }
+        this.logger.info('Triggering retry with explanation', { discussionId, explanationLength: explanation.length });
+        await this.retryCallback(discussionId, explanation);
+        return true;
+    }
+    // Backward-compatible aliases
+    hasPendingFix(discussionId) { return this.has(discussionId); }
+    getPendingFix(discussionId) { return this.get(discussionId); }
+    getAllPendingFixes() { return this.getAll(); }
+}
+exports.pendingFixRegistry = new PendingFixRegistry();
+//# sourceMappingURL=pending-fix-registry.js.map

package/dist/modules/bug-reports/pending-registry.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Generic Pending Registry Base Class
+ *
+ * Shared foundation for PendingFixRegistry and PendingClassificationRegistry.
+ * Provides Map-based storage with register/unregister/has/get/getAll methods.
+ */
+import { Logger } from '../../lib/logger';
+export interface PendingItem {
+    discussionId: string;
+    timestamp: number;
+}
+/**
+ * Generic registry for pending items keyed by discussionId
+ */
+export declare class PendingRegistry<T extends PendingItem> {
+    protected items: Map<string, T>;
+    protected logger: Logger;
+    constructor(component: string);
+    register(item: T): void;
+    unregister(discussionId: string): void;
+    has(discussionId: string): boolean;
+    get(discussionId: string): T | undefined;
+    getAll(): T[];
+    get size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=pending-registry.d.ts.map

package/dist/modules/bug-reports/pending-registry.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Generic Pending Registry Base Class
+ *
+ * Shared foundation for PendingFixRegistry and PendingClassificationRegistry.
+ * Provides Map-based storage with register/unregister/has/get/getAll methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendingRegistry = void 0;
+const logger_1 = require("../../lib/logger");
+/**
+ * Generic registry for pending items keyed by discussionId
+ */
+class PendingRegistry {
+    items = new Map();
+    logger;
+    constructor(component) {
+        this.logger = (0, logger_1.createLogger)({ component });
+    }
+    register(item) {
+        this.items.set(item.discussionId, item);
+        this.logger.debug('Registered pending item', {
+            discussionId: item.discussionId,
+            timestamp: item.timestamp
+        });
+    }
+    unregister(discussionId) {
+        this.items.delete(discussionId);
+        this.logger.debug('Unregistered pending item', { discussionId });
+    }
+    has(discussionId) {
+        return this.items.has(discussionId);
+    }
+    get(discussionId) {
+        return this.items.get(discussionId);
+    }
+    getAll() {
+        return Array.from(this.items.values());
+    }
+    get size() {
+        return this.items.size;
+    }
+    clear() {
+        this.items.clear();
+        this.logger.debug('Cleared all pending items');
+    }
+}
+exports.PendingRegistry = PendingRegistry;
+//# sourceMappingURL=pending-registry.js.map

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

@@ -0,0 +1,123 @@
+/**
+ * Bug Reports Module - Type Definitions
+ *
+ * Shared types for the bug monitoring and auto-fix system.
+ * No hardcoded IDs - everything discovered by name patterns.
+ */
+export interface BugReportsConfig {
+    /** Enable/disable the bug monitor */
+    enabled: boolean;
+    /** Workflow name pattern to find Bug Reports workflow */
+    workflowNamePattern: string;
+    /** Phase names for bug lifecycle */
+    phaseNames: {
+        new: string;
+        inProgress: string;
+        fixed: string;
+        closed: string;
+        declined: string;
+    };
+    /** Polling interval in milliseconds */
+    intervalMs: number;
+    /** Enable auto-fix via Giuseppe bot */
+    autoFix: boolean;
+    /** Post notifications to bug discussions */
+    notifyOnNew: boolean;
+    /** Anthropic API key for Giuseppe bot (if autoFix enabled) */
+    anthropicApiKey?: string;
+    /** Apps registry - maps appId to project paths */
+    appsRegistry?: Record<string, AppRegistryEntry>;
+}
+export interface AppRegistryEntry {
+    /** Local path to app project */
+    projectPath: string;
+    /** App name for reference */
+    name: string;
+    /** Git remote URL (optional) */
+    gitRemote?: string;
+}
+export interface BugReport {
+    /** Activity ID */
+    id: string;
+    /** Bug title/name */
+    name: string;
+    /** App ID this bug relates to */
+    appId?: string;
+    /** App name */
+    appName?: string;
+    /** Who reported the bug */
+    reportedBy?: string;
+    /** Bug description */
+    description: string;
+    /** Steps to reproduce */
+    stepsToReproduce?: string;
+    /** Expected behavior */
+    expectedBehavior?: string;
+    /** Actual behavior */
+    actualBehavior?: string;
+    /** Priority level */
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Discussion ID for posting updates */
+    discussionId?: string;
+    /** Workflow ID */
+    workflowId: string;
+    /** Current phase ID */
+    phaseId: string;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Who created the bug activity (user ID) */
+    createdBy?: string;
+    /** Raw field values for custom parsing */
+    rawFields?: Record<string, any>;
+}
+export interface WorkflowDiscoveryResult {
+    /** Found workflow ID */
+    workflowId: string;
+    /** Workflow name */
+    workflowName: string;
+    /** Phase ID mappings */
+    phases: {
+        new?: string;
+        inProgress?: string;
+        fixed?: string;
+        closed?: string;
+        declined?: string;
+    };
+    /** Field ID mappings (discovered by label) */
+    fields: {
+        appId?: string;
+        appName?: string;
+        description?: string;
+        stepsToReproduce?: string;
+        expectedBehavior?: string;
+        actualBehavior?: string;
+        reportedBy?: string;
+        priority?: string;
+    };
+}
+export interface FixResult {
+    success: boolean;
+    /** What was done */
+    summary: string;
+    /** Files modified */
+    filesModified?: string[];
+    /** Commit hash if committed */
+    commitHash?: string;
+    /** New version if published */
+    publishedVersion?: string;
+    /** Error message if failed */
+    error?: string;
+    /** Detailed log of actions */
+    log?: string[];
+}
+export interface GiuseppeTaskInput {
+    /** The bug to fix */
+    bug: BugReport;
+    /** App project info */
+    app: AppRegistryEntry;
+    /** Whether to auto-publish after fix */
+    autoPublish: boolean;
+    /** Hailer app ID for publishing */
+    hailerAppId?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Bug Reports Module - Type Definitions
+ *
+ * Shared types for the bug monitoring and auto-fix system.
+ * No hardcoded IDs - everything discovered by name patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/services/bug-monitor.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bug Monitor Service
+ *
+ * Periodically checks for new bug reports and can trigger auto-fix workflows.
+ * Configuration is read from Hailer's MCP Config workflow.
+ */
+export declare class BugMonitorService {
+    private interval?;
+    private config?;
+    private userContext?;
+    private bugWorkflowId?;
+    private newPhaseId?;
+    private fixedPhaseId?;
+    private processedBugIds;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private loadConfig;
+    private findBugWorkflow;
+    private checkForNewBugs;
+    private processBug;
+}
+export declare function getBugMonitor(): BugMonitorService;
+//# sourceMappingURL=bug-monitor.d.ts.map