@hailer/mcp 0.1.14 → 0.1.16

package/dist/agents/giuseppe/prompt.js

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

package/dist/agents/giuseppe/registries/pending-classification.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pending Classification Registry - Tracks bug classifications awaiting confirmation
+ */
+import { PendingRegistry, PendingItem } from './pending';
+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.d.ts.map

package/dist/agents/giuseppe/registries/pending-classification.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_1 = require("./pending");
+class PendingClassificationRegistry extends pending_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.js.map

package/dist/agents/giuseppe/registries/pending-fix.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pending Fix Registry - Tracks bug fixes awaiting approval
+ */
+import { PendingRegistry, PendingItem } from './pending';
+import type { BugReport, AppRegistryEntry } from '../types';
+import type { FixPlan } from '../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.d.ts.map

package/dist/agents/giuseppe/registries/pending-fix.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_1 = require("./pending");
+class PendingFixRegistry extends pending_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.js.map

package/dist/agents/giuseppe/registries/pending.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.d.ts.map

package/dist/agents/giuseppe/registries/pending.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.js.map

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

@@ -0,0 +1,47 @@
+/**
+ * Giuseppe Specialist Daemon
+ *
+ * A specialist daemon for bug fixing that extends SpecialistDaemon.
+ * Giuseppe handles bug discussions naturally - responds to all messages
+ * in bug discussions (not just @mentions).
+ *
+ * Tools: Uses MCP tools registered in the tool registry.
+ */
+import { SpecialistDaemon, SpecialistDaemonConfig } from "../shared/specialist";
+import { IncomingMessage } from "../shared/base";
+import { HailerSignal } from "../../mcp/signal-handler";
+export interface GiuseppeSpecialistConfig extends SpecialistDaemonConfig {
+    /** Base path for app projects */
+    appsBasePath?: string;
+}
+export declare class GiuseppeSpecialist extends SpecialistDaemon {
+    private giuseppeLogger;
+    private bugDiscussions;
+    constructor(config: GiuseppeSpecialistConfig);
+    /**
+     * Register a bug discussion for Giuseppe to handle
+     * Call this when a new bug is detected
+     */
+    registerBugDiscussion(discussionId: string, bugId: string, bugName: string, appPath?: string): void;
+    /**
+     * Unregister a bug discussion (bug resolved)
+     */
+    unregisterBugDiscussion(discussionId: string): void;
+    /**
+     * Check if Giuseppe is handling a discussion
+     */
+    isHandlingDiscussion(discussionId: string): boolean;
+    /**
+     * Override to respond to ALL messages in bug discussions (not just @mentions)
+     */
+    protected extractIncomingMessage(signal: HailerSignal): Promise<IncomingMessage | null>;
+    /**
+     * Giuseppe's tool whitelist - bug fixing tools
+     */
+    protected getToolWhitelist(): string[];
+    /**
+     * Override system prompt to add Giuseppe-specific instructions
+     */
+    protected getSystemPrompt(): string;
+}
+//# sourceMappingURL=specialist.d.ts.map

