@indiccoder/mentis-cli 1.0.5 → 1.0.9

package/dist/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ReplManager_1 = require("./repl/ReplManager");
 async function main() {
+    if (process.argv.includes('update')) {
+        const { UpdateManager } = require('./utils/UpdateManager');
+        const updater = new UpdateManager();
+        await updater.checkAndPerformUpdate(true);
+        return;
+    }
     const repl = new ReplManager_1.ReplManager();
     await repl.start();
 }

package/dist/repl/ReplManager.js

@@ -52,6 +52,8 @@ 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 readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -66,10 +68,13 @@ 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.shell = new PersistentShell_1.PersistentShell();
+        // Create tools array without skill tools first
         this.tools = [
             new FileTools_1.WriteFileTool(),
             new FileTools_1.ReadFileTool(),
@@ -90,6 +95,56 @@ 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 system
+     */
+    async initializeSkills() {
+        this.skillsManager.ensureDirectoriesExist();
+        await this.skillsManager.discoverSkills();
+        // 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));
+    }
+    /**
+     * 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'
+        };
+        const mappedToolName = toolMapping[toolName] || toolName;
+        return skill.allowedTools.includes(mappedToolName);
     }
     initializeClient() {
         const config = this.configManager.getConfig();
@@ -123,27 +178,25 @@ class ReplManager {
         // console.log(chalk.dim(`Initialized ${provider} client with model ${model}`));
     }
     async start() {
-        UIManager_1.UIManager.displayLogo();
-        UIManager_1.UIManager.displayWelcome();
+        UIManager_1.UIManager.renderDashboard({
+            model: this.currentModelName,
+            mode: this.mode,
+            cwd: process.cwd()
+        });
         // Load History
         let commandHistory = [];
         if (fs.existsSync(HISTORY_FILE)) {
             try {
-                commandHistory = fs.readFileSync(HISTORY_FILE, 'utf-8').split('\n').filter(Boolean).reverse(); // readline expects newest first? No, newest is usually 0? Check.
-                // readline.history is [newest, ..., oldest]
-                // If I read from file where newest is at bottom (standard append), I need to reverse it.
-                // Let's assume standard file: line 1 (old), line 2 (new).
-                // So split -> reverse -> history.
+                commandHistory = fs.readFileSync(HISTORY_FILE, 'utf-8').split('\n').filter(Boolean).reverse();
             }
             catch (e) { }
         }
         while (true) {
-            UIManager_1.UIManager.printSeparator();
-            // console.log(chalk.dim(`  /help for help | Model: ${chalk.cyan(this.currentModelName)}`));
-            // Removed redundancy to keep CLI clean, prompt has info? No, prompt is minimal.
-            const modeLabel = this.mode === 'PLAN' ? chalk_1.default.magenta('PLAN') : chalk_1.default.blue('BUILD');
-            const modelInfo = this.currentModelName ? ` (${this.currentModelName})` : '';
-            const promptText = `${modeLabel}${chalk_1.default.dim(modelInfo)} ${chalk_1.default.cyan('>')}`;
+            // Minimalist Separator
+            console.log(chalk_1.default.gray('────────────────────────────────────────────────────────────────────────────────'));
+            // Hint (Claude style puts it below, we put it above for standard terminal compatibility)
+            console.log(chalk_1.default.dim('  ? for shortcuts'));
+            const promptText = `> `; // Clean prompt
             // Use readline for basic input to support history
             const answer = await new Promise((resolve) => {
                 const rl = readline.createInterface({
@@ -151,7 +204,7 @@ class ReplManager {
                     output: process.stdout,
                     history: commandHistory,
                     historySize: 1000,
-                    prompt: promptText + ' '
+                    prompt: promptText
                 });
                 rl.prompt();
                 rl.on('line', (line) => {
@@ -193,16 +246,16 @@ class ReplManager {
                 console.log('  /help    - Show this help message');
                 console.log('  /clear   - Clear chat history');
                 console.log('  /exit    - Exit the application');
+                console.log('  /update  - Check for and install updates');
                 console.log('  /config  - Configure settings');
                 console.log('  /add <file> - Add file to context');
                 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('  /resume  - Resume last session');
                 console.log('  /checkpoint <save|load|list> [name] - Manage checkpoints');
                 console.log('  /search <query> - Search codebase');
@@ -274,12 +327,21 @@ class ReplManager {
                 console.log(chalk_1.default.green('Session saved. Goodbye!'));
                 process.exit(0);
                 break;
+            case '/update':
+                const UpdateManager = require('../utils/UpdateManager').UpdateManager;
+                const updater = new UpdateManager();
+                await updater.checkAndPerformUpdate(true);
+                break;
+            case '/skills':
+                await this.handleSkillsCommand(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();
         let fullInput = input;
         let modeInstruction = '';
         if (this.mode === 'PLAN') {
@@ -289,6 +351,10 @@ 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}`;
+        }
         if (context) {
             fullInput = `${context}\n\nUser Question: ${fullInput}`;
         }
@@ -341,7 +407,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);
@@ -823,6 +890,82 @@ 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(', ')}`));
+        }
+    }
     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 });

package/dist/skills/SkillCreator.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * SkillCreator - Interactive wizard for creating new skills
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillCreator = void 0;
+exports.validateSkills = validateSkills;
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const SkillsManager_1 = require("./SkillsManager");
+class SkillCreator {
+    constructor(skillsManager) {
+        this.skillsManager = skillsManager || new SkillsManager_1.SkillsManager();
+    }
+    /**
+     * Run the interactive skill creation wizard
+     */
+    async run(name) {
+        console.log('\n📝 Create a new Skill\n');
+        let skillName;
+        let skillType;
+        let description;
+        let allowedTools;
+        // Step 1: Skill Name
+        if (name) {
+            skillName = name;
+        }
+        else {
+            const { name: inputName } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Skill name (lowercase, numbers, hyphens only):',
+                    validate: (input) => {
+                        if (!input)
+                            return 'Name is required';
+                        if (!/^[a-z0-9-]+$/.test(input)) {
+                            return 'Name must contain only lowercase letters, numbers, and hyphens';
+                        }
+                        if (input.length > 64)
+                            return 'Name must be 64 characters or less';
+                        return true;
+                    }
+                }
+            ]);
+            skillName = inputName;
+        }
+        // Step 2: Skill Type
+        const { type } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Skill type:',
+                choices: [
+                    { name: 'Personal (available in all projects)', value: 'personal' },
+                    { name: 'Project (shared with team via git)', value: 'project' }
+                ],
+                default: 'personal'
+            }
+        ]);
+        skillType = type;
+        // Step 3: Description
+        const { desc } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'desc',
+                message: 'Description (what it does + when to use it):',
+                validate: (input) => {
+                    if (!input)
+                        return 'Description is required';
+                    if (input.length > 1024)
+                        return 'Description must be 1024 characters or less';
+                    if (!input.toLowerCase().includes('use when') && !input.toLowerCase().includes('use for')) {
+                        return 'Tip: Include when to use this skill (e.g., "Use when...")';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        description = desc;
+        // Step 4: Allowed Tools (optional)
+        const { useAllowedTools } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useAllowedTools',
+                message: 'Restrict which tools this skill can use?',
+                default: false
+            }
+        ]);
+        if (useAllowedTools) {
+            const { tools } = await inquirer_1.default.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'tools',
+                    message: 'Select allowed tools:',
+                    choices: [
+                        { name: 'Read (read_file)', value: 'Read' },
+                        { name: 'Write (write_file)', value: 'Write' },
+                        { name: 'Edit (edit_file)', value: 'Edit' },
+                        { name: 'Grep (search files)', value: 'Grep' },
+                        { name: 'Glob (find files)', value: 'Glob' },
+                        { name: 'ListDir (list directory)', value: 'ListDir' },
+                        { name: 'SearchFile (search in files)', value: 'SearchFile' },
+                        { name: 'RunShell (run shell command)', value: 'RunShell' },
+                        { name: 'WebSearch (web search)', value: 'WebSearch' },
+                        { name: 'GitStatus', value: 'GitStatus' },
+                        { name: 'GitDiff', value: 'GitDiff' },
+                        { name: 'GitCommit', value: 'GitCommit' },
+                        { name: 'GitPush', value: 'GitPush' },
+                        { name: 'GitPull', value: 'GitPull' }
+                    ]
+                }
+            ]);
+            allowedTools = tools.length > 0 ? tools : undefined;
+        }
+        // Step 5: Create the skill
+        return this.createSkill(skillName, skillType, description, allowedTools);
+    }
+    /**
+     * Create the skill file and directory
+     */
+    async createSkill(name, type, description, allowedTools) {
+        const baseDir = type === 'personal'
+            ? path.join(os.homedir(), '.mentis', 'skills')
+            : path.join(process.cwd(), '.mentis', 'skills');
+        const skillDir = path.join(baseDir, name);
+        const skillFile = path.join(skillDir, 'SKILL.md');
+        // Check if skill already exists
+        if (fs.existsSync(skillFile)) {
+            const { overwrite } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Skill "${name}" already exists. Overwrite?`,
+                    default: false
+                }
+            ]);
+            if (!overwrite) {
+                console.log('Cancelled.');
+                return false;
+            }
+        }
+        // Create directory
+        if (!fs.existsSync(skillDir)) {
+            fs.mkdirSync(skillDir, { recursive: true });
+        }
+        // Generate SKILL.md content
+        let content = `---\nname: ${name}\ndescription: ${description}\n`;
+        if (allowedTools && allowedTools.length > 0) {
+            content += `allowed-tools: [${allowedTools.map(t => `"${t}"`).join(', ')}]\n`;
+        }
+        content += `---\n\n# ${this.formatTitle(name)}\n\n`;
+        content += `## Overview\n\n`;
+        content += `This skill provides...\n\n`;
+        content += `## Instructions\n\n`;
+        content += `### Step 1: ...\n\n`;
+        content += `### Step 2: ...\n\n`;
+        content += `## Examples\n\n`;
+        content += `\`\`\`\n`;
+        content += `// Example usage\n`;
+        content += `\`\`\`\n`;
+        // Write SKILL.md
+        fs.writeFileSync(skillFile, content, 'utf-8');
+        console.log(`\n✓ Skill created at: ${skillFile}`);
+        console.log(`\nNext steps:`);
+        console.log(`  1. Edit ${skillFile} to add instructions`);
+        console.log(`  2. Add supporting files (reference.md, examples.md, scripts/) as needed`);
+        console.log(`  3. Restart Mentis to load the new skill`);
+        return true;
+    }
+    /**
+     * Format skill name to title case
+     */
+    formatTitle(name) {
+        return name
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+}
+exports.SkillCreator = SkillCreator;
+/**
+ * Validate skills and show results
+ */
+async function validateSkills(skillsManager) {
+    const results = skillsManager.validateAllSkills();
+    console.log('\n📋 Skill Validation Results\n');
+    let hasErrors = false;
+    let hasWarnings = false;
+    for (const [name, result] of results) {
+        if (result.isValid) {
+            console.log(`✓ ${name}`);
+        }
+        else {
+            console.log(`✗ ${name}`);
+            hasErrors = true;
+        }
+        if (result.errors.length > 0) {
+            result.errors.forEach(err => console.log(`  ERROR: ${err}`));
+        }
+        if (result.warnings.length > 0) {
+            hasWarnings = true;
+            result.warnings.forEach(warn => console.log(`  WARNING: ${warn}`));
+        }
+    }
+    if (!hasErrors && !hasWarnings) {
+        console.log('\n✓ All skills are valid!');
+    }
+}