@indiccoder/mentis-cli 1.0.8 → 1.1.0

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!');
+    }
+}

package/dist/skills/SkillsManager.js

@@ -0,0 +1,337 @@
+"use strict";
+/**
+ * SkillsManager - Core module for Agent Skills system
+ * Handles discovery, loading, and validation of 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.SkillsManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fast_glob_1 = require("fast-glob");
+const yaml_1 = __importDefault(require("yaml"));
+class SkillsManager {
+    constructor(cwd = process.cwd()) {
+        this.skills = new Map();
+        this.personalSkillsDir = path.join(os.homedir(), '.mentis', 'skills');
+        this.projectSkillsDir = path.join(cwd, '.mentis', 'skills');
+    }
+    /**
+     * Discover all skills from configured directories
+     */
+    async discoverSkills(options = {}) {
+        const { includePersonal = true, includeProject = true, includePlugin = false // Plugin skills not implemented yet
+         } = options;
+        const discovered = [];
+        if (includePersonal) {
+            discovered.push(...await this.discoverSkillsInDirectory(this.personalSkillsDir, 'personal'));
+        }
+        if (includeProject) {
+            discovered.push(...await this.discoverSkillsInDirectory(this.projectSkillsDir, 'project'));
+        }
+        // Store skills in map for quick lookup
+        for (const skill of discovered) {
+            this.skills.set(skill.name, skill);
+        }
+        return Array.from(this.skills.values());
+    }
+    /**
+     * Discover skills in a specific directory
+     */
+    async discoverSkillsInDirectory(dir, type) {
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        const skills = [];
+        try {
+            // Find all SKILL.md files in subdirectories
+            const skillFiles = await (0, fast_glob_1.glob)('**/SKILL.md', {
+                cwd: dir,
+                absolute: true,
+                onlyFiles: true
+            });
+            for (const skillFile of skillFiles) {
+                const skillDir = path.dirname(skillFile);
+                const skillName = path.basename(skillDir);
+                const skill = await this.loadSkillMetadata(skillFile, skillDir, type);
+                if (skill) {
+                    skills.push(skill);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error discovering skills in ${dir}: ${error.message}`);
+        }
+        return skills;
+    }
+    /**
+     * Load only the metadata (YAML frontmatter) from a SKILL.md file
+     * This is used for progressive disclosure - only name/description loaded at startup
+     */
+    async loadSkillMetadata(skillPath, skillDir, type) {
+        try {
+            const content = fs.readFileSync(skillPath, 'utf-8');
+            const frontmatter = this.extractFrontmatter(content);
+            if (!frontmatter) {
+                return null;
+            }
+            // Convert SkillFrontmatter to SkillMetadata for validation
+            const metadata = {
+                name: frontmatter.name,
+                description: frontmatter.description,
+                allowedTools: frontmatter['allowed-tools']
+            };
+            const validation = this.validateSkillMetadata(metadata);
+            const skill = {
+                name: frontmatter.name,
+                description: frontmatter.description,
+                allowedTools: frontmatter['allowed-tools'],
+                path: skillPath,
+                directory: skillDir,
+                type,
+                isValid: validation.isValid,
+                errors: validation.errors.length > 0 ? validation.errors : undefined
+            };
+            return skill;
+        }
+        catch (error) {
+            console.error(`Error loading skill metadata from ${skillPath}: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Load the full content of a skill (for progressive disclosure)
+     */
+    async loadFullSkill(name) {
+        const skill = this.skills.get(name);
+        if (!skill) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(skill.path, 'utf-8');
+            skill.content = content;
+            return skill;
+        }
+        catch (error) {
+            console.error(`Error loading full skill ${name}: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Extract YAML frontmatter from markdown content
+     */
+    extractFrontmatter(content) {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
+        const match = content.match(frontmatterRegex);
+        if (!match) {
+            return null;
+        }
+        try {
+            const parsed = yaml_1.default.parse(match[1]);
+            return parsed;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Validate skill metadata according to Claude Code spec
+     */
+    validateSkillMetadata(metadata) {
+        const errors = [];
+        const warnings = [];
+        // Check required fields
+        if (!metadata.name) {
+            errors.push('Missing required field: name');
+        }
+        else {
+            // Name validation: lowercase letters, numbers, hyphens only, max 64 chars
+            const nameRegex = /^[a-z0-9-]+$/;
+            if (!nameRegex.test(metadata.name)) {
+                errors.push('Name must contain only lowercase letters, numbers, and hyphens');
+            }
+            if (metadata.name.length > 64) {
+                errors.push('Name must be 64 characters or less');
+            }
+        }
+        if (!metadata.description) {
+            errors.push('Missing required field: description');
+        }
+        else {
+            if (metadata.description.length > 1024) {
+                errors.push('Description must be 1024 characters or less');
+            }
+            // Check if description mentions when to use
+            if (!metadata.description.toLowerCase().includes('use when') &&
+                !metadata.description.toLowerCase().includes('use for')) {
+                warnings.push('Description should include when to use this skill (e.g., "Use when...")');
+            }
+        }
+        // Validate allowed-tools if present
+        if (metadata.allowedTools) {
+            const validTools = [
+                'Read', 'Write', 'Edit', 'Grep', 'Glob', 'Bash', 'WebSearch',
+                'GitStatus', 'GitDiff', 'GitCommit', 'GitPush', 'GitPull',
+                'ListDir', 'SearchFile', 'RunShell'
+            ];
+            const invalidTools = metadata.allowedTools.filter(t => !validTools.includes(t));
+            if (invalidTools.length > 0) {
+                warnings.push(`Unknown tools in allowed-tools: ${invalidTools.join(', ')}`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+     * Get skill by name
+     */
+    getSkill(name) {
+        return this.skills.get(name);
+    }
+    /**
+     * Get all skills
+     */
+    getAllSkills() {
+        return Array.from(this.skills.values());
+    }
+    /**
+     * Get skills formatted for model context injection
+     * This provides only metadata for progressive disclosure
+     */
+    getSkillsContext() {
+        const skills = this.getAllSkills().filter(s => s.isValid);
+        if (skills.length === 0) {
+            return '';
+        }
+        const context = skills.map(skill => {
+            return `- ${skill.name}: ${skill.description}`;
+        }).join('\n');
+        return `Available Skills:\n${context}`;
+    }
+    /**
+     * Get skills as SkillContext array
+     */
+    getSkillsContextArray() {
+        return this.getAllSkills()
+            .filter(s => s.isValid)
+            .map(s => ({
+            name: s.name,
+            description: s.description
+        }));
+    }
+    /**
+     * Validate all loaded skills
+     */
+    validateAllSkills() {
+        const results = new Map();
+        for (const [name, skill] of this.skills) {
+            const metadata = {
+                name: skill.name,
+                description: skill.description,
+                allowedTools: skill.allowedTools
+            };
+            results.set(name, this.validateSkillMetadata(metadata));
+        }
+        return results;
+    }
+    /**
+     * Read a supporting file from a skill directory
+     * Used for progressive disclosure of skill resources
+     */
+    readSkillFile(skillName, fileName) {
+        const skill = this.skills.get(skillName);
+        if (!skill) {
+            return null;
+        }
+        const filePath = path.join(skill.directory, fileName);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * List supporting files in a skill directory
+     */
+    listSkillFiles(skillName) {
+        const skill = this.skills.get(skillName);
+        if (!skill) {
+            return [];
+        }
+        if (!fs.existsSync(skill.directory)) {
+            return [];
+        }
+        try {
+            const files = fs.readdirSync(skill.directory);
+            // Exclude SKILL.md as it's the main file
+            return files.filter(f => f !== 'SKILL.md');
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    /**
+     * Create skills directories if they don't exist
+     */
+    ensureDirectoriesExist() {
+        if (!fs.existsSync(this.personalSkillsDir)) {
+            fs.mkdirSync(this.personalSkillsDir, { recursive: true });
+        }
+    }
+    /**
+     * Get personal skills directory path
+     */
+    getPersonalSkillsDir() {
+        return this.personalSkillsDir;
+    }
+    /**
+     * Get project skills directory path
+     */
+    getProjectSkillsDir() {
+        return this.projectSkillsDir;
+    }
+}
+exports.SkillsManager = SkillsManager;

package/dist/ui/UIManager.js

@@ -19,12 +19,12 @@ class UIManager {
             whitespaceBreak: true,
         });
         console.log(gradient_string_1.default.pastel.multiline(logoText));
-        console.log(chalk_1.default.gray('  v1.0.5 - AI Coding Agent'));
+        console.log(chalk_1.default.gray('  v1.1.0 - AI Coding Agent'));
         console.log('');
     }
     static renderDashboard(config) {
         const { model, cwd } = config;
-        const version = 'v1.0.8';
+        const version = 'v1.1.0';
         // Layout: Left (Status/Welcome) | Right (Tips/Activity)
         // Total width ~80 chars. 
         // Left ~45, Right ~30.

package/dist/utils/ContextVisualizer.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * ContextVisualizer - Auto context bar display
+ * Shows token usage as a colored progress bar
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextVisualizer = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class ContextVisualizer {
+    constructor(maxTokens) {
+        this.maxTokens = 128000; // Default context window
+        if (maxTokens) {
+            this.maxTokens = maxTokens;
+        }
+    }
+    /**
+     * Calculate approximate token count from text
+     * Rough estimate: ~4 characters per token
+     */
+    estimateTokens(text) {
+        if (!text)
+            return 0;
+        // Rough estimation: ~4 characters per token for English text
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Calculate total tokens from message history
+     */
+    calculateUsage(history) {
+        let totalChars = 0;
+        for (const msg of history) {
+            if (msg.content) {
+                totalChars += msg.content.length;
+            }
+            if (msg.tool_calls) {
+                totalChars += JSON.stringify(msg.tool_calls).length;
+            }
+        }
+        // Add overhead for system prompt, skills, etc.
+        totalChars += 2000;
+        // Rough estimation: ~4 characters per token
+        const tokens = Math.ceil(totalChars / 4);
+        const percentage = Math.min(100, Math.round((tokens / this.maxTokens) * 100));
+        return { tokens, percentage, maxTokens: this.maxTokens };
+    }
+    /**
+     * Format the context bar for display
+     */
+    formatBar(usage) {
+        const { percentage, tokens, maxTokens } = usage;
+        // Create progress bar (20 chars wide)
+        const filled = Math.round(percentage / 5);
+        const empty = 20 - filled;
+        let bar;
+        if (percentage < 60) {
+            bar = chalk_1.default.green('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+        }
+        else if (percentage < 80) {
+            bar = chalk_1.default.yellow('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+        }
+        else {
+            bar = chalk_1.default.red('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+        }
+        const tokensK = Math.round(tokens / 1000);
+        const maxTokensK = Math.round(maxTokens / 1000);
+        return `${bar} ${percentage}% | ${tokensK}k/${maxTokensK} tokens`;
+    }
+    /**
+     * Get the context bar string for current history
+     */
+    getContextBar(history) {
+        const usage = this.calculateUsage(history);
+        return this.formatBar(usage);
+    }
+    /**
+     * Check if context is at warning threshold (>=80%)
+     */
+    shouldCompact(history) {
+        const usage = this.calculateUsage(history);
+        return usage.percentage >= 80;
+    }
+    /**
+     * Set custom max tokens (for different models)
+     */
+    setMaxTokens(max) {
+        this.maxTokens = max;
+    }
+}
+exports.ContextVisualizer = ContextVisualizer;