@hailer/mcp 0.0.1

package/dist/client/description-updater.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Description Updater for Adaptive Documentation Bot
+ *
+ * Updates tool descriptions in source files based on error analysis.
+ * Modifies ReadTools.ts, WriteTools.ts, and PlaygroundTools.ts.
+ */
+import { Improvement } from './adaptive-documentation-types';
+export declare class DescriptionUpdater {
+    private toolFiles;
+    private improvementHistory;
+    /**
+     * Update tool description in source file
+     */
+    updateToolDescription(toolName: string, newDescription: string, reason: string, triggeredBy?: any): Promise<boolean>;
+    /**
+     * Update parameter description in Zod schema
+     */
+    updateParameterDescription(toolName: string, parameterName: string, newDescription: string, reason: string): Promise<boolean>;
+    /**
+     * Find which file contains the given tool
+     */
+    private findToolFile;
+    /**
+     * Extract current description for a tool
+     */
+    private extractCurrentDescription;
+    /**
+     * Replace description in file content
+     */
+    private replaceDescription;
+    /**
+     * Escape string for insertion into source code
+     */
+    private escapeString;
+    /**
+     * Convert tool name to PascalCase for schema method name
+     */
+    private toPascalCase;
+    /**
+     * Record improvement in history
+     */
+    private recordImprovement;
+    /**
+     * Get improvement history for a specific tool
+     */
+    getImprovementHistory(toolName?: string): Improvement[];
+    /**
+     * Get improvement statistics
+     */
+    getStats(): {
+        totalImprovements: number;
+        byType: Record<string, number>;
+        byTool: Record<string, number>;
+    };
+}
+//# sourceMappingURL=description-updater.d.ts.map

