@hailer/mcp 0.1.16 → 0.2.1

package/dist/lib/prompt-length-manager.js

@@ -1,457 +0,0 @@
-"use strict";
-/**
- * Prompt Length Manager
- * Handles prompt length validation, truncation, and debugging
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptLengthManager = exports.PromptLengthManager = exports.DEFAULT_TRUNCATION_CONFIG = void 0;
-const logger_1 = require("./logger");
-exports.DEFAULT_TRUNCATION_CONFIG = {
-    // Claude 4 optimized limits (leaving room for response)
-    maxTotalTokens: 150_000, // 150k tokens for Claude 4 
-    maxUserMessagesTokens: 20_000, // 20k tokens for user messages
-    // Character limits (fallback: 1 token ≈ 4 characters)
-    maxTotalCharacters: 600_000, // ~150k tokens
-    maxUserMessagesCharacters: 80_000, // ~20k tokens
-    // Provider context windows (in tokens)
-    anthropicContextWindow: 200_000, // Claude Sonnet 4
-    openaiContextWindow: 128_000, // GPT-4 Turbo
-    // New smart truncation strategy
-    preserveSystemPrompt: true, // Never truncate system prompts
-    preserveUserMessages: true, // Preserve up to 20k tokens
-    preserveAssistantResponses: true, // Preserve when possible
-    truncateToolResponsesFirst: true, // Tool responses are most expendable
-};
-class PromptLengthManager {
-    logger;
-    config;
-    constructor(config = {}) {
-        this.config = { ...exports.DEFAULT_TRUNCATION_CONFIG, ...config };
-        this.logger = (0, logger_1.createLogger)({ component: "PromptLengthManager" });
-    }
-    /**
-     * Estimate token count from character count
-     * Rough approximation: 1 token ≈ 4 characters for English text
-     */
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4);
-    }
-    /**
-     * Count exact characters and estimate tokens for a text
-     */
-    analyzeText(text) {
-        const characters = text.length;
-        const estimatedTokens = this.estimateTokens(text);
-        return { characters, estimatedTokens };
-    }
-    /**
-     * Truncate text intelligently, preserving structure when possible
-     */
-    truncateText(text, maxLength, source) {
-        if (text.length <= maxLength) {
-            return { text, truncated: false };
-        }
-        // Try to truncate at natural boundaries (paragraphs, sentences)
-        const truncated = text.substring(0, maxLength);
-        // Find last complete sentence or paragraph
-        const lastParagraph = truncated.lastIndexOf('\n\n');
-        const lastSentence = truncated.lastIndexOf('. ');
-        let cutPoint = maxLength;
-        let truncationMethod = 'hard_cutoff';
-        if (lastParagraph > maxLength * 0.7) {
-            cutPoint = lastParagraph;
-            truncationMethod = 'paragraph_boundary';
-        }
-        else if (lastSentence > maxLength * 0.8) {
-            cutPoint = lastSentence + 1;
-            truncationMethod = 'sentence_boundary';
-        }
-        const finalText = text.substring(0, cutPoint) + '\n\n[... Content truncated ...]';
-        const removedContent = text.substring(cutPoint);
-        this.logger.warn(`Truncated ${source}`, {
-            originalLength: text.length,
-            truncatedLength: finalText.length,
-            truncatedAt: cutPoint,
-            truncationMethod,
-            removedCharacters: removedContent.length,
-            reductionPercent: Math.round((1 - finalText.length / text.length) * 100),
-            source,
-            removedContentPreview: removedContent.substring(0, 200) + (removedContent.length > 200 ? '...' : ''),
-            originalContentPreview: text.substring(0, 200) + (text.length > 200 ? '...' : '')
-        });
-        return {
-            text: finalText,
-            truncated: true,
-            truncatedAt: cutPoint,
-            truncationMethod,
-            originalContent: text
-        };
-    }
-    /**
-     * Analyze prompt components and build analysis
-     */
-    analyzePrompt(components) {
-        let totalCharacters = 0;
-        let totalTokens = 0;
-        const warnings = [];
-        const processedComponents = [];
-        for (const component of components) {
-            const analysis = this.analyzeText(component.content);
-            totalCharacters += analysis.characters;
-            totalTokens += analysis.estimatedTokens;
-            processedComponents.push({
-                ...component,
-                originalLength: analysis.characters,
-            });
-            // TRUNCATION WARNINGS TEMPORARILY DISABLED FOR TESTING
-            /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
-            // Check component token limits under new system
-            const componentTokens = this.estimateTokens(component.content);
-            
-            if (component.type === 'user' && componentTokens > this.config.maxUserMessagesTokens) {
-              warnings.push(`User message (${componentTokens} tokens) exceeds user message limit (${this.config.maxUserMessagesTokens} tokens)`);
-            }
-            
-            // Note: No individual limits for system prompts or tool responses under new logic
-            */ // END OF COMMENTED OUT WARNING LOGIC
-        }
-        // TOTAL TOKEN LIMIT WARNINGS TEMPORARILY DISABLED FOR TESTING
-        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
-        // Check total token limits (primary check under new system)
-        if (totalTokens > this.config.maxTotalTokens) {
-          warnings.push(`Total prompt (${totalTokens} tokens) exceeds Claude 4 limit (${this.config.maxTotalTokens} tokens)`);
-        }
-        */ // END OF COMMENTED OUT WARNING LOGIC
-        return {
-            totalCharacters,
-            estimatedTokens: totalTokens,
-            components: processedComponents,
-            truncationApplied: false,
-            warnings,
-        };
-    }
-    /**
-     * No longer truncate individual tool responses - only when total prompt exceeds limits
-     * This method now just passes through content unchanged and logs for monitoring
-     * TEMPORARILY DISABLED - Even monitoring/logging is disabled
-     */
-    truncateToolResponse(content, toolName) {
-        // TRUNCATION AND MONITORING TEMPORARILY DISABLED FOR TESTING
-        return content; // Pass through unchanged with no logging
-        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
-        this.logger.debug(`Tool response processed (no individual limits)`, {
-          toolName,
-          length: content.length,
-          estimatedTokens: this.estimateTokens(content),
-          note: "Individual tool limits removed - truncation only happens at total prompt level"
-        });
-    
-        return content; // Pass through unchanged
-        */ // END OF COMMENTED OUT MONITORING LOGIC
-    }
-    /**
-     * Apply smart token-based truncation optimized for Claude 4
-     * TEMPORARILY DISABLED - All truncation logic commented out for testing
-     */
-    truncatePrompt(analysis) {
-        // TRUNCATION TEMPORARILY DISABLED FOR TESTING
-        this.logger.info("Truncation is temporarily disabled - returning prompt unchanged", {
-            originalTokens: analysis.estimatedTokens,
-            originalChars: analysis.totalCharacters,
-            tokenLimit: this.config.maxTotalTokens,
-            status: "DISABLED"
-        });
-        return analysis;
-        /* COMMENTED OUT - RE-ENABLE BY UNCOMMENTING THIS BLOCK
-        if (analysis.estimatedTokens <= this.config.maxTotalTokens) {
-          return analysis; // No truncation needed
-        }
-    
-        const targetTokenReduction = analysis.estimatedTokens - this.config.maxTotalTokens;
-        
-        this.logger.warn("Applying Claude 4 optimized prompt truncation", {
-          originalTokens: analysis.estimatedTokens,
-          originalChars: analysis.totalCharacters,
-          tokenLimit: this.config.maxTotalTokens,
-          targetTokenReduction,
-          truncationStrategy: "claude_4_smart_preservation"
-        });
-    
-        // Track unknown component types for debugging
-        const knownTypes = new Set(['system', 'user', 'assistant', 'tool_result', 'tool_call']);
-        const unknownComponents = analysis.components.filter(c => !knownTypes.has(c.type));
-        if (unknownComponents.length > 0) {
-          this.logger.info("Unknown prompt component types detected", {
-            unknownTypes: unknownComponents.map(c => ({ type: c.type, source: c.source, length: c.content.length })),
-            count: unknownComponents.length
-          });
-        }
-    
-        // Separate components by type for smart preservation
-        const systemComponents = analysis.components.filter(c => c.type === 'system');
-        const userComponents = analysis.components.filter(c => c.type === 'user');
-        const assistantComponents = analysis.components.filter(c => c.type === 'assistant' || c.type === 'tool_call');
-        const toolComponents = analysis.components.filter(c => c.type === 'tool_result');
-        const otherComponents = analysis.components.filter(c => !knownTypes.has(c.type));
-    
-        // Calculate current token usage by component type
-        const systemTokens = systemComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
-        const userTokens = userComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
-        const assistantTokens = assistantComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
-        const toolTokens = toolComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
-        const otherTokens = otherComponents.reduce((sum, c) => sum + this.estimateTokens(c.content), 0);
-    
-        this.logger.info("Component token breakdown", {
-          system: `${systemTokens} tokens (${systemComponents.length} components) - PRESERVED`,
-          user: `${userTokens} tokens (${userComponents.length} components) - PRESERVE UP TO 20k`,
-          assistant: `${assistantTokens} tokens (${assistantComponents.length} components) - PRESERVE WHEN POSSIBLE`,
-          tool_result: `${toolTokens} tokens (${toolComponents.length} components) - TRUNCATE FIRST`,
-          other: `${otherTokens} tokens (${otherComponents.length} components) - UNKNOWN TYPE`
-        });
-    
-        const truncatedComponents: PromptComponent[] = [];
-        let tokensUsed = 0;
-        let tokensReduced = 0;
-    
-        // Step 1: Always preserve system prompts (100%)
-        systemComponents.forEach(component => {
-          truncatedComponents.push({ ...component });
-          tokensUsed += this.estimateTokens(component.content);
-        });
-    
-        // Step 2: Preserve user messages up to 20k tokens
-        let userTokensUsed = 0;
-        userComponents.forEach(component => {
-          const componentTokens = this.estimateTokens(component.content);
-          if (userTokensUsed + componentTokens <= this.config.maxUserMessagesTokens) {
-            // Keep this user message fully
-            truncatedComponents.push({ ...component });
-            tokensUsed += componentTokens;
-            userTokensUsed += componentTokens;
-          } else if (userTokensUsed < this.config.maxUserMessagesTokens) {
-            // Partial truncation to fit within user message limit
-            const allowedTokens = this.config.maxUserMessagesTokens - userTokensUsed;
-            const allowedChars = Math.floor(allowedTokens * 4); // Approximate conversion
-            
-            const result = this.truncateText(component.content, allowedChars, component.source || 'user_message');
-            truncatedComponents.push({
-              ...component,
-              content: result.text,
-              truncated: result.truncated,
-              originalContent: result.originalContent,
-              truncatedAt: result.truncatedAt,
-              truncationReason: `User message truncated to fit within ${this.config.maxUserMessagesTokens} token limit for user messages`
-            });
-            
-            const actualTokens = this.estimateTokens(result.text);
-            tokensUsed += actualTokens;
-            userTokensUsed += actualTokens;
-            tokensReduced += componentTokens - actualTokens;
-            
-            if (result.truncated) {
-              this.logger.warn("User message truncated to fit limit", {
-                componentSource: component.source,
-                originalTokens: componentTokens,
-                truncatedTokens: actualTokens,
-                userTokenLimit: this.config.maxUserMessagesTokens
-              });
-            }
-          }
-          // Skip user messages that don't fit in the 20k limit
-        });
-    
-        // Step 3: Add assistant responses if we have room
-        assistantComponents.forEach(component => {
-          const componentTokens = this.estimateTokens(component.content);
-          if (tokensUsed + componentTokens <= this.config.maxTotalTokens - targetTokenReduction) {
-            truncatedComponents.push({ ...component });
-            tokensUsed += componentTokens;
-          }
-          // Skip assistant messages if no room
-        });
-    
-        // Step 4: Add tool responses with truncation if needed
-        const remainingTokenBudget = this.config.maxTotalTokens - tokensUsed;
-        let toolBudgetUsed = 0;
-    
-        toolComponents.forEach(component => {
-          const componentTokens = this.estimateTokens(component.content);
-          
-          if (toolBudgetUsed + componentTokens <= remainingTokenBudget) {
-            // Tool response fits fully
-            truncatedComponents.push({ ...component });
-            tokensUsed += componentTokens;
-            toolBudgetUsed += componentTokens;
-          } else if (toolBudgetUsed < remainingTokenBudget) {
-            // Partial truncation of tool response
-            const allowedTokens = remainingTokenBudget - toolBudgetUsed;
-            const allowedChars = Math.floor(allowedTokens * 4);
-            
-            const result = this.truncateText(component.content, allowedChars, component.source || 'tool_result');
-            truncatedComponents.push({
-              ...component,
-              content: result.text,
-              truncated: result.truncated,
-              originalContent: result.originalContent,
-              truncatedAt: result.truncatedAt,
-              truncationReason: `Tool response truncated to fit within ${this.config.maxTotalTokens} token total limit`
-            });
-            
-            const actualTokens = this.estimateTokens(result.text);
-            tokensUsed += actualTokens;
-            toolBudgetUsed += actualTokens;
-            tokensReduced += componentTokens - actualTokens;
-            
-            if (result.truncated) {
-              this.logger.warn("Tool response truncated", {
-                toolSource: component.source,
-                originalTokens: componentTokens,
-                truncatedTokens: actualTokens,
-                originalLength: component.content.length,
-                truncatedLength: result.text.length,
-                truncationMethod: result.truncationMethod,
-                truncatedAt: result.truncatedAt
-              });
-            }
-          }
-          // Skip tool responses that don't fit
-        });
-    
-        // Step 5: Handle unknown component types
-        otherComponents.forEach(component => {
-          this.logger.warn("Unknown component type in prompt", {
-            type: component.type,
-            source: component.source,
-            length: component.content.length,
-            tokens: this.estimateTokens(component.content),
-            note: "Added to debug page for analysis"
-          });
-          
-          // Add to debug but don't include in prompt for now
-          truncatedComponents.push({
-            ...component,
-            truncationReason: `Unknown component type '${component.type}' - review on debug page`
-          });
-        });
-    
-        const finalTokens = this.estimateTokens(truncatedComponents.map(c => c.content).join(''));
-        
-        return {
-          totalCharacters: truncatedComponents.reduce((sum, c) => sum + c.content.length, 0),
-          estimatedTokens: finalTokens,
-          components: truncatedComponents,
-          truncationApplied: tokensReduced > 0,
-          warnings: [
-            ...analysis.warnings,
-            `Applied Claude 4 smart truncation: reduced by ${tokensReduced} tokens (${Math.round(tokensReduced / analysis.estimatedTokens * 100)}%)`,
-            `Preservation strategy: System (100%) → User (up to 20k tokens) → Assistant → Tools`,
-            `Final prompt: ${finalTokens.toLocaleString()} tokens (limit: ${this.config.maxTotalTokens.toLocaleString()})`
-          ],
-        };
-        */ // END OF COMMENTED OUT TRUNCATION LOGIC
-    }
-    /**
-     * Check if a provider-specific error indicates prompt too long
-     */
-    isPromptTooLongError(error, provider) {
-        const errorMessage = error.message.toLowerCase();
-        if (provider === 'anthropic') {
-            return errorMessage.includes('prompt too long') ||
-                errorMessage.includes('maximum context length') ||
-                errorMessage.includes('context_length_exceeded') ||
-                errorMessage.includes('token limit exceeded');
-        }
-        if (provider === 'openai') {
-            return errorMessage.includes('maximum context length') ||
-                errorMessage.includes('context_length_exceeded') ||
-                errorMessage.includes('token limit exceeded') ||
-                errorMessage.includes('reduce the length');
-        }
-        return false;
-    }
-    /**
-     * Log comprehensive debug information about prompt structure
-     */
-    logPromptDebugInfo(analysis, provider, botId) {
-        const debugData = {
-            provider,
-            botId,
-            summary: {
-                totalCharacters: analysis.totalCharacters,
-                estimatedTokens: analysis.estimatedTokens,
-                componentCount: analysis.components.length,
-                truncationApplied: analysis.truncationApplied,
-                warningCount: analysis.warnings.length,
-            },
-            breakdown: analysis.components.map(comp => ({
-                type: comp.type,
-                source: comp.source,
-                currentLength: comp.content.length,
-                originalLength: comp.originalLength || comp.content.length,
-                truncated: comp.truncated,
-                reductionPercent: comp.originalLength ?
-                    Math.round((1 - comp.content.length / comp.originalLength) * 100) : 0,
-                estimatedTokens: this.estimateTokens(comp.content),
-                // First 100 chars as preview (for debugging)
-                preview: comp.content.substring(0, 100) + (comp.content.length > 100 ? '...' : ''),
-            })),
-            warnings: analysis.warnings,
-        };
-        this.logger.info("Prompt debug analysis", debugData);
-        // Enhanced truncation logging
-        const truncatedComponents = analysis.components.filter(c => c.truncated);
-        if (truncatedComponents.length > 0) {
-            this.logger.warn("Component truncation summary", {
-                truncatedCount: truncatedComponents.length,
-                totalComponents: analysis.components.length,
-                truncations: truncatedComponents.map(comp => ({
-                    type: comp.type,
-                    source: comp.source,
-                    originalChars: comp.originalLength,
-                    truncatedChars: comp.content.length,
-                    savedChars: (comp.originalLength || comp.content.length) - comp.content.length,
-                    reductionPercent: comp.originalLength ?
-                        Math.round((1 - comp.content.length / comp.originalLength) * 100) : 0,
-                }))
-            });
-        }
-        // Log full prompt to separate file if it was truncated or has warnings
-        if (analysis.truncationApplied || analysis.warnings.length > 0) {
-            this.logger.warn("Prompt required attention", {
-                reason: analysis.truncationApplied ? 'truncation' : 'warnings',
-                fullPrompt: analysis.components.map(c => `=== ${c.type.toUpperCase()} (${c.source || 'unknown'}) ===\n${c.content}`).join('\n\n'),
-            });
-        }
-    }
-    /**
-     * Generate a quick truncation summary for debugging
-     */
-    generateTruncationSummary(analysis) {
-        const totalOriginal = analysis.components.reduce((sum, comp) => sum + (comp.originalLength || comp.content.length), 0);
-        const totalCurrent = analysis.totalCharacters;
-        const totalSaved = totalOriginal - totalCurrent;
-        const overallReduction = totalOriginal > 0 ? Math.round((totalSaved / totalOriginal) * 100) : 0;
-        const truncatedComponents = analysis.components.filter(c => c.truncated);
-        let summary = `Prompt Summary: ${totalCurrent.toLocaleString()} chars (${analysis.estimatedTokens.toLocaleString()} tokens)`;
-        if (totalSaved > 0) {
-            summary += `\nTruncation Applied: Saved ${totalSaved.toLocaleString()} chars (${overallReduction}% reduction)`;
-            summary += `\nTruncated Components: ${truncatedComponents.length}/${analysis.components.length}`;
-            if (truncatedComponents.length > 0) {
-                summary += `\nBreakdown:`;
-                truncatedComponents.forEach(comp => {
-                    const saved = (comp.originalLength || comp.content.length) - comp.content.length;
-                    const percent = comp.originalLength ? Math.round((saved / comp.originalLength) * 100) : 0;
-                    summary += `\n  - ${comp.type} (${comp.source}): ${saved.toLocaleString()} chars saved (${percent}%)`;
-                });
-            }
-        }
-        else {
-            summary += `\nNo truncation applied`;
-        }
-        return summary;
-    }
-}
-exports.PromptLengthManager = PromptLengthManager;
-// Export a default instance
-exports.promptLengthManager = new PromptLengthManager();
-//# sourceMappingURL=prompt-length-manager.js.map

