mentat-mcp 1.0.0

package/dist/skills/engine.js

@@ -0,0 +1,362 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { z } from 'zod';
+// Skill definition schema
+const SkillSchema = z.object({
+    skill: z.object({
+        id: z.string(),
+        name: z.string(),
+        description: z.string(),
+        category: z.string(),
+        pricing: z.union([z.literal('free'), z.number()]),
+        author: z.string().optional(),
+        version: z.string(),
+        inputs: z.record(z.object({
+            type: z.enum(['string', 'number', 'boolean', 'select', 'multiselect']),
+            required: z.boolean(),
+            default: z.any().optional(),
+            description: z.string(),
+            options: z.array(z.string()).optional(),
+        })).optional(),
+        context_needed: z.array(z.object({
+            description: z.string(),
+            pattern: z.string(),
+            max_files: z.number().optional(),
+        })).optional(),
+        execution: z.array(z.object({
+            step: z.string(),
+        }).passthrough()),
+        validation: z.array(z.object({
+            check: z.string(),
+        }).passthrough()).optional(),
+        success_message: z.string(),
+        estimated_time: z.number(),
+    }),
+});
+export class SkillEngine {
+    constructor(workspacePath) {
+        this.workspacePath = workspacePath;
+        this.backupPath = path.join(workspacePath, '.skill-backups');
+    }
+    /**
+     * Load and parse skill definition from YAML
+     */
+    async loadSkill(skillPath) {
+        const content = await fs.readFile(skillPath, 'utf-8');
+        const parsed = yaml.parse(content);
+        return SkillSchema.parse(parsed);
+    }
+    /**
+     * Execute a skill with given inputs
+     */
+    async executeSkill(skillDefinition, inputs, context) {
+        const { skill } = skillDefinition;
+        try {
+            // Step 1: Validate inputs
+            this.validateInputs(skill.inputs || {}, inputs);
+            // Step 2: Create backup of files we might modify
+            await this.createBackup(context.files || []);
+            // Step 3: Initialize execution state
+            const state = {
+                inputs,
+                context,
+                changes: [],
+            };
+            // Step 4: Run validation checks
+            if (skill.validation) {
+                for (const validation of skill.validation) {
+                    await this.runValidation(validation, state);
+                }
+            }
+            // Step 5: Execute steps
+            for (const step of skill.execution) {
+                await this.executeStep(step, state);
+            }
+            // Step 6: Return success
+            return {
+                success: true,
+                message: skill.success_message,
+                changes: state.changes,
+            };
+        }
+        catch (error) {
+            // Rollback on error
+            await this.rollback();
+            return {
+                success: false,
+                message: 'Skill execution failed',
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Validate inputs against skill definition
+     */
+    validateInputs(inputDef, inputs) {
+        for (const [key, def] of Object.entries(inputDef)) {
+            const value = inputs[key];
+            // Check required
+            if (def.required && value === undefined) {
+                throw new Error(`Missing required input: ${key}`);
+            }
+            // Type validation
+            if (value !== undefined) {
+                switch (def.type) {
+                    case 'string':
+                        if (typeof value !== 'string') {
+                            throw new Error(`Input ${key} must be a string`);
+                        }
+                        break;
+                    case 'number':
+                        if (typeof value !== 'number') {
+                            throw new Error(`Input ${key} must be a number`);
+                        }
+                        break;
+                    case 'boolean':
+                        if (typeof value !== 'boolean') {
+                            throw new Error(`Input ${key} must be a boolean`);
+                        }
+                        break;
+                    case 'select':
+                        if (!def.options?.includes(value)) {
+                            throw new Error(`Input ${key} must be one of: ${def.options?.join(', ')}`);
+                        }
+                        break;
+                    case 'multiselect':
+                        if (!Array.isArray(value)) {
+                            throw new Error(`Input ${key} must be an array`);
+                        }
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * Run validation check
+     */
+    async runValidation(validation, state) {
+        const { check } = validation;
+        switch (check) {
+            case 'valid_javascript':
+                // Would need actual JS parser - simplified for MVP
+                break;
+            case 'no_syntax_errors':
+                // Would need linting - simplified for MVP
+                break;
+            case 'file_exists':
+                const filePath = this.resolvePath(validation.path, state);
+                try {
+                    await fs.access(filePath);
+                }
+                catch {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                break;
+        }
+    }
+    /**
+     * Execute a single step
+     */
+    async executeStep(step, state) {
+        switch (step.step) {
+            case 'read_file':
+                await this.stepReadFile(step, state);
+                break;
+            case 'write_file':
+                await this.stepWriteFile(step, state);
+                break;
+            case 'update_file':
+                await this.stepUpdateFile(step, state);
+                break;
+            case 'delete_file':
+                await this.stepDeleteFile(step, state);
+                break;
+            case 'rename_file':
+                await this.stepRenameFile(step, state);
+                break;
+            case 'for_each':
+                await this.stepForEach(step, state);
+                break;
+            case 'analyze_code':
+            case 'generate_types':
+            case 'transform':
+                // These would require AI/LLM calls - simplified for MVP
+                // In production, these would call Claude API
+                state[step.save_as] = `[Generated content for ${step.step}]`;
+                break;
+            default:
+                console.warn(`Unknown step type: ${step.step}`);
+        }
+    }
+    /**
+     * Read file step
+     */
+    async stepReadFile(step, state) {
+        const filePath = this.resolvePath(step.path, state);
+        this.validateFilePath(filePath);
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (step.save_as) {
+            state[step.save_as] = content;
+        }
+    }
+    /**
+     * Write file step
+     */
+    async stepWriteFile(step, state) {
+        const filePath = this.resolvePath(step.path, state);
+        this.validateFilePath(filePath);
+        const content = this.resolveValue(step.content, state);
+        await fs.writeFile(filePath, content, 'utf-8');
+        state.changes.push({
+            type: 'create',
+            path: filePath,
+            content,
+        });
+    }
+    /**
+     * Update file step
+     */
+    async stepUpdateFile(step, state) {
+        const filePath = this.resolvePath(step.path, state);
+        this.validateFilePath(filePath);
+        let content = await fs.readFile(filePath, 'utf-8');
+        const newContent = this.resolveValue(step.content, state);
+        switch (step.operation) {
+            case 'insert_after':
+                const target = step.target;
+                content = content.replace(target, `${target}\n${newContent}`);
+                break;
+            case 'replace':
+                content = newContent;
+                break;
+            case 'append':
+                content += `\n${newContent}`;
+                break;
+        }
+        await fs.writeFile(filePath, content, 'utf-8');
+        state.changes.push({
+            type: 'update',
+            path: filePath,
+            content,
+        });
+    }
+    /**
+     * Delete file step
+     */
+    async stepDeleteFile(step, state) {
+        const filePath = this.resolvePath(step.path, state);
+        this.validateFilePath(filePath);
+        await fs.unlink(filePath);
+        state.changes.push({
+            type: 'delete',
+            path: filePath,
+        });
+    }
+    /**
+     * Rename file step
+     */
+    async stepRenameFile(step, state) {
+        const fromPath = this.resolvePath(step.from, state);
+        const toPath = this.resolvePath(step.to, state);
+        this.validateFilePath(fromPath);
+        this.validateFilePath(toPath);
+        await fs.rename(fromPath, toPath);
+        state.changes.push({
+            type: 'delete',
+            path: fromPath,
+        });
+        state.changes.push({
+            type: 'create',
+            path: toPath,
+        });
+    }
+    /**
+     * For each loop step
+     */
+    async stepForEach(step, state) {
+        const items = this.resolveValue(step.items, state);
+        if (!Array.isArray(items)) {
+            throw new Error('for_each items must be an array');
+        }
+        for (const item of items) {
+            // Create sub-state with loop variable
+            const loopState = {
+                ...state,
+                [step.as]: item,
+            };
+            // Execute sub-steps
+            for (const subStep of step.do) {
+                await this.executeStep(subStep, loopState);
+            }
+        }
+    }
+    /**
+     * Resolve path with variable substitution
+     */
+    resolvePath(pathTemplate, state) {
+        const resolved = this.resolveValue(pathTemplate, state);
+        return path.resolve(this.workspacePath, resolved);
+    }
+    /**
+     * Resolve value with variable substitution
+     */
+    resolveValue(template, state) {
+        if (typeof template !== 'string') {
+            return template;
+        }
+        // Replace ${variable} patterns
+        return template.replace(/\$\{([^}]+)\}/g, (match, varPath) => {
+            const value = this.getNestedValue(state, varPath);
+            return value !== undefined ? value : match;
+        });
+    }
+    /**
+     * Get nested value from object (e.g., "context.files[0]")
+     */
+    getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === undefined)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+    /**
+     * Validate file path is within workspace
+     */
+    validateFilePath(filePath) {
+        const resolved = path.resolve(filePath);
+        const workspace = path.resolve(this.workspacePath);
+        if (!resolved.startsWith(workspace)) {
+            throw new Error('File path outside workspace not allowed');
+        }
+    }
+    /**
+     * Create backup of files
+     */
+    async createBackup(files) {
+        await fs.mkdir(this.backupPath, { recursive: true });
+        const timestamp = Date.now();
+        for (const file of files) {
+            try {
+                const content = await fs.readFile(file, 'utf-8');
+                const backupFile = path.join(this.backupPath, `${timestamp}-${path.basename(file)}`);
+                await fs.writeFile(backupFile, content, 'utf-8');
+            }
+            catch (error) {
+                // File might not exist yet, skip backup
+            }
+        }
+    }
+    /**
+     * Rollback changes on error
+     */
+    async rollback() {
+        // In production, this would restore from backup
+        // For MVP, just log the error
+        console.error('Rollback triggered - restore from backup directory');
+    }
+}

package/dist/skills.js

@@ -0,0 +1,141 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { glob } from 'glob';
+const LIMITS = {
+    maxFiles: 10,
+    maxFileSize: 50000,
+    maxTotalChars: 400000,
+};
+export class SkillLibrary {
+    constructor(skillsPath, workspacePath) {
+        this.skillsPath = skillsPath;
+        this.workspacePath = workspacePath;
+    }
+    /**
+     * Load skill from YAML
+     */
+    async loadSkill(skillId) {
+        const skillPath = path.join(this.skillsPath, `${skillId}.yaml`);
+        const content = await fs.readFile(skillPath, 'utf-8');
+        const parsed = yaml.parse(content);
+        return {
+            id: parsed.skill.id,
+            name: parsed.skill.name,
+            description: parsed.skill.description,
+            instructions: parsed.skill.instructions || this.generateInstructions(parsed.skill),
+            context_patterns: parsed.skill.context_patterns,
+            examples: parsed.skill.examples,
+        };
+    }
+    /**
+     * Gather file context based on patterns or explicit files
+     */
+    async gatherContext(patterns = [], explicitFiles = []) {
+        const filePaths = new Set();
+        // Add explicit files
+        explicitFiles.forEach((f) => filePaths.add(path.resolve(this.workspacePath, f)));
+        // Add files matching patterns
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: this.workspacePath,
+                absolute: true,
+                ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
+            });
+            matches.slice(0, LIMITS.maxFiles).forEach((f) => filePaths.add(f));
+        }
+        // Rank and limit files
+        const rankedFiles = await this.rankFiles(Array.from(filePaths));
+        const limitedFiles = rankedFiles.slice(0, LIMITS.maxFiles);
+        // Read file contents
+        const files = [];
+        let totalChars = 0;
+        let truncated = false;
+        for (const filePath of limitedFiles) {
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size > LIMITS.maxFileSize) {
+                    truncated = true;
+                    continue;
+                }
+                if (totalChars + stats.size > LIMITS.maxTotalChars) {
+                    truncated = true;
+                    break;
+                }
+                const content = await fs.readFile(filePath, 'utf-8');
+                const lines = content.split('\n').length;
+                files.push({
+                    path: path.relative(this.workspacePath, filePath),
+                    content,
+                    lines,
+                });
+                totalChars += content.length;
+            }
+            catch (error) {
+                console.error(`Failed to read ${filePath}:`, error);
+            }
+        }
+        return { files, totalChars, truncated };
+    }
+    /**
+     * Rank files by relevance
+     */
+    async rankFiles(files) {
+        const scored = await Promise.all(files.map(async (f) => {
+            const stats = await fs.stat(f).catch(() => null);
+            const relativePath = path.relative(this.workspacePath, f);
+            let score = 0;
+            // Deprioritize test files
+            if (relativePath.includes('test') || relativePath.includes('spec')) {
+                score -= 100;
+            }
+            // Prefer root-level files
+            const depth = relativePath.split(path.sep).length;
+            score -= depth * 10;
+            // Slight preference for smaller files
+            if (stats) {
+                score -= stats.size / 10000;
+            }
+            return { path: f, score };
+        }));
+        return scored.sort((a, b) => b.score - a.score).map((s) => s.path);
+    }
+    /**
+     * Format skill + context for Claude to read
+     */
+    formatForClaude(skill, context) {
+        const parts = [];
+        parts.push(`# ${skill.name}`);
+        parts.push(`${skill.description}\n`);
+        parts.push(`## Instructions`);
+        parts.push(skill.instructions);
+        parts.push('');
+        if (skill.examples) {
+            parts.push(`## Examples`);
+            parts.push(skill.examples);
+            parts.push('');
+        }
+        if (context.files.length > 0) {
+            parts.push(`## Context (${context.files.length} file${context.files.length > 1 ? 's' : ''})`);
+            for (const file of context.files) {
+                parts.push(`\n### ${file.path} (${file.lines} lines)`);
+                parts.push('```');
+                parts.push(file.content);
+                parts.push('```');
+            }
+            if (context.truncated) {
+                parts.push(`\n⚠️  Some files were excluded due to size limits.`);
+            }
+        }
+        parts.push(`\n---`);
+        parts.push(`Use your Edit tool to make changes.`);
+        parts.push(`Use Read tool if you need additional files.`);
+        return parts.join('\n');
+    }
+    /**
+     * Backward compatibility for old YAML format
+     */
+    generateInstructions(skillDef) {
+        return skillDef.description || 'Complete the task as described.';
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "mentat-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for terminal AI tools (Claude Code, Cursor CLI, Codex CLI) - execute skills and hire AI workers",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "mentat": "./dist/setup.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "setup": "node dist/setup.js"
+  },
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "cursor",
+    "codex",
+    "ai",
+    "agents",
+    "marketplace",
+    "mentat",
+    "dune"
+  ],
+  "author": "Victor Gardrinier",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vgardrinier/a2a_marketplace.git",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://github.com/vgardrinier/a2a_marketplace#readme",
+  "bugs": {
+    "url": "https://github.com/vgardrinier/a2a_marketplace/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "glob": "^10.3.10",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}