package/dist/agents/giuseppe/specialist.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Giuseppe Specialist Daemon
+ *
+ * A specialist daemon for bug fixing that extends SpecialistDaemon.
+ * Giuseppe handles bug discussions naturally - responds to all messages
+ * in bug discussions (not just @mentions).
+ *
+ * Tools: Uses MCP tools registered in the tool registry.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GiuseppeSpecialist = void 0;
+const specialist_1 = require("../shared/specialist");
+const logger_1 = require("../../lib/logger");
+class GiuseppeSpecialist extends specialist_1.SpecialistDaemon {
+    giuseppeLogger;
+    // Track bug discussions Giuseppe is handling
+    bugDiscussions = new Map();
+    constructor(config) {
+        super(config);
+        this.giuseppeLogger = (0, logger_1.createLogger)({
+            component: "GiuseppeSpecialist",
+            botId: config.botClient.userId,
+        });
+    }
+    /**
+     * Register a bug discussion for Giuseppe to handle
+     * Call this when a new bug is detected
+     */
+    registerBugDiscussion(discussionId, bugId, bugName, appPath) {
+        this.bugDiscussions.set(discussionId, { bugId, bugName, appPath });
+        this.giuseppeLogger.info("Registered bug discussion", { discussionId, bugId, bugName });
+    }
+    /**
+     * Unregister a bug discussion (bug resolved)
+     */
+    unregisterBugDiscussion(discussionId) {
+        this.bugDiscussions.delete(discussionId);
+    }
+    /**
+     * Check if Giuseppe is handling a discussion
+     */
+    isHandlingDiscussion(discussionId) {
+        return this.bugDiscussions.has(discussionId);
+    }
+    /**
+     * Override to respond to ALL messages in bug discussions (not just @mentions)
+     */
+    async extractIncomingMessage(signal) {
+        // FIRST: Check if this is a bug discussion we're handling (before @mention check)
+        const discussionId = signal.data?.discussion;
+        this.giuseppeLogger.debug("Checking signal for bug discussion", {
+            discussionId,
+            registeredDiscussions: Array.from(this.bugDiscussions.keys()),
+            signalType: signal.type,
+        });
+        // Check if this is a registered bug discussion
+        const bugInfo = discussionId ? this.bugDiscussions.get(discussionId) : null;
+        if (!bugInfo) {
+            // Not a bug discussion - fall back to @mention check (parent behavior)
+            return super.extractIncomingMessage(signal);
+        }
+        this.giuseppeLogger.info("Processing message in registered bug discussion", {
+            discussionId,
+            bugName: bugInfo.bugName,
+        });
+        // Get the message content
+        const senderId = signal.data?.uid;
+        if (!senderId)
+            return null;
+        // Skip our own messages
+        if (senderId === this.botClient.userId)
+            return null;
+        // Fetch the message content using the Hailer API
+        try {
+            const msgId = signal.data?.msg_id;
+            this.giuseppeLogger.info("Processing bug discussion message", {
+                discussionId,
+                bugName: bugInfo.bugName,
+                msgId,
+            });
+            // Fetch actual message content from API
+            const response = await this.botClient.client.socket.request("v3.discussion.message.latest", [discussionId]);
+            const messages = response?.messages || [];
+            const targetMessage = messages.find((msg) => msg._id === msgId);
+            if (!targetMessage) {
+                this.giuseppeLogger.warn("Message not found in discussion", { discussionId, msgId });
+                return null;
+            }
+            // Extract content - try both field names
+            const messageContent = targetMessage.msg || targetMessage.content || "";
+            if (!messageContent) {
+                this.giuseppeLogger.warn("Message has no content", { discussionId, msgId, targetMessage });
+                return null;
+            }
+            // Get sender name from cache or message
+            const cachedUser = this.botClient.workspaceCache?.usersById[senderId];
+            const senderName = cachedUser?.fullName
+                || `${cachedUser?.firstname || ''} ${cachedUser?.lastname || ''}`.trim()
+                || targetMessage.userName
+                || "User";
+            this.giuseppeLogger.debug("Extracted message content", {
+                discussionId,
+                msgId,
+                contentPreview: messageContent.substring(0, 50),
+                senderName,
+            });
+            // Return a properly structured IncomingMessage with actual content
+            return {
+                id: msgId,
+                discussionId,
+                senderId,
+                senderName,
+                content: messageContent,
+                timestamp: Date.now(),
+                priority: "high",
+                priorityReason: `Bug discussion: ${bugInfo.bugName}`,
+                workspaceId: signal.workspaceId || '',
+                linkedActivityId: bugInfo.bugId,
+                linkedActivityName: bugInfo.bugName,
+                isMention: false,
+                isReplyToBot: false,
+                isDirectMessage: true,
+            };
+        }
+        catch (error) {
+            this.giuseppeLogger.warn("Failed to process bug discussion message", { discussionId, error });
+            return null;
+        }
+    }
+    /**
+     * Giuseppe's tool whitelist - bug fixing tools
+     */
+    getToolWhitelist() {
+        return [
+            // Standard Hailer tools
+            "list_workflows",
+            "list_workflow_phases",
+            "get_workflow_schema",
+            "list_activities",
+            "show_activity_by_id",
+            "update_activity",
+            "add_discussion_message",
+            "fetch_discussion_messages",
+            "get_activity_from_discussion",
+            "search_workspace_users",
+            // Giuseppe's bug-fixing tools (registered as MCP tools)
+            "giuseppe_find_app",
+            "giuseppe_list_files",
+            "giuseppe_read_file",
+            // "giuseppe_write_file",  // Disabled - use giuseppe_apply_fix instead
+            "giuseppe_apply_fix", // search/replace pattern (token-efficient)
+            "giuseppe_run_build",
+            "giuseppe_git_status",
+            "giuseppe_git_pull",
+            "giuseppe_git_commit",
+            "giuseppe_git_push",
+            "giuseppe_git_revert",
+            "giuseppe_publish_app",
+        ];
+    }
+    /**
+     * Override system prompt to add Giuseppe-specific instructions
+     */
+    getSystemPrompt() {
+        const basePrompt = super.getSystemPrompt();
+        const giuseppeAddition = `
+
+<giuseppe_mode>
+You are Giuseppe, the bug-fixing specialist. You handle bug reports through natural conversation.
+
+**WORKFLOW - Follow this order:**
+
+1. **ANALYZE** - When you see a new bug:
+   - Greet the user and acknowledge the bug
+   - Use giuseppe_find_app to locate the app project
+   - Read the bug description carefully
+   - Ask clarifying questions if needed
+
+2. **INVESTIGATE** - Understand the code:
+   - Use giuseppe_git_status to check repo state
+   - Use giuseppe_git_pull if behind remote
+   - Use giuseppe_list_files to see project structure
+   - Use giuseppe_read_file to examine relevant code
+   - Use giuseppe_run_build to check current state
+
+3. **PROPOSE FIX** - Present your plan:
+   - Explain what you found (root cause)
+   - Describe your proposed fix clearly
+   - List the files you'll modify
+   - **ASK: "Does this fix plan look good? Reply 'approved' to proceed."**
+
+4. **EXECUTE** (only after user says "approved"):
+   - Use giuseppe_apply_fix with search/replace pattern (more efficient than rewriting entire files)
+   - Example:
+     giuseppe_apply_fix({
+       appPath: "my-app",
+       fixes: [{
+         path: "src/App.tsx",
+         action: "edit",
+         search: "const oldCode = () => {\\n  // buggy code\\n}",
+         replace: "const oldCode = () => {\\n  // fixed code\\n}"
+       }]
+     })
+   - The 'search' must EXACTLY match the code in the file
+   - Use giuseppe_run_build to verify fix works
+   - If build fails, adjust the fix and try again
+   - Use giuseppe_git_commit with clear message
+
+5. **PUBLISH** (only after asking):
+   - **ASK: "Fix is ready. Should I publish to production?"**
+   - If user confirms, use giuseppe_publish_app
+   - Report success with version number
+
+**BUG STATUS - Update phases:**
+1. First call list_workflow_phases(workflowId) to get available phases and their IDs
+2. Find the phase you need (e.g., "Fixed", "In Progress", "Declined")
+3. Use the hex ID in update_activity: update_activity(activityId, { phaseId: "actual-hex-id-here" })
+- FIXED: move to "Fixed" phase
+- DECLINED: move to "Declined" phase
+- WORKING: move to "In Progress" phase
+
+**RULES:**
+- NEVER execute fixes without user approval
+- NEVER publish without explicit confirmation
+- Be conversational and explain in plain language
+- If something fails, explain the error and ask how to proceed
+- ALWAYS update bug phase when status changes (look up phase ID first with list_workflow_phases)
+- You can add notes to the bug by updating its description field
+
+**You're responding to messages in a bug discussion - no need for @mentions.**
+</giuseppe_mode>`;
+        return basePrompt + giuseppeAddition;
+    }
+}
+exports.GiuseppeSpecialist = GiuseppeSpecialist;
+//# sourceMappingURL=specialist.js.map