@indiccoder/mentis-cli 1.0.8 → 1.1.0

package/dist/commands/SlashCommandTool.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * SlashCommandTool - Tool for model-invoked custom command execution
+ * The model can call this tool when it determines a custom command should be run
+ */
+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.ListCommandsTool = exports.SlashCommandTool = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SlashCommandTool {
+    constructor(commandManager) {
+        this.name = 'slash_command';
+        this.description = 'Execute a custom slash command. Available commands can be seen in /help. Example: slash_command({ name: "review", arguments: ["src/file.ts"] })';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'The name of the custom command to execute'
+                },
+                arguments: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Arguments to pass to the command'
+                }
+            },
+            required: ['name']
+        };
+        this.commandManager = commandManager;
+    }
+    async execute(args) {
+        const { name, arguments: cmdArgs = [] } = args;
+        if (!name) {
+            return 'Error: Command name is required';
+        }
+        const command = this.commandManager.getCommand(name);
+        if (!command) {
+            const availableCommands = this.commandManager.getAllCommands().map(c => c.name).join(', ');
+            return `Error: Command "${name}" not found. Available commands: ${availableCommands || 'none'}`;
+        }
+        try {
+            // Parse command and handle substitutions
+            const parsed = await this.commandManager.parseCommand(command, cmdArgs);
+            let content = parsed.content;
+            // Execute bash commands and collect results
+            const bashResults = [];
+            for (const bashCmd of parsed.bashCommands) {
+                try {
+                    const result = await execAsync(bashCmd);
+                    bashResults.push(`${bashCmd}\n${result.stdout}`);
+                }
+                catch (error) {
+                    bashResults.push(`${bashCmd}\nError: ${error.message}`);
+                }
+            }
+            // Substitute bash outputs into content
+            let bashIndex = 0;
+            content = content.replace(/\[BASH_OUTPUT\]/g, () => {
+                return bashResults[bashIndex++] || '';
+            });
+            // Read file references
+            const fileContents = [];
+            for (const filePath of parsed.fileReferences) {
+                try {
+                    const fileContent = fs.readFileSync(filePath, 'utf-8');
+                    fileContents.push(`\n=== File: ${filePath} ===\n${fileContent}\n=== End of ${filePath} ===\n`);
+                }
+                catch (error) {
+                    fileContents.push(`\n=== File: ${filePath} ===\nError: ${error.message}\n=== End of ${filePath} ===\n`);
+                }
+            }
+            // Substitute file references
+            let fileIndex = 0;
+            content = content.replace(/@[^\s]+/g, () => {
+                return fileContents[fileIndex++] || '';
+            });
+            return `# Executing: /${name}${cmdArgs.length ? ' ' + cmdArgs.join(' ') : ''}\n\n${content}`;
+        }
+        catch (error) {
+            return `Error executing command "${name}": ${error.message}`;
+        }
+    }
+}
+exports.SlashCommandTool = SlashCommandTool;
+/**
+ * ListCommandsTool - Tool for listing custom commands
+ */
+class ListCommandsTool {
+    constructor(commandManager) {
+        this.name = 'list_commands';
+        this.description = 'List all available custom slash commands with their descriptions';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+        this.commandManager = commandManager;
+    }
+    async execute() {
+        const commands = this.commandManager.getAllCommands();
+        if (commands.length === 0) {
+            return 'No custom commands available. Add commands to ~/.mentis/commands/ or .mentis/commands/';
+        }
+        let response = `# Custom Commands (${commands.length})\n\n`;
+        // Group by namespace
+        const grouped = new Map();
+        for (const cmd of commands) {
+            const ns = cmd.description.match(/\(([^)]+)\)/)?.[1] || cmd.type;
+            if (!grouped.has(ns)) {
+                grouped.set(ns, []);
+            }
+            grouped.get(ns).push(cmd);
+        }
+        for (const [namespace, cmds] of grouped) {
+            response += `## ${namespace}\n\n`;
+            for (const cmd of cmds) {
+                const params = cmd.frontmatter['argument-hint'] ? ` ${cmd.frontmatter['argument-hint']}` : '';
+                response += `**/${cmd.name}${params}**\n`;
+                response += `${cmd.description}\n\n`;
+            }
+        }
+        return response;
+    }
+}
+exports.ListCommandsTool = ListCommandsTool;

