@hailer/mcp 0.0.1

package/dist/client/simple-llm-caller.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Simple LLM Caller for Adaptive Documentation Bot
+ *
+ * Provides basic LLM API calls without the full MCP provider infrastructure.
+ * Used for analyzing errors and generating improvements.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLLMCaller = void 0;
+const logger_1 = require("../lib/logger");
+const logger = (0, logger_1.createLogger)({ component: 'SimpleLLMCaller' });
+class SimpleLLMCaller {
+    apiKey;
+    model;
+    provider;
+    constructor(provider, apiKey, model) {
+        this.provider = provider;
+        this.apiKey = apiKey;
+        this.model = model || (provider === 'anthropic' ? 'claude-3-5-haiku-20241022' : 'gpt-4o-mini');
+    }
+    /**
+     * Simple LLM call for text generation
+     */
+    async generate(prompt, systemPrompt) {
+        if (this.provider === 'anthropic') {
+            return this.callAnthropic(prompt, systemPrompt);
+        }
+        else {
+            return this.callOpenAI(prompt, systemPrompt);
+        }
+    }
+    async callAnthropic(prompt, systemPrompt) {
+        try {
+            const response = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.apiKey,
+                    'anthropic-version': '2023-06-01'
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    max_tokens: 2000,
+                    system: systemPrompt || 'You are a helpful assistant.',
+                    messages: [
+                        {
+                            role: 'user',
+                            content: prompt
+                        }
+                    ]
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data.content[0].text;
+        }
+        catch (error) {
+            logger.error('Anthropic API call failed', error);
+            throw error;
+        }
+    }
+    async callOpenAI(prompt, systemPrompt) {
+        try {
+            const response = await fetch('https://api.openai.com/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: systemPrompt || 'You are a helpful assistant.'
+                        },
+                        {
+                            role: 'user',
+                            content: prompt
+                        }
+                    ],
+                    max_tokens: 2000
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data.choices[0].message.content;
+        }
+        catch (error) {
+            logger.error('OpenAI API call failed', error);
+            throw error;
+        }
+    }
+}
+exports.SimpleLLMCaller = SimpleLLMCaller;
+//# sourceMappingURL=simple-llm-caller.js.map

package/dist/client/skill-generator.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Skill Generator for Adaptive Documentation Bot
+ *
+ * Automatically creates and updates Claude Code skill documents
+ * based on common LLM mistakes and error patterns.
+ */
+import { ErrorPattern } from './adaptive-documentation-types';
+export declare class SkillGenerator {
+    private skillsDir;
+    private mistakesByTool;
+    /**
+     * Update or create skill for a tool with common mistakes
+     */
+    updateOrCreateSkill(toolName: string, errorPattern: ErrorPattern, incorrectExample: any, correctExample: any): Promise<boolean>;
+    /**
+     * Load existing skill or create template
+     */
+    private loadOrCreateSkill;
+    /**
+     * Create initial skill template
+     */
+    private createSkillTemplate;
+    /**
+     * Add mistake section to skill content
+     */
+    private addMistakeToSkill;
+    /**
+     * Generate markdown section for a mistake
+     */
+    private generateMistakeSection;
+    /**
+     * Generate skill summary with statistics
+     */
+    generateSkillSummary(toolName: string): Promise<string>;
+    /**
+     * Update skill summary section
+     */
+    updateSkillSummary(toolName: string): Promise<void>;
+    /**
+     * Get list of all skills created by this generator
+     */
+    getGeneratedSkills(): Promise<string[]>;
+    /**
+     * Track mistake for statistics
+     */
+    private trackMistake;
+    /**
+     * Get mistake count for a tool
+     */
+    private getMistakeCount;
+    /**
+     * Find existing skill for a tool
+     * Checks for patterns like: install-workflow-skill, install_workflow-skill, etc.
+     */
+    private findExistingSkill;
+    /**
+     * Convert tool name to kebab-case for skill directory names
+     */
+    private toKebabCase;
+    /**
+     * Convert tool name to title case
+     */
+    private toTitleCase;
+    /**
+     * Ensure directory exists
+     */
+    private ensureDirectory;
+    /**
+     * Check if file exists
+     */
+    private fileExists;
+    /**
+     * Get statistics about generated skills
+     */
+    getStats(): {
+        totalSkills: number;
+        totalMistakes: number;
+        mistakesByTool: Record<string, number>;
+    };
+}
+//# sourceMappingURL=skill-generator.d.ts.map