package/dist/client/description-updater.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * Description Updater for Adaptive Documentation Bot
+ *
+ * Updates tool descriptions in source files based on error analysis.
+ * Modifies ReadTools.ts, WriteTools.ts, and PlaygroundTools.ts.
+ */
+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.DescriptionUpdater = 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: 'DescriptionUpdater' });
+class DescriptionUpdater {
+    toolFiles = [
+        path.join(process.cwd(), 'src/mcp/tools/ReadTools.ts'),
+        path.join(process.cwd(), 'src/mcp/tools/WriteTools.ts'),
+        path.join(process.cwd(), 'src/mcp/tools/PlaygroundTools.ts')
+    ];
+    improvementHistory = [];
+    /**
+     * Update tool description in source file
+     */
+    async updateToolDescription(toolName, newDescription, reason, triggeredBy) {
+        try {
+            // Find which file contains this tool
+            const toolFile = await this.findToolFile(toolName);
+            if (!toolFile) {
+                logger.warn('Tool file not found', { toolName });
+                return false;
+            }
+            // Read current file content
+            const oldContent = await fs.readFile(toolFile, 'utf-8');
+            const oldDescription = this.extractCurrentDescription(oldContent, toolName);
+            if (!oldDescription) {
+                logger.warn('Could not extract current description', { toolName, toolFile });
+                return false;
+            }
+            // Check if description actually changed
+            if (oldDescription === newDescription) {
+                logger.debug('Description unchanged, skipping update', { toolName });
+                return false;
+            }
+            // Update the description
+            const newContent = this.replaceDescription(oldContent, toolName, newDescription);
+            // Write back to file
+            await fs.writeFile(toolFile, newContent, 'utf-8');
+            logger.info('✅ Tool description updated', {
+                toolName,
+                file: path.basename(toolFile),
+                reason,
+                oldLength: oldDescription.length,
+                newLength: newDescription.length
+            });
+            // Record improvement
+            this.recordImprovement({
+                timestamp: Date.now(),
+                toolName,
+                type: 'description',
+                oldValue: oldDescription,
+                newValue: newDescription,
+                triggeredBy,
+                reason,
+                applied: true
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to update tool description', error, { toolName });
+            return false;
+        }
+    }
+    /**
+     * Update parameter description in Zod schema
+     */
+    async updateParameterDescription(toolName, parameterName, newDescription, reason) {
+        try {
+            const toolFile = await this.findToolFile(toolName);
+            if (!toolFile) {
+                return false;
+            }
+            const oldContent = await fs.readFile(toolFile, 'utf-8');
+            // Find the schema method for this tool
+            const schemaMethodMatch = oldContent.match(new RegExp(`private static get.*${this.toPascalCase(toolName)}Schema\\(\\)[\\s\\S]*?{([\\s\\S]*?)}\\s*\\}`, 'm'));
+            if (!schemaMethodMatch) {
+                logger.warn('Could not find schema method', { toolName });
+                return false;
+            }
+            // Replace parameter description
+            const paramPattern = new RegExp(`${parameterName}:\\s*z\\.[^.]+\\.describe\\(['"]([^'"]+)['"]\\)`, 'g');
+            const newContent = oldContent.replace(paramPattern, (match) => {
+                return match.replace(/\.describe\(['"]([^'"]+)['"]\)/, `.describe("${newDescription}")`);
+            });
+            if (newContent === oldContent) {
+                logger.debug('Parameter description unchanged', { toolName, parameterName });
+                return false;
+            }
+            await fs.writeFile(toolFile, newContent, 'utf-8');
+            logger.info('✅ Parameter description updated', {
+                toolName,
+                parameterName,
+                file: path.basename(toolFile),
+                reason
+            });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to update parameter description', error, { toolName, parameterName });
+            return false;
+        }
+    }
+    /**
+     * Find which file contains the given tool
+     */
+    async findToolFile(toolName) {
+        for (const file of this.toolFiles) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                // Check if this file contains the tool definition
+                if (content.includes(`name: '${toolName}'`) ||
+                    content.includes(`name: "${toolName}"`)) {
+                    return file;
+                }
+            }
+            catch (error) {
+                // File doesn't exist or can't be read, continue
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract current description for a tool
+     */
+    extractCurrentDescription(content, toolName) {
+        // Pattern 1: name: 'tool_name', description: 'description text'
+        const pattern1 = new RegExp(`name:\\s*['"]${toolName}['"],\\s*description:\\s*['"]([^'"]+)['"]`, 'm');
+        const match1 = content.match(pattern1);
+        if (match1) {
+            return match1[1];
+        }
+        // Pattern 2: Multi-line description with template literals
+        const pattern2 = new RegExp(`name:\\s*['"]${toolName}['"],\\s*description:\\s*\`([^\`]+)\``, 'm');
+        const match2 = content.match(pattern2);
+        if (match2) {
+            return match2[1];
+        }
+        return null;
+    }
+    /**
+     * Replace description in file content
+     */
+    replaceDescription(content, toolName, newDescription) {
+        // Escape special regex characters in tool name
+        const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Pattern 1: Single-quote strings (handles escaped quotes and nested double quotes)
+        // Matches: description: 'text with "nested" quotes and \'escaped\' quotes',
+        const pattern1 = new RegExp(`(name:\\s*['"]${escapedToolName}['"],\\s*description:\\s*)'((?:[^'\\\\]|\\\\.)*)'`, 'gm');
+        let newContent = content.replace(pattern1, `$1'${this.escapeString(newDescription)}'`);
+        // Pattern 2: Double-quote strings (handles escaped quotes and nested single quotes)
+        // Matches: description: "text with 'nested' quotes and \"escaped\" quotes"
+        const pattern2 = new RegExp(`(name:\\s*['"]${escapedToolName}['"],\\s*description:\\s*)"((?:[^"\\\\]|\\\\.)*)"`, 'gm');
+        newContent = newContent.replace(pattern2, `$1'${this.escapeString(newDescription)}'`);
+        // Pattern 3: Multi-line description with template literals
+        const pattern3 = new RegExp(`(name:\\s*['"]${escapedToolName}['"],\\s*description:\\s*)\`([^\`]+)\``, 'gm');
+        newContent = newContent.replace(pattern3, `$1'${this.escapeString(newDescription)}'`);
+        return newContent;
+    }
+    /**
+     * Escape string for insertion into source code
+     */
+    escapeString(str) {
+        return str
+            .replace(/\\/g, '\\\\')
+            .replace(/'/g, "\\'")
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t');
+    }
+    /**
+     * Convert tool name to PascalCase for schema method name
+     */
+    toPascalCase(str) {
+        return str
+            .split('_')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+    }
+    /**
+     * Record improvement in history
+     */
+    recordImprovement(improvement) {
+        this.improvementHistory.push(improvement);
+        // Keep only last 100 improvements
+        if (this.improvementHistory.length > 100) {
+            this.improvementHistory = this.improvementHistory.slice(-100);
+        }
+    }
+    /**
+     * Get improvement history for a specific tool
+     */
+    getImprovementHistory(toolName) {
+        if (toolName) {
+            return this.improvementHistory.filter(imp => imp.toolName === toolName);
+        }
+        return this.improvementHistory;
+    }
+    /**
+     * Get improvement statistics
+     */
+    getStats() {
+        const byType = {};
+        const byTool = {};
+        for (const improvement of this.improvementHistory) {
+            byType[improvement.type] = (byType[improvement.type] || 0) + 1;
+            byTool[improvement.toolName] = (byTool[improvement.toolName] || 0) + 1;
+        }
+        return {
+            totalImprovements: this.improvementHistory.length,
+            byType,
+            byTool
+        };
+    }
+}
+exports.DescriptionUpdater = DescriptionUpdater;
+//# sourceMappingURL=description-updater.js.map

package/dist/client/log-parser.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Log Parser for Adaptive Documentation Bot
+ *
+ * Parses MCP server logs to extract tool call errors and LLM mistakes.
+ * Monitors both file-based logs and live log streams.
+ */
+import { ToolCallError } from './adaptive-documentation-types';
+export declare class LogParser {
+    private logPath;
+    private statePath;
+    private lastReadPosition;
+    private lastProcessedTimestamp;
+    private seenErrors;
+    constructor(logPath?: string);
+    /**
+     * Parse recent logs for tool call errors
+     * Returns only new errors since last parse
+     */
+    parseToolCallErrors(retries?: number): Promise<ToolCallError[]>;
+    /**
+     * Parse a single log entry for error patterns
+     */
+    private parseLogEntry;
+    /**
+     * Extract tool call error from JSON log entry
+     */
+    private extractToolCallError;
+    /**
+     * Extract validation error
+     */
+    private extractValidationError;
+    /**
+     * Extract parameter error
+     */
+    private extractParameterError;
+    /**
+     * Extract tool name from error message
+     */
+    private extractToolNameFromMessage;
+    /**
+     * Check if error is a duplicate
+     */
+    private isDuplicate;
+    /**
+     * Generate unique signature for error deduplication
+     */
+    private getErrorSignature;
+    /**
+     * Check if file exists
+     */
+    private fileExists;
+    /**
+     * Reset parser state (useful for testing)
+     */
+    reset(): void;
+    /**
+     * Get statistics about parsed errors
+     */
+    getStats(): {
+        totalSeen: number;
+        uniqueErrors: number;
+    };
+    /**
+     * Load parser state from disk synchronously (called in constructor)
+     */
+    private loadStateSync;
+    /**
+     * Save parser state to disk
+     */
+    private saveState;
+}
+//# sourceMappingURL=log-parser.d.ts.map