package/dist/repl/ReplManager.js

@@ -52,6 +52,13 @@ const WebSearchTool_1 = require("../tools/WebSearchTool");
 const GitTools_1 = require("../tools/GitTools");
 const McpClient_1 = require("../mcp/McpClient");
 const CheckpointManager_1 = require("../checkpoint/CheckpointManager");
+const SkillsManager_1 = require("../skills/SkillsManager");
+const LoadSkillTool_1 = require("../skills/LoadSkillTool");
+const ContextVisualizer_1 = require("../utils/ContextVisualizer");
+const ProjectInitializer_1 = require("../utils/ProjectInitializer");
+const ConversationCompacter_1 = require("../utils/ConversationCompacter");
+const CommandManager_1 = require("../commands/CommandManager");
+const SlashCommandTool_1 = require("../commands/SlashCommandTool");
 const readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -66,10 +73,16 @@ class ReplManager {
         this.tools = [];
         this.mcpClients = [];
         this.currentModelName = 'Unknown';
+        this.activeSkill = null; // Track currently active skill for allowed-tools
         this.configManager = new ConfigManager_1.ConfigManager();
         this.contextManager = new ContextManager_1.ContextManager();
         this.checkpointManager = new CheckpointManager_1.CheckpointManager();
+        this.skillsManager = new SkillsManager_1.SkillsManager();
+        this.contextVisualizer = new ContextVisualizer_1.ContextVisualizer();
+        this.conversationCompacter = new ConversationCompacter_1.ConversationCompacter();
+        this.commandManager = new CommandManager_1.CommandManager();
         this.shell = new PersistentShell_1.PersistentShell();
+        // Create tools array without skill tools first
         this.tools = [
             new FileTools_1.WriteFileTool(),
             new FileTools_1.ReadFileTool(),
@@ -90,6 +103,62 @@ class ReplManager {
         });
         // Default to Ollama if not specified, assuming compatible endpoint
         this.initializeClient();
+        // Initialize skills system after client is ready
+        this.initializeSkills();
+    }
+    /**
+     * Initialize the skills and custom commands system
+     */
+    async initializeSkills() {
+        // Initialize skills
+        this.skillsManager.ensureDirectoriesExist();
+        await this.skillsManager.discoverSkills();
+        // Initialize custom commands
+        this.commandManager.ensureDirectoriesExist();
+        await this.commandManager.discoverCommands();
+        // Add skill tools to the tools list
+        // Pass callback to LoadSkillTool to track active skill
+        this.tools.push(new LoadSkillTool_1.LoadSkillTool(this.skillsManager, (skill) => {
+            this.activeSkill = skill ? skill.name : null;
+        }), new LoadSkillTool_1.ListSkillsTool(this.skillsManager), new LoadSkillTool_1.ReadSkillFileTool(this.skillsManager), new SlashCommandTool_1.SlashCommandTool(this.commandManager), new SlashCommandTool_1.ListCommandsTool(this.commandManager));
+    }
+    /**
+     * Check if a tool is allowed by the currently active skill
+     * Returns true if tool is allowed, false if it requires confirmation
+     */
+    isToolAllowedBySkill(toolName) {
+        if (!this.activeSkill) {
+            // No active skill, all tools require confirmation as per normal flow
+            return false;
+        }
+        const skill = this.skillsManager.getSkill(this.activeSkill);
+        if (!skill || !skill.allowedTools || skill.allowedTools.length === 0) {
+            // No skill or no allowed-tools restriction
+            return false;
+        }
+        // Map tool names to allowed tool names
+        const toolMapping = {
+            'write_file': 'Write',
+            'read_file': 'Read',
+            'edit_file': 'Edit',
+            'search_files': 'Grep',
+            'list_dir': 'ListDir',
+            'search_file': 'SearchFile',
+            'run_shell': 'RunShell',
+            'web_search': 'WebSearch',
+            'git_status': 'GitStatus',
+            'git_diff': 'GitDiff',
+            'git_commit': 'GitCommit',
+            'git_push': 'GitPush',
+            'git_pull': 'GitPull',
+            'load_skill': 'Read',
+            'list_skills': 'Read',
+            'read_skill_file': 'Read',
+            'slash_command': 'Read',
+            'list_commands': 'Read'
+        };
+        const mappedToolName = toolMapping[toolName] || toolName;
+        return skill.allowedTools.includes(mappedToolName);
     }
     initializeClient() {
         const config = this.configManager.getConfig();
@@ -197,16 +266,17 @@ class ReplManager {
                 console.log('  /drop <file> - Remove file from context');
                 console.log('  /plan    - Switch to PLAN mode');
                 console.log('  /build   - Switch to BUILD mode');
-                console.log('  /plan    - Switch to PLAN mode');
-                console.log('  /build   - Switch to BUILD mode');
                 console.log('  /model   - Interactively select Provider & Model');
                 console.log('  /use <provider> [model] - Quick switch (legacy)');
                 console.log('  /mcp <cmd> - Manage MCP servers');
+                console.log('  /skills <list|show|create|validate> - Manage Agent Skills');
+                console.log('  /commands <list|create|validate> - Manage Custom Commands');
                 console.log('  /resume  - Resume last session');
                 console.log('  /checkpoint <save|load|list> [name] - Manage checkpoints');
                 console.log('  /search <query> - Search codebase');
                 console.log('  /run <cmd> - Run shell command');
                 console.log('  /commit [msg] - Git commit all changes');
+                console.log('  /init    - Initialize project with .mentis.md');
                 break;
             case '/plan':
                 this.mode = 'PLAN';
@@ -278,12 +348,23 @@ class ReplManager {
                 const updater = new UpdateManager();
                 await updater.checkAndPerformUpdate(true);
                 break;
+            case '/init':
+                await this.handleInitCommand();
+                break;
+            case '/skills':
+                await this.handleSkillsCommand(args);
+                break;
+            case '/commands':
+                await this.handleCommandsCommand(args);
+                break;
             default:
                 console.log(chalk_1.default.red(`Unknown command: ${command}`));
         }
     }
     async handleChat(input) {
         const context = this.contextManager.getContextString();
+        const skillsContext = this.skillsManager.getSkillsContext();
+        const commandsContext = this.commandManager.getCommandsContext();
         let fullInput = input;
         let modeInstruction = '';
         if (this.mode === 'PLAN') {
@@ -293,6 +374,14 @@ class ReplManager {
             modeInstruction = '\n[SYSTEM: You are in BUILD mode. Focus on implementing working code that solves the user request efficiently.]';
         }
         fullInput = `${input}${modeInstruction}`;
+        // Add skills context if available
+        if (skillsContext) {
+            fullInput = `${skillsContext}\n\n${fullInput}`;
+        }
+        // Add commands context if available
+        if (commandsContext) {
+            fullInput = `${commandsContext}\n\n${fullInput}`;
+        }
         if (context) {
             fullInput = `${context}\n\nUser Question: ${fullInput}`;
         }
@@ -345,7 +434,8 @@ class ReplManager {
                     }
                     console.log(chalk_1.default.dim(`  [Action] ${toolName}(${displayArgs})`));
                     // Safety check for write_file
-                    if (toolName === 'write_file') {
+                    // Skip confirmation if tool is allowed by active skill
+                    if (toolName === 'write_file' && !this.isToolAllowedBySkill('Write')) {
                         // Pause cancellation listener during user interaction
                         if (process.stdin.isTTY) {
                             process.stdin.removeListener('keypress', keyListener);
@@ -431,8 +521,16 @@ class ReplManager {
                     const totalCost = this.estimateCost(input_tokens, output_tokens);
                     console.log(chalk_1.default.dim(`\n(Tokens: ${input_tokens} in / ${output_tokens} out | Est. Cost: $${totalCost.toFixed(5)})`));
                 }
+                // Display context bar
+                const contextBar = this.contextVisualizer.getContextBar(this.history);
+                console.log(chalk_1.default.dim(`\n${contextBar}`));
                 console.log('');
                 this.history.push({ role: 'assistant', content: response.content });
+                // Auto-compact prompt when context is at 80%
+                const usage = this.contextVisualizer.calculateUsage(this.history);
+                if (usage.percentage >= 80) {
+                    this.history = await this.conversationCompacter.promptIfCompactNeeded(usage.percentage, this.history, this.modelClient);
+                }
             }
         }
         catch (error) {
@@ -827,6 +925,150 @@ class ReplManager {
             console.log(lastMsg.content);
         }
     }
+    async handleSkillsCommand(args) {
+        const { SkillCreator, validateSkills } = await Promise.resolve().then(() => __importStar(require('../skills/SkillCreator')));
+        if (args.length < 1) {
+            // Show skills list by default
+            await this.handleSkillsCommand(['list']);
+            return;
+        }
+        const action = args[0];
+        switch (action) {
+            case 'list':
+                await this.handleSkillsList();
+                break;
+            case 'show':
+                if (args.length < 2) {
+                    console.log(chalk_1.default.red('Usage: /skills show <name>'));
+                    return;
+                }
+                await this.handleSkillsShow(args[1]);
+                break;
+            case 'create':
+                const creator = new SkillCreator(this.skillsManager);
+                await creator.run(args[1]);
+                // Re-discover skills after creation
+                await this.skillsManager.discoverSkills();
+                break;
+            case 'validate':
+                await validateSkills(this.skillsManager);
+                break;
+            default:
+                console.log(chalk_1.default.red(`Unknown skills action: ${action}`));
+                console.log(chalk_1.default.yellow('Available actions: list, show, create, validate'));
+        }
+    }
+    async handleSkillsList() {
+        const skills = this.skillsManager.getAllSkills();
+        if (skills.length === 0) {
+            console.log(chalk_1.default.yellow('No skills available.'));
+            console.log(chalk_1.default.dim('Create skills with: /skills create'));
+            console.log(chalk_1.default.dim('Add skills to: ~/.mentis/skills/ or .mentis/skills/'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`\nAvailable Skills (${skills.length}):\n`));
+        for (const skill of skills) {
+            const statusIcon = skill.isValid ? '✓' : '✗';
+            const typeLabel = skill.type === 'personal' ? 'Personal' : 'Project';
+            console.log(`${statusIcon} ${chalk_1.default.bold(skill.name)} (${typeLabel})`);
+            console.log(`  ${skill.description}`);
+            if (skill.allowedTools && skill.allowedTools.length > 0) {
+                console.log(chalk_1.default.dim(`  Allowed tools: ${skill.allowedTools.join(', ')}`));
+            }
+            if (!skill.isValid && skill.errors) {
+                console.log(chalk_1.default.red(`  Errors: ${skill.errors.join(', ')}`));
+            }
+            console.log('');
+        }
+    }
+    async handleSkillsShow(name) {
+        const skill = await this.skillsManager.loadFullSkill(name);
+        if (!skill) {
+            console.log(chalk_1.default.red(`Skill "${name}" not found.`));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`\n# ${skill.name}\n`));
+        console.log(chalk_1.default.dim(`Type: ${skill.type}`));
+        console.log(chalk_1.default.dim(`Path: ${skill.path}`));
+        if (skill.allowedTools && skill.allowedTools.length > 0) {
+            console.log(chalk_1.default.dim(`Allowed tools: ${skill.allowedTools.join(', ')}`));
+        }
+        console.log('');
+        console.log(skill.content || 'No content available');
+        // List supporting files
+        const files = this.skillsManager.listSkillFiles(name);
+        if (files.length > 0) {
+            console.log(chalk_1.default.dim(`\nSupporting files: ${files.join(', ')}`));
+        }
+    }
+    async handleInitCommand() {
+        const initializer = new ProjectInitializer_1.ProjectInitializer();
+        await initializer.run();
+    }
+    async handleCommandsCommand(args) {
+        if (args.length < 1) {
+            // Show commands list by default
+            await this.handleCommandsCommand(['list']);
+            return;
+        }
+        const action = args[0];
+        switch (action) {
+            case 'list':
+                await this.handleCommandsList();
+                break;
+            case 'create':
+                await this.handleCommandsCreate(args[1]);
+                break;
+            case 'validate':
+                await this.handleCommandsValidate();
+                break;
+            default:
+                console.log(chalk_1.default.red(`Unknown commands action: ${action}`));
+                console.log(chalk_1.default.yellow('Available actions: list, create, validate'));
+        }
+    }
+    async handleCommandsList() {
+        const commands = this.commandManager.getAllCommands();
+        if (commands.length === 0) {
+            console.log(chalk_1.default.yellow('No custom commands available.'));
+            console.log(chalk_1.default.dim('Create commands with: /commands create'));
+            console.log(chalk_1.default.dim('Add commands to: ~/.mentis/commands/ or .mentis/commands/'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`\nCustom Commands (${commands.length}):\n`));
+        // Group by namespace
+        const grouped = new Map();
+        for (const cmd of commands) {
+            const ns = cmd.description.match(/\(([^)]+)\)/)?.[1] || cmd.type;
+            if (!grouped.has(ns)) {
+                grouped.set(ns, []);
+            }
+            grouped.get(ns).push(cmd);
+        }
+        for (const [namespace, cmds] of grouped) {
+            console.log(chalk_1.default.bold(`\n${namespace}`));
+            for (const cmd of cmds) {
+                const params = cmd.frontmatter['argument-hint'] ? ` ${cmd.frontmatter['argument-hint']}` : '';
+                console.log(`  /${cmd.name}${params}`);
+                console.log(`    ${cmd.description.replace(/\s*\([^)]+\)/, '')}`);
+                if (cmd.frontmatter['allowed-tools'] && cmd.frontmatter['allowed-tools'].length > 0) {
+                    console.log(chalk_1.default.dim(`    Allowed tools: ${cmd.frontmatter['allowed-tools'].join(', ')}`));
+                }
+            }
+        }
+        console.log('');
+    }
+    async handleCommandsCreate(name) {
+        const { CommandCreator } = await Promise.resolve().then(() => __importStar(require('../commands/CommandCreator')));
+        const creator = new CommandCreator(this.commandManager);
+        await creator.run(name);
+        // Re-discover commands after creation
+        await this.commandManager.discoverCommands();
+    }
+    async handleCommandsValidate() {
+        const { validateCommands } = await Promise.resolve().then(() => __importStar(require('../commands/CommandCreator')));
+        await validateCommands(this.commandManager);
+    }
     estimateCost(input, output) {
         const config = this.configManager.getConfig();
         const provider = config.defaultProvider;

package/dist/skills/LoadSkillTool.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * LoadSkillTool - Tool for model-invoked skill loading
+ * The model can call this tool when it determines a skill is relevant to the current task
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadSkillFileTool = exports.ListSkillsTool = exports.LoadSkillTool = void 0;
+class LoadSkillTool {
+    constructor(skillsManager, onSkillLoaded) {
+        this.name = 'load_skill';
+        this.description = 'Load the full content of a skill by name. Use this when you need detailed instructions from a skill. Available skills can be seen in the system prompt. Example: load_skill({ name: "commit-helper" })';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'The name of the skill to load (e.g., "commit-helper", "pdf-processing")'
+                }
+            },
+            required: ['name']
+        };
+        this.skillsManager = skillsManager;
+        this.onSkillLoaded = onSkillLoaded;
+    }
+    async execute(args) {
+        const { name } = args;
+        if (!name) {
+            return 'Error: Skill name is required';
+        }
+        const skill = this.skillsManager.getSkill(name);
+        if (!skill) {
+            const availableSkills = this.skillsManager.getAllSkills().map(s => s.name).join(', ');
+            return `Error: Skill "${name}" not found. Available skills: ${availableSkills || 'none'}`;
+        }
+        // Load full skill content
+        const fullSkill = await this.skillsManager.loadFullSkill(name);
+        if (!fullSkill || !fullSkill.content) {
+            return `Error: Failed to load content for skill "${name}"`;
+        }
+        // Notify callback that skill was loaded
+        if (this.onSkillLoaded) {
+            this.onSkillLoaded(fullSkill);
+        }
+        // Format response with skill content
+        let response = `# Loaded Skill: ${skill.name}\n\n`;
+        response += `**Type**: ${skill.type}\n`;
+        response += `**Description**: ${skill.description}\n`;
+        if (skill.allowedTools && skill.allowedTools.length > 0) {
+            response += `**Allowed Tools**: ${skill.allowedTools.join(', ')}\n`;
+        }
+        response += `\n---\n\n`;
+        response += fullSkill.content;
+        return response;
+    }
+}
+exports.LoadSkillTool = LoadSkillTool;
+/**
+ * ListSkillsTool - Tool for listing available skills
+ */
+class ListSkillsTool {
+    constructor(skillsManager) {
+        this.name = 'list_skills';
+        this.description = 'List all available skills with their descriptions. Use this to see what skills are available.';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+        this.skillsManager = skillsManager;
+    }
+    async execute() {
+        const skills = this.skillsManager.getAllSkills();
+        if (skills.length === 0) {
+            return 'No skills available. Add skills to ~/.mentis/skills/ or .mentis/skills/';
+        }
+        let response = `# Available Skills (${skills.length})\n\n`;
+        for (const skill of skills) {
+            const statusIcon = skill.isValid ? '✓' : '✗';
+            response += `**${statusIcon} ${skill.name}** (${skill.type})\n`;
+            response += `  ${skill.description}\n`;
+            if (skill.allowedTools && skill.allowedTools.length > 0) {
+                response += `  Allowed tools: ${skill.allowedTools.join(', ')}\n`;
+            }
+            if (!skill.isValid && skill.errors) {
+                response += `  Errors: ${skill.errors.join(', ')}\n`;
+            }
+            response += '\n';
+        }
+        return response;
+    }
+}
+exports.ListSkillsTool = ListSkillsTool;
+/**
+ * ReadSkillFileTool - Tool for reading supporting files within a skill
+ * Used for progressive disclosure of skill resources
+ */
+class ReadSkillFileTool {
+    constructor(skillsManager) {
+        this.name = 'read_skill_file';
+        this.description = 'Read a supporting file from within a skill directory. Use this when a skill references additional files like [reference.md](reference.md). Example: read_skill_file({ skill: "pdf-processing", file: "reference.md" })';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                skill: {
+                    type: 'string',
+                    description: 'The name of the skill'
+                },
+                file: {
+                    type: 'string',
+                    description: 'The filename within the skill directory (e.g., "reference.md", "examples.md")'
+                }
+            },
+            required: ['skill', 'file']
+        };
+        this.skillsManager = skillsManager;
+    }
+    async execute(args) {
+        const { skill, file } = args;
+        if (!skill || !file) {
+            return 'Error: Both skill and file parameters are required';
+        }
+        const content = this.skillsManager.readSkillFile(skill, file);
+        if (content === null) {
+            const availableFiles = this.skillsManager.listSkillFiles(skill);
+            if (availableFiles.length === 0) {
+                return `Error: Skill "${skill}" has no supporting files`;
+            }
+            return `Error: File "${file}" not found in skill "${skill}". Available files: ${availableFiles.join(', ')}`;
+        }
+        return content;
+    }
+}
+exports.ReadSkillFileTool = ReadSkillFileTool;

package/dist/skills/Skill.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Skill data structure for Agent Skills system
+ * Based on Claude Code's Agent Skills format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });