@hailer/mcp 0.1.16 → 0.2.1

package/dist/client/services/message-formatter.js

@@ -1,353 +0,0 @@
-"use strict";
-/**
- * Message Formatter Service
- *
- * Handles formatting of messages for Hailer:
- * - Converting @mentions and #activity tags to Hailer tags
- * - Resolving user/activity IDs via API
- * - Extracting tag links for messenger.send
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageFormatterService = void 0;
-class MessageFormatterService {
-    botClient;
-    logger;
-    callMcpTool;
-    constructor(botClient, logger, callMcpTool) {
-        this.botClient = botClient;
-        this.logger = logger;
-        this.callMcpTool = callMcpTool;
-    }
-    /**
-     * Format a Hailer tag for mentioning a user or activity
-     * Hailer requires ZWNBSP (U+FEFF) around the tag
-     */
-    formatHailerTag(targetId, displayName) {
-        const ZWNBSP = '\uFEFF';
-        return `${ZWNBSP}[hailerTag|${displayName}](${targetId})${ZWNBSP}`;
-    }
-    /**
-     * Get user's display name from workspace cache
-     */
-    getUserDisplayName(userId) {
-        const cache = this.botClient.workspaceCache;
-        if (!cache)
-            return null;
-        const user = cache.usersById[userId];
-        if (!user)
-            return null;
-        return user.fullName || `${user.firstname || ''} ${user.lastname || ''}`.trim() || null;
-    }
-    /**
-     * Look up user by ID and create a Hailer tag
-     */
-    createUserTagById(userId) {
-        const cache = this.botClient.workspaceCache;
-        if (!cache)
-            return null;
-        const user = cache.usersById[userId];
-        if (!user)
-            return null;
-        const displayName = user.fullName || `${user.firstname} ${user.lastname}`.trim();
-        return this.formatHailerTag(userId, displayName);
-    }
-    /**
-     * Look up user by name and create a Hailer tag
-     */
-    createUserTagByName(name) {
-        const cache = this.botClient.workspaceCache;
-        if (!cache)
-            return null;
-        const nameLower = name.toLowerCase();
-        const user = cache.users.find(u => {
-            const fullName = u.fullName || `${u.firstname} ${u.lastname}`.trim();
-            return fullName.toLowerCase() === nameLower ||
-                u.firstname?.toLowerCase() === nameLower ||
-                u.lastname?.toLowerCase() === nameLower;
-        });
-        if (!user)
-            return null;
-        const displayName = user.fullName || `${user.firstname} ${user.lastname}`.trim();
-        return this.formatHailerTag(user.id, displayName);
-    }
-    /**
-     * Convert @mentions and #activity tags in response to Hailer tags
-     * Supports:
-     * - @userId (24-char hex MongoDB ID) → user tag
-     * - @"Full Name" (quoted name lookup) → user tag
-     * - @FirstName (single word name lookup) → user tag
-     * - #activityId (24-char hex) → activity tag
-     * - #"Activity Name" (quoted) → activity tag (requires lookup)
-     */
-    convertMentionsToTags(content) {
-        // User mentions (from cache)
-        const cache = this.botClient.workspaceCache;
-        if (cache) {
-            // Pattern 1: @userId (24-char hex)
-            content = content.replace(/@([a-f0-9]{24})\b/gi, (match, userId) => {
-                const tag = this.createUserTagById(userId);
-                return tag || match;
-            });
-            // Pattern 2: @"Full Name" (quoted)
-            content = content.replace(/@"([^"]+)"/g, (match, name) => {
-                const tag = this.createUserTagByName(name);
-                return tag || match;
-            });
-            // Pattern 3: @FirstName (single word, capitalized)
-            content = content.replace(/@([A-Z][a-z]+)\b/g, (match, name) => {
-                const tag = this.createUserTagByName(name);
-                return tag || match;
-            });
-        }
-        // Activity tags (#activityId and #"Name") are handled by
-        // resolveActivityTags (async) which runs before this
-        return content;
-    }
-    /**
-     * Resolve user tags - look up names for IDs via API when not in cache
-     * Handles @userId (24-char hex) format
-     */
-    async resolveUserTags(content) {
-        const pattern = /@([a-f0-9]{24})\b/gi;
-        const matches = [...content.matchAll(pattern)];
-        for (const match of matches) {
-            const userId = match[1];
-            // Try cache first
-            const cachedTag = this.createUserTagById(userId);
-            if (cachedTag) {
-                content = content.replace(match[0], cachedTag);
-                this.logger.debug("User tag from cache", { userId });
-                continue;
-            }
-            // Fallback to API
-            try {
-                this.logger.info("Resolving user tag via API", { userId });
-                const result = await this.callMcpTool("search_workspace_users", { query: userId });
-                const resultText = result?.content?.[0]?.text;
-                if (resultText) {
-                    // Parse the JSON array from the response
-                    // Response format: "Found X users:\n\n```json\n[...]\n```"
-                    const jsonMatch = resultText.match(/```json\s*([\s\S]*?)\s*```/);
-                    if (jsonMatch) {
-                        const users = JSON.parse(jsonMatch[1]);
-                        const user = users.find((u) => u._id === userId);
-                        if (user) {
-                            const displayName = `${user.firstname || ''} ${user.lastname || ''}`.trim() || user.fullName || userId;
-                            const tag = this.formatHailerTag(userId, displayName);
-                            content = content.replace(match[0], tag);
-                            this.logger.info("Created user tag from API", { userId, displayName });
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn("Failed to resolve user tag", { userId, error });
-                // Leave as @userId - won't be clickable but visible
-            }
-        }
-        return content;
-    }
-    /**
-     * Resolve activity tags - look up names for IDs and IDs for names
-     * Handles both #activityId and #"Activity Name" formats
-     */
-    async resolveActivityTags(content) {
-        // Pattern 1: #activityId (24-char hex) - need to look up the name
-        const activityIdPattern = /#([a-f0-9]{24})\b/gi;
-        const idMatches = [...content.matchAll(activityIdPattern)];
-        for (const match of idMatches) {
-            const activityId = match[1];
-            try {
-                this.logger.info("Resolving activity tag by ID", { activityId });
-                // Fetch activity by ID to get its name
-                const result = await this.callMcpTool("show_activity_by_id", {
-                    activityId: activityId,
-                });
-                const resultText = result?.content?.[0]?.text;
-                this.logger.debug("show_activity_by_id response", {
-                    hasResult: !!resultText,
-                    preview: resultText?.substring(0, 200)
-                });
-                if (resultText) {
-                    // Response format: "✅ Loaded activity with ID "xxx":\n\n{ JSON }"
-                    // Extract the JSON part after the header
-                    const jsonMatch = resultText.match(/\{[\s\S]*\}/);
-                    if (jsonMatch) {
-                        const parsed = JSON.parse(jsonMatch[0]);
-                        const activityName = parsed.name;
-                        this.logger.info("Extracted activity name", { activityId, activityName });
-                        if (activityName) {
-                            const tag = this.formatHailerTag(activityId, activityName);
-                            content = content.replace(match[0], tag);
-                            this.logger.info("Created activity tag", { tag });
-                        }
-                    }
-                    else {
-                        this.logger.warn("Could not extract JSON from response", { preview: resultText.substring(0, 100) });
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn("Failed to resolve activity ID tag", { activityId, error });
-                // Leave as #id - won't be clickable but at least visible
-            }
-        }
-        // Pattern 2: #"Activity Name" - need to look up the ID
-        // This is harder because list_activities requires workflowId/phaseId
-        // For now, search in each workflow until we find a match
-        const activityNamePattern = /#"([^"]+)"/g;
-        const nameMatches = [...content.matchAll(activityNamePattern)];
-        for (const match of nameMatches) {
-            const activityName = match[1];
-            try {
-                // Get list of workflows first
-                const workflowsResult = await this.callMcpTool("list_workflows_minimal", {});
-                const workflowsText = workflowsResult?.content?.[0]?.text;
-                if (workflowsText) {
-                    // Extract workflow IDs from the response (format varies)
-                    const workflowIdMatches = workflowsText.matchAll(/"_id":\s*"([a-f0-9]{24})"/gi);
-                    const workflowIds = [...workflowIdMatches].map(m => m[1]);
-                    // Search each workflow for the activity
-                    for (const workflowId of workflowIds.slice(0, 5)) { // Limit to first 5 workflows
-                        try {
-                            const phasesResult = await this.callMcpTool("list_workflow_phases", { workflowId });
-                            const phasesText = phasesResult?.content?.[0]?.text;
-                            if (phasesText) {
-                                const phaseIdMatches = phasesText.matchAll(/"_id":\s*"([a-f0-9]{24})"/gi);
-                                const phaseIds = [...phaseIdMatches].map(m => m[1]);
-                                for (const phaseId of phaseIds.slice(0, 3)) { // Limit to first 3 phases
-                                    const activitiesResult = await this.callMcpTool("list_activities", {
-                                        workflowId,
-                                        phaseId,
-                                        search: activityName,
-                                        limit: 1,
-                                    });
-                                    const activitiesText = activitiesResult?.content?.[0]?.text;
-                                    if (activitiesText) {
-                                        // Look for activity ID and name in the response
-                                        const activityIdMatch = activitiesText.match(/"_id":\s*"([a-f0-9]{24})"/i);
-                                        if (activityIdMatch) {
-                                            const foundId = activityIdMatch[1];
-                                            const tag = this.formatHailerTag(foundId, activityName);
-                                            content = content.replace(match[0], tag);
-                                            break; // Found it, stop searching
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        catch {
-                            // Continue to next workflow
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn("Failed to resolve activity name tag", { activityName, error });
-                // Leave the original #"Name" in place
-            }
-        }
-        return content;
-    }
-    /**
-     * Convert Hailer URLs to Hailer tags
-     * Handles:
-     * - https://app.hailer.com/#/activities/{activityId}
-     * - https://app.hailer.com/#/discussions/{discussionId}
-     */
-    async resolveHailerUrls(content) {
-        // Pattern for activity URLs
-        const activityUrlPattern = /https?:\/\/app\.hailer\.com\/#\/activities\/([a-f0-9]{24})/gi;
-        const activityMatches = [...content.matchAll(activityUrlPattern)];
-        for (const match of activityMatches) {
-            const activityId = match[1];
-            try {
-                const result = await this.callMcpTool("show_activity_by_id", { activityId });
-                const resultText = result?.content?.[0]?.text;
-                if (resultText) {
-                    const jsonMatch = resultText.match(/\{[\s\S]*\}/);
-                    if (jsonMatch) {
-                        const parsed = JSON.parse(jsonMatch[0]);
-                        const activityName = parsed.name;
-                        if (activityName) {
-                            const tag = this.formatHailerTag(activityId, activityName);
-                            content = content.replace(match[0], tag);
-                            this.logger.debug("Converted activity URL to tag", { activityId, activityName });
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.debug("Failed to resolve activity URL", { activityId, error });
-                // Leave URL as-is
-            }
-        }
-        // Pattern for discussion URLs - need to look up the linked activity
-        const discussionUrlPattern = /https?:\/\/app\.hailer\.com\/#\/discussions\/([a-f0-9]{24})/gi;
-        const discussionMatches = [...content.matchAll(discussionUrlPattern)];
-        for (const match of discussionMatches) {
-            const discussionId = match[1];
-            try {
-                // Load discussion to get linked activity
-                const discussionResponse = await this.botClient.client.socket.request("messenger.load_discussions", [[discussionId]]);
-                if (discussionResponse && discussionResponse[discussionId]) {
-                    const discData = discussionResponse[discussionId];
-                    const linkedActivityId = discData.linked_activity;
-                    const discussionName = discData.name;
-                    if (linkedActivityId) {
-                        // It's an activity discussion - use the activity ID for the tag
-                        const tag = this.formatHailerTag(linkedActivityId, discussionName || "Activity");
-                        content = content.replace(match[0], tag);
-                        this.logger.debug("Converted discussion URL to activity tag", { discussionId, linkedActivityId, discussionName });
-                    }
-                    else if (discussionName) {
-                        // It's a standalone discussion - use discussion name but discussion ID
-                        const tag = this.formatHailerTag(discussionId, discussionName);
-                        content = content.replace(match[0], tag);
-                        this.logger.debug("Converted discussion URL to discussion tag", { discussionId, discussionName });
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.debug("Failed to resolve discussion URL", { discussionId, error });
-                // Leave URL as-is
-            }
-        }
-        return content;
-    }
-    /**
-     * Extract link metadata from hailerTag formatted content
-     * Returns array of links for the messenger.send API
-     */
-    extractTagLinks(content) {
-        const links = [];
-        // Match all hailerTag patterns: [hailerTag|Name](id)
-        const tagPattern = /\[hailerTag\|[^\]]+\]\(([a-f0-9]{24})\)/gi;
-        const matches = content.matchAll(tagPattern);
-        for (const match of matches) {
-            const targetId = match[1];
-            // Determine if it's a user or activity based on context
-            // For now, check if it's in the user cache
-            const isUser = this.botClient.workspaceCache?.usersById[targetId];
-            links.push({
-                target: targetId,
-                targetType: isUser ? 'user' : 'activity',
-                type: 'linked-to'
-            });
-        }
-        return links;
-    }
-    /**
-     * Format incoming message for LLM consumption
-     */
-    formatIncomingMessage(message) {
-        const priorityTag = message.priority === "high" ? " priority=\"high\"" : "";
-        const reasonAttr = message.priority === "high" ? ` reason="${message.priorityReason}"` : "";
-        const activityAttr = message.linkedActivityId ? ` activity_id="${message.linkedActivityId}"` : "";
-        return `<incoming discussion="${message.discussionId}"${activityAttr} from="${message.senderName}" user_id="${message.senderId}" timestamp="${new Date(message.timestamp).toISOString()}"${priorityTag}${reasonAttr}>
-${message.content}
-</incoming>`;
-    }
-}
-exports.MessageFormatterService = MessageFormatterService;
-//# sourceMappingURL=message-formatter.js.map

package/dist/client/services/session-logger.d.ts

@@ -1,106 +0,0 @@
-/**
- * Session Logger Service
- *
- * Manages per-activity session tracking and logging to Hailer workflows:
- * - Tracks metrics (tokens, tool calls, messages)
- * - Logs completed sessions to SESSION_LOG workflow
- * - Manages idle session detection and flushing
- */
-import Anthropic from "@anthropic-ai/sdk";
-import { Logger } from "../../lib/logger";
-import { ActivitySession, McpToolCallback } from "../types";
-import { WorkspaceSchemaCacheService } from "./workspace-schema-cache";
-/** Memory entry loaded from SESSION_LOG */
-export interface MemoryEntry {
-    sessionId: string;
-    timestamp: number;
-    summary: string;
-    linkedActivityId?: string;
-}
-export declare class SessionLoggerService {
-    private agentDirectoryId;
-    private logger;
-    private callMcpTool;
-    private getDefaultTeamId;
-    private activitySessions;
-    private lastGlobalLogId;
-    private idleCheckTimer;
-    private anthropicClient;
-    private schemaCache;
-    private currentWorkspaceId;
-    constructor(agentDirectoryId: string | null, logger: Logger, callMcpTool: McpToolCallback, getDefaultTeamId: () => string | undefined);
-    /**
-     * Set the workspace schema cache for dynamic ID lookup
-     */
-    setSchemaCache(cache: WorkspaceSchemaCacheService, workspaceId: string): void;
-    /**
-     * Get Session Log schema from cache for a specific workspace
-     */
-    private getSessionLogSchema;
-    /**
-     * Set Anthropic client for generating summaries
-     */
-    setAnthropicClient(client: Anthropic): void;
-    /**
-     * Get or create an activity session for tracking
-     * Multi-tenant: workspaceId is required for proper schema lookup
-     */
-    getOrCreateActivitySession(message: {
-        linkedActivityId?: string;
-        linkedActivityName?: string;
-        discussionId: string;
-        workspaceId: string;
-    }): ActivitySession;
-    /**
-     * Get session by key
-     */
-    getSession(key: string): ActivitySession | undefined;
-    /**
-     * Get all active sessions
-     */
-    getActiveSessions(): Map<string, ActivitySession>;
-    /**
-     * Check for idle sessions and flush them
-     * Called periodically by timer
-     */
-    checkAndFlushIdleSessions(): Promise<void>;
-    /**
-     * Flush a single activity session to the session log
-     */
-    flushActivitySession(key: string, session: ActivitySession): Promise<void>;
-    /**
-     * Flush all active sessions (called on shutdown)
-     */
-    flushAllSessions(): Promise<void>;
-    /**
-     * Build summary for an activity session
-     * Now includes conversation summary for memory recall
-     */
-    private buildActivitySessionSummary;
-    /**
-     * Start periodic idle session checking
-     */
-    startIdleCheckTimer(intervalMs?: number): void;
-    /**
-     * Stop idle check timer
-     */
-    stopIdleCheckTimer(): void;
-    /**
-     * Generate a conversation summary using LLM
-     * Creates a condensed memory of what was discussed
-     */
-    private generateConversationSummary;
-    /**
-     * Load memory entries for an activity from SESSION_LOG
-     * Returns past conversation summaries for context injection
-     *
-     * NOTE: ActivityLink fields store objects {_id, name}, so we fetch recent
-     * session logs and filter client-side by checking the nested _id.
-     */
-    loadMemoryForActivity(activityId: string, workspaceId: string, limit?: number): Promise<MemoryEntry[]>;
-    /**
-     * Format memory entries for injection into conversation context
-     */
-    formatMemoryForContext(entries: MemoryEntry[]): string;
-}
-//# sourceMappingURL=session-logger.d.ts.map