package/dist/client/skill-generator.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * Skill Generator for Adaptive Documentation Bot
+ *
+ * Automatically creates and updates Claude Code skill documents
+ * based on common LLM mistakes and error patterns.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillGenerator = void 0;
+const logger_1 = require("../lib/logger");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger = (0, logger_1.createLogger)({ component: 'SkillGenerator' });
+class SkillGenerator {
+    skillsDir = '.claude/skills';
+    mistakesByTool = new Map();
+    /**
+     * Update or create skill for a tool with common mistakes
+     */
+    async updateOrCreateSkill(toolName, errorPattern, incorrectExample, correctExample) {
+        try {
+            // First, check if an existing skill exists for this tool
+            const existingSkill = await this.findExistingSkill(toolName);
+            let skillPath;
+            let skillFile;
+            if (existingSkill) {
+                // Update existing skill
+                skillPath = existingSkill.path;
+                skillFile = existingSkill.file;
+                logger.info('Found existing skill, will update it', {
+                    toolName,
+                    existingSkill: existingSkill.name
+                });
+            }
+            else {
+                // Create new -common-mistakes skill
+                skillPath = path.join(this.skillsDir, `${this.toKebabCase(toolName)}-common-mistakes`);
+                skillFile = path.join(skillPath, 'SKILL.md');
+                logger.info('No existing skill found, creating new one', {
+                    toolName,
+                    skillPath
+                });
+            }
+            // Ensure directory exists
+            await this.ensureDirectory(skillPath);
+            // Load or create skill content
+            let skillContent = await this.loadOrCreateSkill(skillFile, toolName);
+            // Create mistake section
+            const mistake = {
+                title: errorPattern.description,
+                frequency: errorPattern.count,
+                lastSeen: errorPattern.lastSeen,
+                wrongExample: incorrectExample,
+                correctExample: correctExample,
+                explanation: errorPattern.rootCause || 'Common mistake detected from LLM usage'
+            };
+            // Add mistake to the skill
+            skillContent = this.addMistakeToSkill(skillContent, mistake);
+            // Write back to file
+            await fs.writeFile(skillFile, skillContent, 'utf-8');
+            logger.info('✅ Skill updated', {
+                toolName,
+                skillPath,
+                mistakeCount: this.getMistakeCount(toolName) + 1
+            });
+            // Track mistake
+            this.trackMistake(toolName, mistake);
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to update skill', error, { toolName });
+            return false;
+        }
+    }
+    /**
+     * Load existing skill or create template
+     */
+    async loadOrCreateSkill(skillFile, toolName) {
+        try {
+            const exists = await this.fileExists(skillFile);
+            if (exists) {
+                return await fs.readFile(skillFile, 'utf-8');
+            }
+            // Create new skill template
+            return this.createSkillTemplate(toolName);
+        }
+        catch (error) {
+            return this.createSkillTemplate(toolName);
+        }
+    }
+    /**
+     * Create initial skill template
+     */
+    createSkillTemplate(toolName) {
+        return `# ${this.toTitleCase(toolName)} - Common Mistakes
+
+This skill document is automatically generated and updated by the Adaptive Documentation Bot.
+It contains common mistakes made by LLMs when using the \`${toolName}\` tool, based on real usage errors.
+
+## Purpose
+
+Help Claude Code avoid common mistakes when calling the \`${toolName}\` tool by documenting:
+- Incorrect usage patterns that have caused errors
+- Correct usage examples
+- Why these mistakes happen
+- How to avoid them
+
+---
+
+## Common Mistakes
+
+`;
+    }
+    /**
+     * Add mistake section to skill content
+     */
+    addMistakeToSkill(skillContent, mistake) {
+        const mistakeSection = this.generateMistakeSection(mistake);
+        // Try to find existing "## Common Mistakes" section
+        const commonMistakesMarker = '## Common Mistakes';
+        const hasCommonMistakes = skillContent.includes(commonMistakesMarker);
+        if (hasCommonMistakes) {
+            // Insert after existing "## Common Mistakes" header
+            const insertMarker = commonMistakesMarker + '\n\n';
+            const insertIndex = skillContent.indexOf(insertMarker);
+            if (insertIndex !== -1) {
+                const beforeInsert = skillContent.substring(0, insertIndex + insertMarker.length);
+                const afterInsert = skillContent.substring(insertIndex + insertMarker.length);
+                return beforeInsert + mistakeSection + '\n' + afterInsert;
+            }
+        }
+        // No "## Common Mistakes" section exists - add one at the end
+        const newSection = `\n\n---\n\n## Common Mistakes\n\n${mistakeSection}`;
+        return skillContent + newSection;
+    }
+    /**
+     * Generate markdown section for a mistake
+     */
+    generateMistakeSection(mistake) {
+        const dateStr = new Date(mistake.lastSeen).toISOString().split('T')[0];
+        return `### ❌ ${mistake.title}
+
+**Frequency**: Seen ${mistake.frequency} times
+**Last occurrence**: ${dateStr}
+
+**Why this happens**: ${mistake.explanation}
+
+**❌ Wrong:**
+\`\`\`json
+${JSON.stringify(mistake.wrongExample, null, 2)}
+\`\`\`
+
+**✅ Correct:**
+\`\`\`json
+${JSON.stringify(mistake.correctExample, null, 2)}
+\`\`\`
+
+---
+`;
+    }
+    /**
+     * Generate skill summary with statistics
+     */
+    async generateSkillSummary(toolName) {
+        const mistakes = this.mistakesByTool.get(toolName) || [];
+        if (mistakes.length === 0) {
+            return `No common mistakes recorded yet for ${toolName}.`;
+        }
+        const totalFrequency = mistakes.reduce((sum, m) => sum + m.frequency, 0);
+        const mostRecent = Math.max(...mistakes.map(m => m.lastSeen));
+        return `## Summary
+
+**Total mistake types**: ${mistakes.length}
+**Total occurrences**: ${totalFrequency}
+**Last updated**: ${new Date(mostRecent).toISOString().split('T')[0]}
+
+### Most Common Mistakes
+
+${mistakes
+            .sort((a, b) => b.frequency - a.frequency)
+            .slice(0, 5)
+            .map((m, i) => `${i + 1}. ${m.title} (${m.frequency} times)`)
+            .join('\n')}
+`;
+    }
+    /**
+     * Update skill summary section
+     */
+    async updateSkillSummary(toolName) {
+        const skillPath = path.join(this.skillsDir, `${toolName}-common-mistakes`, 'SKILL.md');
+        try {
+            const exists = await this.fileExists(skillPath);
+            if (!exists)
+                return;
+            let content = await fs.readFile(skillPath, 'utf-8');
+            const summary = await this.generateSkillSummary(toolName);
+            // Replace or append summary
+            const summaryMarker = '## Summary';
+            if (content.includes(summaryMarker)) {
+                // Replace existing summary
+                content = content.replace(/## Summary[\s\S]*?(?=##|$)/, summary + '\n\n');
+            }
+            else {
+                // Append summary after header
+                const headerEnd = content.indexOf('---\n\n## Common Mistakes');
+                if (headerEnd !== -1) {
+                    content = content.substring(0, headerEnd) +
+                        '---\n\n' + summary + '\n\n## Common Mistakes' +
+                        content.substring(headerEnd + '---\n\n## Common Mistakes'.length);
+                }
+            }
+            await fs.writeFile(skillPath, content, 'utf-8');
+        }
+        catch (error) {
+            logger.error('Failed to update skill summary', error, { toolName });
+        }
+    }
+    /**
+     * Get list of all skills created by this generator
+     */
+    async getGeneratedSkills() {
+        try {
+            const exists = await this.fileExists(this.skillsDir);
+            if (!exists)
+                return [];
+            const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+            return entries
+                .filter(entry => entry.isDirectory() && entry.name.endsWith('-common-mistakes'))
+                .map(entry => entry.name.replace('-common-mistakes', ''));
+        }
+        catch (error) {
+            logger.error('Failed to get generated skills', error);
+            return [];
+        }
+    }
+    /**
+     * Track mistake for statistics
+     */
+    trackMistake(toolName, mistake) {
+        const mistakes = this.mistakesByTool.get(toolName) || [];
+        mistakes.push(mistake);
+        this.mistakesByTool.set(toolName, mistakes);
+    }
+    /**
+     * Get mistake count for a tool
+     */
+    getMistakeCount(toolName) {
+        return (this.mistakesByTool.get(toolName) || []).length;
+    }
+    /**
+     * Find existing skill for a tool
+     * Checks for patterns like: install-workflow-skill, install_workflow-skill, etc.
+     */
+    async findExistingSkill(toolName) {
+        try {
+            const exists = await this.fileExists(this.skillsDir);
+            if (!exists)
+                return null;
+            const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+            // Convert tool name to kebab case for matching
+            const kebabToolName = this.toKebabCase(toolName);
+            // Try different naming patterns
+            const patterns = [
+                `${kebabToolName}-skill`, // install-workflow-skill
+                `${kebabToolName}`, // install-workflow
+                toolName.replace(/_/g, '-') + '-skill', // direct conversion
+            ];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                // Check if directory name matches any pattern
+                for (const pattern of patterns) {
+                    if (entry.name === pattern || entry.name.startsWith(pattern)) {
+                        const skillPath = path.join(this.skillsDir, entry.name);
+                        const skillFile = path.join(skillPath, 'SKILL.md');
+                        // Verify SKILL.md exists
+                        const skillExists = await this.fileExists(skillFile);
+                        if (skillExists) {
+                            return {
+                                name: entry.name,
+                                path: skillPath,
+                                file: skillFile
+                            };
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error('Failed to find existing skill', error, { toolName });
+            return null;
+        }
+    }
+    /**
+     * Convert tool name to kebab-case for skill directory names
+     */
+    toKebabCase(str) {
+        return str
+            .replace(/_/g, '-')
+            .toLowerCase();
+    }
+    /**
+     * Convert tool name to title case
+     */
+    toTitleCase(str) {
+        return str
+            .split('_')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+    /**
+     * Ensure directory exists
+     */
+    async ensureDirectory(dir) {
+        try {
+            await fs.mkdir(dir, { recursive: true });
+        }
+        catch (error) {
+            // Directory might already exist
+        }
+    }
+    /**
+     * Check if file exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get statistics about generated skills
+     */
+    getStats() {
+        const mistakesByTool = {};
+        let totalMistakes = 0;
+        for (const [toolName, mistakes] of this.mistakesByTool.entries()) {
+            mistakesByTool[toolName] = mistakes.length;
+            totalMistakes += mistakes.length;
+        }
+        return {
+            totalSkills: this.mistakesByTool.size,
+            totalMistakes,
+            mistakesByTool
+        };
+    }
+}
+exports.SkillGenerator = SkillGenerator;
+//# sourceMappingURL=skill-generator.js.map

package/dist/client/test-adaptive-bot.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Test script for Adaptive Documentation Bot
+ *
+ * Run this to see what the bot would do without actually modifying files:
+ *
+ * npx tsx server/src/client/test-adaptive-bot.ts
+ */
+export {};
+//# sourceMappingURL=test-adaptive-bot.d.ts.map

package/dist/client/test-adaptive-bot.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Test script for Adaptive Documentation Bot
+ *
+ * Run this to see what the bot would do without actually modifying files:
+ *
+ * npx tsx server/src/client/test-adaptive-bot.ts
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const path_1 = __importDefault(require("path"));
+const adaptive_documentation_bot_1 = require("./adaptive-documentation-bot");
+// Load environment variables from server/.env.local
+// When running with tsx, __dirname is the source directory, so go up to server root
+(0, dotenv_1.config)({ path: path_1.default.resolve(process.cwd(), '.env.local') });
+async function testAdaptiveBot() {
+    console.log('🧪 Testing Adaptive Documentation Bot\n');
+    // Check if Anthropic API key is available
+    if (!process.env.ANTHROPIC_API_KEY) {
+        console.error('❌ ANTHROPIC_API_KEY not found in environment');
+        console.log('Set it in .env.local to test with LLM analysis');
+        process.exit(1);
+    }
+    // Create bot instance with auto-update DISABLED
+    const bot = new adaptive_documentation_bot_1.AdaptiveDocumentationBot(process.env.ANTHROPIC_API_KEY, 'anthropic', {
+        enabled: true,
+        autoUpdate: false, // IMPORTANT: Don't modify files during test
+        updateInterval: 0,
+        minErrorCount: 1, // Lower threshold for testing
+        skillGeneration: true
+    });
+    console.log('📊 Analyzing recent logs...\n');
+    try {
+        const result = await bot.testRun();
+        console.log(`Found ${result.errors.length} errors in logs`);
+        console.log(`Detected ${result.patterns.length} error patterns\n`);
+        if (result.suggestions.length === 0) {
+            console.log('✅ No improvements needed (no errors detected)');
+            console.log('\nTo test the bot:');
+            console.log('1. Trigger some tool errors (e.g., call list_activities without fields)');
+            console.log('2. Wait a moment for logs to be written');
+            console.log('3. Run this script again');
+            return;
+        }
+        console.log('🔧 Suggested Improvements:\n');
+        console.log('='.repeat(80));
+        for (const suggestion of result.suggestions) {
+            console.log(`\nTool: ${suggestion.toolName}`);
+            console.log(`Error: "${suggestion.errorMessage}"`);
+            console.log(`Frequency: ${suggestion.errorCount} time(s)`);
+            if (suggestion.existingSkill) {
+                console.log(`✅ Existing skill found: ${suggestion.existingSkill}`);
+                console.log(`   → Would UPDATE existing skill with Common Mistakes section`);
+            }
+            else {
+                console.log(`❌ No existing skill found`);
+                console.log(`   → Would CREATE new skill: ${suggestion.toolName}-common-mistakes`);
+            }
+            console.log('-'.repeat(80));
+        }
+        console.log('\n📋 Summary:');
+        console.log(`- Total errors: ${result.errors.length}`);
+        console.log(`- Unique patterns: ${result.patterns.length}`);
+        console.log(`- Tools needing improvement: ${result.suggestions.length}`);
+        console.log(`- Would update existing skills: ${result.suggestions.filter(s => s.wouldUpdateSkill).length}`);
+        console.log(`- Would create new skills: ${result.suggestions.filter(s => s.wouldCreateSkill).length}`);
+        console.log('\n💡 To enable auto-improvements:');
+        console.log('1. Review the suggestions above');
+        console.log('2. Set ADAPTIVE_AUTO_UPDATE=true in .env.local');
+        console.log('3. Restart the MCP server');
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        process.exit(1);
+    }
+}
+// Run test
+testAdaptiveBot().catch(console.error);
+//# sourceMappingURL=test-adaptive-bot.js.map

package/dist/client/token-pricing.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Token Pricing Utility
+ *
+ * Calculates cost estimates for LLM API usage based on token consumption.
+ * Pricing data is accurate as of January 2025 and should be updated periodically.
+ *
+ * Anthropic pricing: https://www.anthropic.com/pricing
+ * OpenAI pricing: https://openai.com/pricing
+ */
+/**
+ * Token usage from API response
+ */
+export interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+}
+/**
+ * Calculate the cost of token usage for a specific model
+ *
+ * @param usage - Token usage from API response
+ * @param model - Model identifier (e.g., "claude-sonnet-4-20250514")
+ * @returns Estimated cost in USD
+ *
+ * @example
+ * ```typescript
+ * const usage = {
+ *   input_tokens: 24567,
+ *   output_tokens: 412,
+ *   cache_read_input_tokens: 22000
+ * };
+ * const cost = calculateTokenCost(usage, 'claude-sonnet-4-20250514');
+ * // Returns: 0.038
+ * ```
+ */
+export declare function calculateTokenCost(usage: TokenUsage, model: string): number;
+//# sourceMappingURL=token-pricing.d.ts.map