@indiccoder/mentis-cli 1.0.5 → 1.0.9

package/src/repl/ReplManager.ts

@@ -17,6 +17,8 @@ import { Tool } from '../tools/Tool';
 import { McpClient } from '../mcp/McpClient';
 
 import { CheckpointManager } from '../checkpoint/CheckpointManager';
+import { SkillsManager } from '../skills/SkillsManager';
+import { LoadSkillTool, ListSkillsTool, ReadSkillFileTool } from '../skills/LoadSkillTool';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -31,18 +33,23 @@ export class ReplManager {
     private modelClient!: ModelClient;
     private contextManager: ContextManager;
     private checkpointManager: CheckpointManager;
+    private skillsManager: SkillsManager;
     private history: ChatMessage[] = [];
     private mode: 'PLAN' | 'BUILD' = 'BUILD';
     private tools: Tool[] = [];
     private mcpClients: McpClient[] = [];
     private shell: PersistentShell;
     private currentModelName: string = 'Unknown';
+    private activeSkill: string | null = null;  // Track currently active skill for allowed-tools
 
     constructor() {
         this.configManager = new ConfigManager();
         this.contextManager = new ContextManager();
         this.checkpointManager = new CheckpointManager();
+        this.skillsManager = new SkillsManager();
         this.shell = new PersistentShell();
+
+        // Create tools array without skill tools first
         this.tools = [
             new WriteFileTool(),
             new ReadFileTool(),
@@ -64,6 +71,67 @@ export 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
+     */
+    private 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(this.skillsManager, (skill) => {
+                this.activeSkill = skill ? skill.name : null;
+            }),
+            new ListSkillsTool(this.skillsManager),
+            new 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
+     */
+    private isToolAllowedBySkill(toolName: string): boolean {
+        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: Record<string, string> = {
+            '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);
     }
 
     private initializeClient() {
@@ -99,29 +167,28 @@ export class ReplManager {
     }
 
     public async start() {
-        UIManager.displayLogo();
-        UIManager.displayWelcome();
+        UIManager.renderDashboard({
+            model: this.currentModelName,
+            mode: this.mode,
+            cwd: process.cwd()
+        });
 
         // Load History
         let commandHistory: string[] = [];
         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.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.
+            // Minimalist Separator
+            console.log(chalk.gray('────────────────────────────────────────────────────────────────────────────────'));
+
+            // Hint (Claude style puts it below, we put it above for standard terminal compatibility)
+            console.log(chalk.dim('  ? for shortcuts'));
 
-            const modeLabel = this.mode === 'PLAN' ? chalk.magenta('PLAN') : chalk.blue('BUILD');
-            const modelInfo = this.currentModelName ? ` (${this.currentModelName})` : '';
-            const promptText = `${modeLabel}${chalk.dim(modelInfo)} ${chalk.cyan('>')}`;
+            const promptText = `> `;  // Clean prompt
 
             // Use readline for basic input to support history
             const answer = await new Promise<string>((resolve) => {
@@ -130,7 +197,7 @@ export class ReplManager {
                     output: process.stdout,
                     history: commandHistory,
                     historySize: 1000,
-                    prompt: promptText + ' '
+                    prompt: promptText
                 });
 
                 rl.prompt();
@@ -179,16 +246,16 @@ export 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');
@@ -258,6 +325,14 @@ export class ReplManager {
                 console.log(chalk.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.red(`Unknown command: ${command}`));
         }
@@ -265,6 +340,7 @@ export class ReplManager {
 
     private async handleChat(input: string) {
         const context = this.contextManager.getContextString();
+        const skillsContext = this.skillsManager.getSkillsContext();
         let fullInput = input;
 
         let modeInstruction = '';
@@ -276,6 +352,11 @@ export class ReplManager {
 
         fullInput = `${input}${modeInstruction}`;
 
+        // Add skills context if available
+        if (skillsContext) {
+            fullInput = `${skillsContext}\n\n${fullInput}`;
+        }
+
         if (context) {
             fullInput = `${context}\n\nUser Question: ${fullInput}`;
         }
@@ -338,7 +419,8 @@ export class ReplManager {
                     console.log(chalk.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);
@@ -858,6 +940,100 @@ export class ReplManager {
         }
     }
 
+    private async handleSkillsCommand(args: string[]) {
+        const { SkillCreator, validateSkills } = await import('../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.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.red(`Unknown skills action: ${action}`));
+                console.log(chalk.yellow('Available actions: list, show, create, validate'));
+        }
+    }
+
+    private async handleSkillsList(): Promise<void> {
+        const skills = this.skillsManager.getAllSkills();
+
+        if (skills.length === 0) {
+            console.log(chalk.yellow('No skills available.'));
+            console.log(chalk.dim('Create skills with: /skills create'));
+            console.log(chalk.dim('Add skills to: ~/.mentis/skills/ or .mentis/skills/'));
+            return;
+        }
+
+        console.log(chalk.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.bold(skill.name)} (${typeLabel})`);
+            console.log(`  ${skill.description}`);
+
+            if (skill.allowedTools && skill.allowedTools.length > 0) {
+                console.log(chalk.dim(`  Allowed tools: ${skill.allowedTools.join(', ')}`));
+            }
+
+            if (!skill.isValid && skill.errors) {
+                console.log(chalk.red(`  Errors: ${skill.errors.join(', ')}`));
+            }
+
+            console.log('');
+        }
+    }
+
+    private async handleSkillsShow(name: string): Promise<void> {
+        const skill = await this.skillsManager.loadFullSkill(name);
+
+        if (!skill) {
+            console.log(chalk.red(`Skill "${name}" not found.`));
+            return;
+        }
+
+        console.log(chalk.cyan(`\n# ${skill.name}\n`));
+        console.log(chalk.dim(`Type: ${skill.type}`));
+        console.log(chalk.dim(`Path: ${skill.path}`));
+
+        if (skill.allowedTools && skill.allowedTools.length > 0) {
+            console.log(chalk.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.dim(`\nSupporting files: ${files.join(', ')}`));
+        }
+    }
+
     private estimateCost(input: number, output: number): number {
         const config = this.configManager.getConfig();
         const provider = config.defaultProvider;

package/src/skills/LoadSkillTool.ts

@@ -0,0 +1,168 @@
+/**
+ * LoadSkillTool - Tool for model-invoked skill loading
+ * The model can call this tool when it determines a skill is relevant to the current task
+ */
+
+import { Tool } from '../tools/Tool';
+import { SkillsManager, Skill } from './SkillsManager';
+
+interface LoadSkillArgs {
+    name: string;
+}
+
+type SkillLoadedCallback = (skill: Skill | null) => void;
+
+export class LoadSkillTool implements Tool {
+    name = 'load_skill';
+    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" })';
+    parameters = {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'The name of the skill to load (e.g., "commit-helper", "pdf-processing")'
+            }
+        },
+        required: ['name']
+    };
+
+    private skillsManager: SkillsManager;
+    private onSkillLoaded?: SkillLoadedCallback;
+
+    constructor(skillsManager: SkillsManager, onSkillLoaded?: SkillLoadedCallback) {
+        this.skillsManager = skillsManager;
+        this.onSkillLoaded = onSkillLoaded;
+    }
+
+    async execute(args: LoadSkillArgs): Promise<string> {
+        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;
+    }
+}
+
+/**
+ * ListSkillsTool - Tool for listing available skills
+ */
+export class ListSkillsTool implements Tool {
+    name = 'list_skills';
+    description = 'List all available skills with their descriptions. Use this to see what skills are available.';
+    parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    private skillsManager: SkillsManager;
+
+    constructor(skillsManager: SkillsManager) {
+        this.skillsManager = skillsManager;
+    }
+
+    async execute(): Promise<string> {
+        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;
+    }
+}
+
+/**
+ * ReadSkillFileTool - Tool for reading supporting files within a skill
+ * Used for progressive disclosure of skill resources
+ */
+export class ReadSkillFileTool implements Tool {
+    name = 'read_skill_file';
+    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" })';
+    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']
+    };
+
+    private skillsManager: SkillsManager;
+
+    constructor(skillsManager: SkillsManager) {
+        this.skillsManager = skillsManager;
+    }
+
+    async execute(args: { skill: string; file: string }): Promise<string> {
+        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;
+    }
+}

package/src/skills/Skill.ts

@@ -0,0 +1,51 @@
+/**
+ * Skill data structure for Agent Skills system
+ * Based on Claude Code's Agent Skills format
+ */
+
+export interface SkillMetadata {
+    name: string;           // Lowercase, numbers, hyphens only (max 64 chars)
+    description: string;    // What it does + when to use it (max 1024 chars)
+    allowedTools?: string[]; // Optional tool restrictions
+}
+
+export interface Skill extends SkillMetadata {
+    path: string;           // Path to SKILL.md
+    type: 'personal' | 'project' | 'plugin';
+    content?: string;       // Loaded on demand (progressive disclosure)
+    directory: string;      // Path to skill directory (for resolving supporting files)
+    isValid: boolean;       // Whether skill passes validation
+    errors?: string[];      // Validation errors if any
+}
+
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    'allowed-tools'?: string[];
+}
+
+/**
+ * Validation result for a skill
+ */
+export interface SkillValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+/**
+ * Skill context format for model injection
+ */
+export interface SkillContext {
+    name: string;
+    description: string;
+}
+
+/**
+ * Options for skill discovery
+ */
+export interface SkillDiscoveryOptions {
+    includePersonal?: boolean;
+    includeProject?: boolean;
+    includePlugin?: boolean;
+}