tachibot-mcp 2.0.2

package/dist/src/utils/tool-compressor.js

@@ -0,0 +1,257 @@
+/**
+ * Tool Compressor - Aggressive token reduction for MCP tools
+ * Target: Reduce from ~400 tokens per tool to ~40 tokens
+ */
+import { z } from 'zod';
+/**
+ * Compress a tool description to minimal tokens
+ */
+export function compressToolDescription(tool) {
+    return {
+        n: compressName(tool.name),
+        d: compressDescription(tool.description),
+        p: compressParameters(tool.parameters)
+    };
+}
+/**
+ * Compress tool name
+ */
+function compressName(name) {
+    // Remove underscores, use abbreviations
+    const abbreviations = {
+        'perplexity': 'pplx',
+        'gemini': 'gem',
+        'openai': 'oai',
+        'research': 'rsch',
+        'analyze': 'anlz',
+        'brainstorm': 'bstm',
+        'workflow': 'wf',
+        'visualize': 'viz',
+        'create': 'mk',
+        'list': 'ls'
+    };
+    let compressed = name.toLowerCase();
+    Object.entries(abbreviations).forEach(([full, abbr]) => {
+        compressed = compressed.replace(full, abbr);
+    });
+    return compressed.replace(/_/g, '');
+}
+/**
+ * Compress description to max 10 words
+ */
+function compressDescription(description) {
+    // Remove common filler words
+    const fillers = ['the', 'a', 'an', 'to', 'for', 'with', 'and', 'or', 'but', 'in', 'on', 'at', 'from', 'by'];
+    const words = description
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(word => !fillers.includes(word))
+        .slice(0, 7); // Max 7 meaningful words
+    return words.join(' ');
+}
+/**
+ * Compress parameters to minimal schema notation
+ */
+function compressParameters(params) {
+    if (!params)
+        return {};
+    const compressed = {};
+    // Handle Zod schema
+    if (params._def) {
+        const shape = params._def.shape?.() || {};
+        Object.entries(shape).forEach(([key, value]) => {
+            compressed[compressParamName(key)] = compressParamType(value);
+        });
+    }
+    // Handle plain object
+    else if (typeof params === 'object') {
+        Object.entries(params).forEach(([key, value]) => {
+            compressed[compressParamName(key)] =
+                typeof value === 'object' ? compressParamType(value) : 's';
+        });
+    }
+    return compressed;
+}
+/**
+ * Compress parameter names
+ */
+function compressParamName(name) {
+    const mapping = {
+        'query': 'q',
+        'prompt': 'p',
+        'model': 'm',
+        'temperature': 't',
+        'maxTokens': 'mx',
+        'max_tokens': 'mx',
+        'context': 'c',
+        'content': 'c',
+        'message': 'msg',
+        'depth': 'd',
+        'name': 'n',
+        'type': 'typ',
+        'projectPath': 'path',
+        'input': 'i',
+        'output': 'o'
+    };
+    return mapping[name] || name.slice(0, 3);
+}
+/**
+ * Compress parameter type to shorthand
+ */
+function compressParamType(zodType) {
+    if (!zodType)
+        return 's'; // Default to string
+    const typeName = zodType._def?.typeName || zodType.type || 'string';
+    const typeMap = {
+        'ZodString': 's',
+        'ZodNumber': 'n',
+        'ZodBoolean': 'b',
+        'ZodArray': 'a',
+        'ZodObject': 'o',
+        'ZodEnum': 'e',
+        'ZodOptional': '?',
+        'string': 's',
+        'number': 'n',
+        'boolean': 'b',
+        'array': 'a',
+        'object': 'o'
+    };
+    let compressed = typeMap[typeName] || 's';
+    // Handle optional
+    if (zodType._def?.typeName === 'ZodOptional') {
+        const innerType = compressParamType(zodType._def.innerType);
+        compressed = innerType + '?';
+    }
+    // Handle enum values
+    if (zodType._def?.values) {
+        const values = zodType._def.values.slice(0, 3).join('|');
+        compressed = `e[${values}]`;
+    }
+    return compressed;
+}
+/**
+ * Consolidate multiple tools into one
+ */
+export function consolidateTools(tools, groupName) {
+    const consolidationMap = {
+        'ai_models': {
+            n: 'ai',
+            d: 'query ai models',
+            p: {
+                m: 's', // model
+                p: 's', // prompt
+                t: 'n?', // temperature (optional)
+                mx: 'n?' // maxTokens (optional)
+            }
+        },
+        'research': {
+            n: 'rsch',
+            d: 'web research citations',
+            p: {
+                q: 's', // query
+                d: 'e[quick|standard|deep]?', // depth
+                s: 'a?' // sources (optional array)
+            }
+        },
+        'code': {
+            n: 'code',
+            d: 'analyze review code',
+            p: {
+                c: 's', // code
+                m: 'e[review|analyze|fix]?', // mode
+                f: 's?' // focus area (optional)
+            }
+        },
+        'workflow': {
+            n: 'wf',
+            d: 'execute workflows',
+            p: {
+                n: 's', // name
+                i: 's', // input
+                o: 'o?' // options (optional object)
+            }
+        }
+    };
+    return consolidationMap[groupName] || {
+        n: groupName.slice(0, 5),
+        d: `${groupName} tools`,
+        p: { i: 's' }
+    };
+}
+/**
+ * Expand compressed tool back to full MCP format
+ */
+export function expandCompressedTool(compressed) {
+    // Expand parameter names
+    const expandParamName = (short) => {
+        const mapping = {
+            'q': 'query',
+            'p': 'prompt',
+            'm': 'model',
+            't': 'temperature',
+            'mx': 'maxTokens',
+            'c': 'content',
+            'd': 'depth',
+            'n': 'name',
+            'i': 'input',
+            'o': 'output'
+        };
+        return mapping[short] || short;
+    };
+    // Expand parameter types
+    const expandParamType = (short) => {
+        if (short.endsWith('?')) {
+            return z.optional(expandParamType(short.slice(0, -1)));
+        }
+        const typeMap = {
+            's': z.string(),
+            'n': z.number(),
+            'b': z.boolean(),
+            'a': z.array(z.string()),
+            'o': z.object({})
+        };
+        // Handle enums
+        if (short.startsWith('e[')) {
+            const values = short.slice(2, -1).split('|');
+            return z.enum(values);
+        }
+        return typeMap[short] || z.string();
+    };
+    // Build expanded parameters
+    const parameters = {};
+    Object.entries(compressed.p).forEach(([key, type]) => {
+        parameters[expandParamName(key)] = expandParamType(type);
+    });
+    return {
+        name: compressed.n,
+        description: compressed.d,
+        parameters: z.object(parameters)
+    };
+}
+/**
+ * Calculate estimated token count for a tool
+ */
+export function estimateTokens(tool) {
+    const str = JSON.stringify(tool);
+    // Rough estimate: 1 token ≈ 4 characters
+    return Math.ceil(str.length / 4);
+}
+/**
+ * Batch compress all tools with token budget
+ */
+export function compressAllTools(tools, maxTokens = 10000) {
+    const compressed = [];
+    let totalTokens = 0;
+    for (const tool of tools) {
+        const comp = compressToolDescription(tool);
+        const tokens = estimateTokens(comp);
+        if (totalTokens + tokens <= maxTokens) {
+            compressed.push(comp);
+            totalTokens += tokens;
+        }
+        else {
+            console.warn(`Skipping tool ${tool.name} - would exceed token budget`);
+        }
+    }
+    return { compressed, totalTokens };
+}