package/dist/mcp/tools/giuseppe-tools.d.ts

@@ -1,21 +0,0 @@
-/**
- * Giuseppe MCP Tools
- *
- * Bug-fixing tools for Giuseppe specialist daemon.
- * These tools handle file operations, git, and build commands.
- */
-import { Tool } from "../tool-registry";
-export declare const giuseppeFindAppTool: Tool;
-export declare const giuseppeListFilesTool: Tool;
-export declare const giuseppeReadFileTool: Tool;
-export declare const giuseppeWriteFileTool: Tool;
-export declare const giuseppeApplyFixTool: Tool;
-export declare const giuseppeRunBuildTool: Tool;
-export declare const giuseppeGitStatusTool: Tool;
-export declare const giuseppeGitPullTool: Tool;
-export declare const giuseppeGitCommitTool: Tool;
-export declare const giuseppeGitPushTool: Tool;
-export declare const giuseppeGitRevertTool: Tool;
-export declare const giuseppePublishAppTool: Tool;
-export declare const giuseppeTools: Tool[];
-//# sourceMappingURL=giuseppe-tools.d.ts.map

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

@@ -1,25 +0,0 @@
-/**
- * Bug Reports Module - Configuration Discovery
- *
- * Discovers Bug Reports workflow by name pattern.
- * No hardcoded IDs - works in any workspace.
- */
-import type { UserContext } from '../../mcp/UserContextCache';
-import type { BugReportsConfig, WorkflowDiscoveryResult } from './types';
-/**
- * Discover Bug Reports workflow in a workspace
- */
-export declare function discoverWorkflow(userContext: UserContext, config: BugReportsConfig): Promise<WorkflowDiscoveryResult | null>;
-/**
- * Load config from MCP Config workflow or environment
- */
-export declare function loadConfig(userContext: UserContext): Promise<BugReportsConfig>;
-/**
- * Get default configuration
- */
-export declare function getDefaultConfig(): BugReportsConfig;
-/**
- * Save config back to Hailer (creates/updates config activity)
- */
-export declare function saveConfig(userContext: UserContext, config: BugReportsConfig): Promise<boolean>;
-//# sourceMappingURL=bug-config.d.ts.map