@indiccoder/mentis-cli 1.0.5 → 1.0.9

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

@@ -12,26 +12,64 @@ class UIManager {
     static displayLogo() {
         console.clear();
         const logoText = figlet_1.default.textSync('MENTIS', {
-            font: 'ANSI Shadow', // Use a block-like font
+            font: 'ANSI Shadow',
             horizontalLayout: 'default',
             verticalLayout: 'default',
             width: 100,
             whitespaceBreak: true,
         });
         console.log(gradient_string_1.default.pastel.multiline(logoText));
-        console.log(chalk_1.default.gray('  v1.0.0 - AI Coding Agent'));
+        console.log(chalk_1.default.gray('  v1.0.5 - AI Coding Agent'));
         console.log('');
     }
-    static displayWelcome() {
-        console.log((0, boxen_1.default)(`${chalk_1.default.bold('Welcome to Mentis-CLI')}\n\n` +
-            `• Type ${chalk_1.default.cyan('/help')} for commands.\n` +
-            `• Type ${chalk_1.default.cyan('/config')} to setup your model.\n` +
-            `• Start typing to chat with your agent.`, {
+    static renderDashboard(config) {
+        const { model, cwd } = config;
+        const version = 'v1.0.8';
+        // Layout: Left (Status/Welcome) | Right (Tips/Activity)
+        // Total width ~80 chars. 
+        // Left ~45, Right ~30.
+        const pad = (str, width) => str + ' '.repeat(Math.max(0, width - str.length));
+        const logo = gradient_string_1.default.pastel.multiline(figlet_1.default.textSync('MENTIS', { font: 'Small' }));
+        const logoLines = logo.split('\n');
+        // Tips Column
+        const tips = [
+            chalk_1.default.bold('Tips for getting started'),
+            chalk_1.default.dim('Run /init to scaffold project'),
+            chalk_1.default.dim('Run /model to switch AI'),
+            chalk_1.default.dim('Run /help for full list')
+        ];
+        // Combine Logo (Left) and Tips (Right)
+        let body = '';
+        for (let i = 0; i < Math.max(logoLines.length, tips.length); i++) {
+            const left = logoLines[i] || ''; // Logo line
+            const right = tips[i] || ''; // Tip line
+            // Need to strip ansi to calc padding? simple padding might break with ansi.
+            // Let's just create two distinct blocks and join them?
+            // Complex with boxen.
+            // Let's stick to vertical stack if side-by-side matches ansi poorly.
+            // Actually, let's just use the previous cleaner vertical stack but wider.
+            // User liked the previous one "this is exellent", just wanted input box.
+            // So I will keep the Dashboard mostly same, maybe just widen it.
+        }
+        // Re-using the clean layout but ensuring no "undefined" or weird overlaps
+        const title = ` Mentis-CLI ${version} `;
+        const content = ` ${chalk_1.default.bold('Welcome back!')}\n\n` +
+            `${logo}\n\n` +
+            ` ${chalk_1.default.dim('Model:')} ${chalk_1.default.cyan(model)}\n` +
+            ` ${chalk_1.default.dim('Dir:')}   ${chalk_1.default.dim(cwd)}\n\n` +
+            `${chalk_1.default.gray('────────────────────────────────────────────────────────────────')}\n` +
+            ` ${chalk_1.default.dim('Tips: /help • /config • /mcp • Esc to cancel')}`;
+        console.log((0, boxen_1.default)(content, {
             padding: 1,
-            margin: 1,
+            margin: 0,
             borderStyle: 'round',
             borderColor: 'cyan',
+            title: title,
+            titleAlignment: 'left',
+            dimBorder: true,
+            width: 80
         }));
+        console.log('');
     }
     static printSeparator() {
         console.log(chalk_1.default.gray('──────────────────────────────────────────────────'));

package/dist/utils/UpdateManager.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class UpdateManager {
+    constructor() {
+        const packageJsonPath = path_1.default.join(__dirname, '../../package.json');
+        try {
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            this.packageName = packageJson.name;
+            this.currentVersion = packageJson.version;
+        }
+        catch (e) {
+            // Fallback if running from a context where package.json isn't found easily (e.g. global install oddities)
+            // But usually this works relative to dist/utils/
+            this.packageName = '@indiccoder/mentis-cli';
+            this.currentVersion = '0.0.0';
+        }
+    }
+    async checkAndPerformUpdate(interactive = true) {
+        const spinner = (0, ora_1.default)('Checking for updates...').start();
+        try {
+            // Check latest version from NPM registry
+            const { stdout } = await execAsync(`npm view ${this.packageName} version`);
+            const latestVersion = stdout.trim();
+            if (latestVersion === this.currentVersion) {
+                spinner.succeed(chalk_1.default.green(`You are on the latest version (${this.currentVersion}).`));
+                return;
+            }
+            spinner.info(chalk_1.default.blue(`Update available: ${this.currentVersion} -> ${chalk_1.default.bold(latestVersion)}`));
+            if (!interactive) {
+                // If running in non-interactive mode (e.g. auto-check prompt), maybe just log it.
+                // But for explicit 'update' command, we usually assume interactive or force.
+                console.log(chalk_1.default.yellow(`Run 'mentis update' or '/update' inside the tool to upgrade.`));
+                return;
+            }
+            const { confirm } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Do you want to install v${latestVersion} now?`,
+                    default: true
+                }]);
+            if (confirm) {
+                await this.installUpdate(latestVersion);
+            }
+            else {
+                console.log(chalk_1.default.yellow('Update skipped.'));
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Failed to check for updates.'));
+            if (process.env.DEBUG)
+                console.error(error);
+        }
+    }
+    async installUpdate(version) {
+        const spinner = (0, ora_1.default)(`Installing ${this.packageName}@${version}...`).start();
+        try {
+            await execAsync(`npm install -g ${this.packageName}@latest`);
+            spinner.succeed(chalk_1.default.green('Update completed successfully!'));
+            console.log(chalk_1.default.cyan('Please restart Mentis to use the new version.'));
+            process.exit(0);
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red('Update failed.'));
+            console.error(chalk_1.default.red('Error details:'), error.message);
+            console.log(chalk_1.default.yellow(`Try running: npm install -g ${this.packageName}@latest`));
+        }
+    }
+}
+exports.UpdateManager = UpdateManager;