package/dist/src/utils/tool-config.js

@@ -0,0 +1,201 @@
+/**
+ * Tool configuration manager with profile support
+ * Allows disabling specific tools via config file or environment variables
+ *
+ * Precedence (highest to lowest):
+ * 1. customProfile.enabled = true in tools.config.json
+ * 2. TACHIBOT_PROFILE environment variable
+ * 3. activeProfile in tools.config.json
+ * 4. Fallback: all tools enabled
+ */
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let toolConfig = { tools: {} };
+let activeTools = {};
+let profileSource = 'default';
+/**
+ * Load a profile from the profiles/ directory
+ */
+function loadProfileFromFile(profileName) {
+    try {
+        const profilePath = join(__dirname, '../../../profiles', `${profileName}.json`);
+        if (existsSync(profilePath)) {
+            const content = readFileSync(profilePath, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch (error) {
+        console.warn(`⚠️ Could not load profile '${profileName}' from profiles/ directory`);
+    }
+    return null;
+}
+// Load config once at startup
+try {
+    // Use __dirname to find config relative to source code location, not cwd
+    // When built: dist/src/utils/tool-config.js -> go up 3 levels to project root
+    const configPath = join(__dirname, '../../../tools.config.json');
+    if (existsSync(configPath)) {
+        const configContent = readFileSync(configPath, 'utf-8');
+        toolConfig = JSON.parse(configContent);
+        // Priority 1: Custom profile enabled in tools.config.json
+        if (toolConfig.customProfile?.enabled) {
+            activeTools = toolConfig.customProfile.tools;
+            profileSource = 'custom';
+            console.error(`📋 Using custom profile from tools.config.json`);
+        }
+        // Priority 2: TACHIBOT_PROFILE environment variable
+        else if (process.env.TACHIBOT_PROFILE) {
+            const envProfile = process.env.TACHIBOT_PROFILE;
+            const profile = loadProfileFromFile(envProfile);
+            if (profile) {
+                activeTools = profile.tools;
+                profileSource = envProfile;
+                console.error(`📋 Using profile '${envProfile}' from TACHIBOT_PROFILE env var`);
+                console.error(`   ${profile.description}`);
+            }
+            else {
+                console.warn(`⚠️ Profile '${envProfile}' not found, falling back to activeProfile`);
+                // Fall through to next priority
+            }
+        }
+        // Priority 3: activeProfile in tools.config.json
+        if (!activeTools || Object.keys(activeTools).length === 0) {
+            if (toolConfig.activeProfile) {
+                // Try to load from profiles/ directory first (new structure)
+                const profile = loadProfileFromFile(toolConfig.activeProfile);
+                if (profile) {
+                    activeTools = profile.tools;
+                    profileSource = toolConfig.activeProfile;
+                    console.error(`📋 Using profile '${toolConfig.activeProfile}': ${profile.description}`);
+                }
+                // Fall back to embedded profile in tools.config.json (legacy)
+                else if (toolConfig.profiles?.[toolConfig.activeProfile]) {
+                    const profile = toolConfig.profiles[toolConfig.activeProfile];
+                    activeTools = profile.tools;
+                    profileSource = toolConfig.activeProfile;
+                    console.error(`📋 Using profile '${toolConfig.activeProfile}' from tools.config.json (legacy)`);
+                    console.error(`   ${profile.description}`);
+                }
+            }
+            else if (toolConfig.tools) {
+                // Fallback to legacy flat tools config
+                activeTools = toolConfig.tools;
+                profileSource = 'legacy';
+                console.error(`📋 Using legacy flat configuration from tools.config.json`);
+            }
+        }
+    }
+    // Final fallback: all tools enabled
+    if (!activeTools || Object.keys(activeTools).length === 0) {
+        console.warn(`⚠️ No valid configuration found, all tools enabled by default`);
+        profileSource = 'default';
+    }
+}
+catch (error) {
+    console.warn(`⚠️ Could not load tools.config.json, all tools enabled by default`);
+    profileSource = 'default';
+}
+/**
+ * Check if a tool should be registered
+ * Priority: Environment variables > Profile config > Default (enabled)
+ */
+export function isToolEnabled(toolName) {
+    // Environment variable override (highest priority)
+    const envEnable = process.env[`ENABLE_TOOL_${toolName.toUpperCase()}`];
+    if (envEnable === 'true')
+        return true;
+    const envDisable = process.env[`DISABLE_TOOL_${toolName.toUpperCase()}`];
+    if (envDisable === 'true')
+        return false;
+    // Check if globally disabled
+    if (process.env.DISABLE_ALL_TOOLS === 'true')
+        return false;
+    // Check active profile
+    const toolStatus = activeTools[toolName];
+    // If no profile loaded (default mode), enable all tools
+    if (profileSource === 'default') {
+        return true;
+    }
+    // Simple rule: If tool not in profile config, it's DISABLED
+    // Profiles are explicit allowlists - if it's not listed, it's off
+    if (toolStatus === undefined) {
+        return false;
+    }
+    // Use the config value
+    if (!toolStatus) {
+        console.error(`   ⏭️  Skipping ${toolName} (disabled in profile)`);
+    }
+    return toolStatus;
+}
+/**
+ * Get list of disabled tools for logging
+ */
+export function getDisabledTools() {
+    if (!activeTools)
+        return [];
+    return Object.entries(activeTools)
+        .filter(([_, enabled]) => !enabled)
+        .map(([name]) => name);
+}
+/**
+ * Get list of enabled tools for logging
+ */
+export function getEnabledTools() {
+    if (!activeTools)
+        return [];
+    return Object.entries(activeTools)
+        .filter(([_, enabled]) => enabled)
+        .map(([name]) => name);
+}
+/**
+ * Get active profile info
+ */
+export function getActiveProfile() {
+    if (profileSource === 'default') {
+        return null;
+    }
+    if (profileSource === 'custom') {
+        return {
+            name: 'custom',
+            description: toolConfig.customProfile?.description
+        };
+    }
+    if (profileSource === 'legacy') {
+        return {
+            name: 'legacy',
+            description: 'Legacy flat configuration'
+        };
+    }
+    // For named profiles, try to get description
+    const profile = loadProfileFromFile(profileSource);
+    return {
+        name: profileSource,
+        description: profile?.description
+    };
+}
+/**
+ * Log configuration summary
+ */
+export function logToolConfiguration() {
+    const profile = getActiveProfile();
+    if (profile) {
+        console.error(`🎯 Active profile: ${profile.name}`);
+        if (profile.description) {
+            console.error(`   ${profile.description}`);
+        }
+    }
+    const disabled = getDisabledTools();
+    if (disabled.length > 0) {
+        console.error(`🚫 Disabled tools: ${disabled.join(', ')}`);
+    }
+    // Check for environment overrides
+    const envVars = Object.keys(process.env);
+    const toolOverrides = envVars.filter(key => key.startsWith('ENABLE_TOOL_') || key.startsWith('DISABLE_TOOL_'));
+    if (toolOverrides.length > 0) {
+        console.error(`🔧 Environment overrides active: ${toolOverrides.join(', ')}`);
+    }
+}

package/dist/src/validators/dependency-graph-validator.js

@@ -0,0 +1,147 @@
+/**
+ * Dependency graph validator - detects circular dependencies and validates execution order
+ */
+export class DependencyGraphValidator {
+    constructor() {
+        this.interpolationRegex = /\$\{([^.}]+)(?:\.[^}]+)?\}/g;
+    }
+    validate(context) {
+        const errors = [];
+        // Build dependency graph
+        const graph = this.buildDependencyGraph(context.workflow.steps);
+        // Check for circular dependencies
+        const cycle = this.detectCycle(graph);
+        if (cycle) {
+            errors.push({
+                type: 'dependency',
+                severity: 'error',
+                message: `Circular dependency detected: ${cycle.join(' → ')} → ${cycle[0]}`,
+                path: '$.steps',
+                suggestion: 'Reorganize steps to remove circular dependencies'
+            });
+        }
+        // Validate execution order
+        const orderErrors = this.validateExecutionOrder(context.workflow.steps, graph);
+        errors.push(...orderErrors);
+        return errors;
+    }
+    /**
+     * Build dependency graph from workflow steps
+     * Returns Map<stepName, Set<dependencies>>
+     */
+    buildDependencyGraph(steps) {
+        const graph = new Map();
+        steps.forEach(step => {
+            graph.set(step.name, new Set());
+            // Add explicit dependencies
+            if (step.dependsOn && Array.isArray(step.dependsOn)) {
+                step.dependsOn.forEach((dep) => graph.get(step.name).add(dep));
+            }
+            // Add dependencies from loadFiles
+            if (step.loadFiles && Array.isArray(step.loadFiles)) {
+                step.loadFiles.forEach((fileRef) => graph.get(step.name).add(fileRef));
+            }
+            // Add implicit dependencies from interpolations in input
+            if (step.input) {
+                const inputStr = JSON.stringify(step.input);
+                const matches = inputStr.matchAll(this.interpolationRegex);
+                for (const match of matches) {
+                    const reference = match[1]; // Get the step name part
+                    // Only add if it's referencing another step (not a variable)
+                    if (steps.some(s => s.name === reference)) {
+                        graph.get(step.name).add(reference);
+                    }
+                }
+            }
+            // Add implicit dependencies from 'when' condition
+            if (step.when) {
+                const matches = step.when.matchAll(this.interpolationRegex);
+                for (const match of matches) {
+                    const reference = match[1];
+                    if (steps.some(s => s.name === reference)) {
+                        graph.get(step.name).add(reference);
+                    }
+                }
+            }
+        });
+        return graph;
+    }
+    /**
+     * Detect circular dependencies using DFS
+     * Returns the cycle path if found, null otherwise
+     */
+    detectCycle(graph) {
+        const visiting = new Set();
+        const visited = new Set();
+        const path = [];
+        for (const node of graph.keys()) {
+            if (!visited.has(node)) {
+                if (this.hasCycleDFS(node, graph, visiting, visited, path)) {
+                    // Extract just the cycle from the path
+                    const cycleStart = path.indexOf(path[path.length - 1]);
+                    return path.slice(cycleStart);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * DFS helper to detect cycles
+     */
+    hasCycleDFS(node, graph, visiting, visited, path) {
+        if (visiting.has(node)) {
+            // Found a cycle - add the node that creates the cycle
+            path.push(node);
+            return true;
+        }
+        if (visited.has(node)) {
+            return false;
+        }
+        visiting.add(node);
+        path.push(node);
+        const neighbors = graph.get(node) || new Set();
+        for (const neighbor of neighbors) {
+            if (this.hasCycleDFS(neighbor, graph, visiting, visited, path)) {
+                return true;
+            }
+        }
+        visiting.delete(node);
+        visited.add(node);
+        path.pop();
+        return false;
+    }
+    /**
+     * Validate that dependencies appear before dependent steps
+     */
+    validateExecutionOrder(steps, graph) {
+        const errors = [];
+        const stepPositions = new Map(steps.map((s, i) => [s.name, i]));
+        for (const [stepName, dependencies] of graph.entries()) {
+            const currentPos = stepPositions.get(stepName);
+            if (currentPos === undefined)
+                continue;
+            for (const dep of dependencies) {
+                const depPos = stepPositions.get(dep);
+                if (depPos === undefined) {
+                    errors.push({
+                        type: 'dependency',
+                        severity: 'error',
+                        message: `Step '${stepName}' depends on undefined step '${dep}'`,
+                        path: `$.steps[${currentPos}]`,
+                        suggestion: `Define step '${dep}' or remove the dependency`
+                    });
+                }
+                else if (depPos >= currentPos) {
+                    errors.push({
+                        type: 'dependency',
+                        severity: 'error',
+                        message: `Step '${stepName}' depends on '${dep}' which appears later in the workflow`,
+                        path: `$.steps[${currentPos}]`,
+                        suggestion: `Move step '${dep}' (currently at position ${depPos + 1}) before step '${stepName}' (position ${currentPos + 1})`
+                    });
+                }
+            }
+        }
+        return errors;
+    }
+}