@indiccoder/mentis-cli 1.1.2 → 1.1.4

package/src/commands/CommandManager.ts

@@ -31,10 +31,18 @@ export class CommandManager {
         const discovered: Command[] = [];
 
         // Personal commands
-        discovered.push(...await this.discoverCommandsInDirectory(this.personalCommandsDir, 'personal'));
+        try {
+            discovered.push(...await this.discoverCommandsInDirectory(this.personalCommandsDir, 'personal'));
+        } catch (error: any) {
+            console.warn(`Warning: Failed to load personal commands from ${this.personalCommandsDir}: ${error.message}`);
+        }
 
         // Project commands
-        discovered.push(...await this.discoverCommandsInDirectory(this.projectCommandsDir, 'project'));
+        try {
+            discovered.push(...await this.discoverCommandsInDirectory(this.projectCommandsDir, 'project'));
+        } catch (error: any) {
+            console.warn(`Warning: Failed to load project commands from ${this.projectCommandsDir}: ${error.message}`);
+        }
 
         // Store commands in map (project commands override personal)
         for (const command of discovered) {
@@ -85,6 +93,7 @@ export class CommandManager {
             const commandName = this.getCommandName(commandPath, type);
 
             if (!commandName) {
+                console.warn(`Warning: Invalid command name in ${commandPath} (skipping)`);
                 return null;
             }
 
@@ -107,7 +116,13 @@ export class CommandManager {
 
             return command;
         } catch (error: any) {
-            console.error(`Error parsing command ${commandPath}: ${error.message}`);
+            if (error.code === 'ENOENT') {
+                console.warn(`Warning: Command file not found: ${commandPath}`);
+            } else if (error.code === 'EACCES') {
+                console.warn(`Warning: Permission denied reading command: ${commandPath}`);
+            } else {
+                console.error(`Error parsing command ${commandPath}: ${error.message}`);
+            }
             return null;
         }
     }
@@ -222,7 +237,10 @@ export class CommandManager {
         const bashRegex = /!`([^`]+)`/g;
         let bashMatch;
         while ((bashMatch = bashRegex.exec(content)) !== null) {
-            bashCommands.push(bashMatch[1]);
+            const bashCommand = bashMatch[1].trim();
+            if (bashCommand) {
+                bashCommands.push(bashCommand);
+            }
         }
 
         // Remove bash command markers
@@ -232,7 +250,10 @@ export class CommandManager {
         const fileRegex = /@([^\s]+)/g;
         let fileMatch;
         while ((fileMatch = fileRegex.exec(content)) !== null) {
-            fileReferences.push(fileMatch[1]);
+            const fileRef = fileMatch[1].trim();
+            if (fileRef && !fileReferences.includes(fileRef)) {
+                fileReferences.push(fileRef);
+            }
         }
 
         return { content, bashCommands, fileReferences };

package/src/commands/__tests__/CommandManager.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for CommandManager
+ */
+
+import { CommandManager } from '../CommandManager';
+import { Command } from '../Command';
+
+describe('CommandManager', () => {
+    let manager: CommandManager;
+
+    beforeEach(() => {
+        manager = new CommandManager();
+    });
+
+    describe('getAllCommands', () => {
+        it('should return empty array initially', () => {
+            const commands = manager.getAllCommands();
+            expect(commands).toEqual([]);
+        });
+    });
+
+    describe('getCommandsContext', () => {
+        it('should return empty string when no commands', () => {
+            const context = manager.getCommandsContext();
+            expect(context).toBe('');
+        });
+    });
+
+    describe('parseCommand', () => {
+        it('should replace $ARGUMENTS placeholder', async () => {
+            const command: Command = {
+                name: 'echo',
+                type: 'personal',
+                path: '/echo.md',
+                directory: '/commands',
+                description: 'Echo arguments',
+                frontmatter: {},
+                content: 'You said: $ARGUMENTS',
+                hasParameters: true
+            };
+
+            const parsed = await manager.parseCommand(command, ['hello', 'world']);
+
+            expect(parsed.content).toContain('hello world');
+        });
+
+        it('should replace $1, $2 placeholders', async () => {
+            const command: Command = {
+                name: 'greet',
+                type: 'personal',
+                path: '/greet.md',
+                directory: '/commands',
+                description: 'Greet user',
+                frontmatter: {},
+                content: 'Hello $1, welcome to $2',
+                hasParameters: true
+            };
+
+            const parsed = await manager.parseCommand(command, ['Alice', 'Wonderland']);
+
+            expect(parsed.content).toContain('Hello Alice');
+            expect(parsed.content).toContain('welcome to Wonderland');
+        });
+
+        it('should extract bash commands from content', async () => {
+            const command: Command = {
+                name: 'run-test',
+                type: 'personal',
+                path: '/run-test.md',
+                directory: '/commands',
+                description: 'Run tests',
+                frontmatter: {},
+                content: 'Run tests with !`npm test`',
+                hasParameters: false
+            };
+
+            const parsed = await manager.parseCommand(command, []);
+
+            expect(parsed.bashCommands).toHaveLength(1);
+            expect(parsed.bashCommands[0]).toBe('npm test');
+        });
+    });
+});

package/src/index.ts

@@ -1,13 +1,39 @@
 #!/usr/bin/env node
+
+/**
+ * Mentis CLI - An Agentic, Multi-Model CLI Coding Assistant
+ *
+ * @packageDocumentation
+ */
+
 import { ReplManager } from './repl/ReplManager';
 
+/**
+ * CLI options for controlling Mentis behavior
+ */
 interface CliOptions {
+    /** Resume from the last saved checkpoint */
     resume: boolean;
+    /** Auto-confirm all prompts (skip confirmations) */
     yolo: boolean;
+    /** Run in headless (non-interactive) mode */
     headless: boolean;
+    /** Prompt to execute in headless mode */
     headlessPrompt?: string;
 }
 
+/**
+ * Parse command line arguments
+ *
+ * @returns Parsed command and options
+ *
+ * @example
+ * ```bash
+ * mentis --resume
+ * mentis -p "fix the bug"
+ * mentis --yolo
+ * ```
+ */
 function parseArgs(): { command: string | null, options: CliOptions } {
     const args = process.argv.slice(2);
     const options: CliOptions = {
@@ -69,7 +95,12 @@ Commands (in REPL):
     return { command, options };
 }
 
-async function main() {
+/**
+ * Main entry point for Mentis CLI
+ *
+ * Parses arguments and starts the REPL or update manager
+ */
+async function main(): Promise<void> {
     const { command, options } = parseArgs();
 
     // Handle update command
@@ -85,6 +116,7 @@ async function main() {
     await repl.start();
 }
 
+// Start the application
 main().catch((error) => {
     console.error('Fatal error:', error);
     process.exit(1);

package/src/repl/ReplManager.ts

@@ -7,6 +7,7 @@ import { OpenAIClient } from '../llm/OpenAIClient';
 
 import { ContextManager } from '../context/ContextManager';
 import { UIManager } from '../ui/UIManager';
+import { InputBox } from '../ui/InputBox';
 import { WriteFileTool, ReadFileTool, ListDirTool } from '../tools/FileTools';
 import { SearchFileTool } from '../tools/SearchTools';
 import { PersistentShellTool } from '../tools/PersistentShellTool';
@@ -229,53 +230,38 @@ export class ReplManager {
             } catch (e) { }
         }
 
+        // Initialize InputBox with history
+        const inputBox = new InputBox(commandHistory);
+
         while (true) {
-            // 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 promptText = `> `;  // Clean prompt
-
-            // Use readline for basic input to support history
-            const answer = await new Promise<string>((resolve) => {
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                    history: commandHistory,
-                    historySize: 1000,
-                    prompt: promptText
-                });
+            // Calculate context usage for display
+            const usage = this.contextVisualizer.calculateUsage(this.history);
 
-                rl.prompt();
+            // Display enhanced input frame
+            inputBox.displayFrame({
+                messageCount: this.history.length,
+                contextPercent: usage.percentage
+            });
 
-                rl.on('line', (line) => {
-                    rl.close();
-                    resolve(line);
-                });
+            // Get styled input
+            const answer = await inputBox.prompt({
+                showHint: this.history.length === 0,
+                hint: 'Type your message or /help for commands'
             });
 
-            // Update history manually or grab from rl? 
-            // rl.history gets updated when user hits enter.
-            // But we closed rl. We should manually save the input to our tracking array and file.
             const input = answer.trim();
 
             if (input) {
-                // Update in-memory history (for next readline instance)
-                // Readline history has newest at 0.
-                // Avoid duplicates if needed, but standard shell keeps them.
-                if (commandHistory[0] !== input) {
-                    commandHistory.unshift(input);
-                }
+                // Update history via InputBox
+                inputBox.addToHistory(input);
 
-                // Append to file (as standard log, so append at end)
+                // Append to file
                 try {
                     fs.appendFileSync(HISTORY_FILE, input + '\n');
                 } catch (e) { }
             }
 
-            if (!answer.trim()) continue; // Skip empty but allow it to close readline loop
+            if (!input) continue;
 
             if (input.startsWith('/')) {
                 await this.handleCommand(input);

package/src/skills/Skill.ts

@@ -1,26 +1,96 @@
 /**
- * Skill data structure for Agent Skills system
- * Based on Claude Code's Agent Skills format
+ * Agent Skills System
+ *
+ * Based on Claude Code's Agent Skills format. Skills are reusable AI agent
+ * configurations stored as SKILL.md files in dedicated directories.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```markdown
+ * ---
+ * name: code-reviewer
+ * description: Use when the user asks for a code review. Examines code for bugs, style issues, and improvements.
+ * allowed-tools: [Read, Grep, Glob]
+ * ---
+ *
+ * Review the code for...
+ * ```
  */
 
+/**
+ * Core metadata for an Agent Skill
+ *
+ * @remarks
+ * Skills define specialized AI behaviors with optional tool restrictions.
+ * The description should include when to use the skill (e.g., "Use when...").
+ */
 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
+    /**
+     * Lowercase skill name with numbers and hyphens only (max 64 chars)
+     *
+     * @pattern ^[a-z0-9-]+$
+     * @maxLength 64
+     */
+    name: string;
+    /**
+     * What the skill does and when to use it (max 1024 chars)
+     *
+     * @remarks
+     * Should include phrases like "Use when..." or "Use for..."
+     * to help the AI understand when to invoke this skill.
+     *
+     * @maxLength 1024
+     */
+    description: string;
+    /**
+     * Optional list of tools the skill is allowed to use
+     *
+     * @remarks
+     * If specified, the AI will be restricted to only these tools
+     * when executing this skill.
+     */
+    allowedTools?: string[];
 }
 
+/**
+ * A fully loaded Agent Skill
+ */
 export interface Skill extends SkillMetadata {
-    path: string;           // Path to SKILL.md
+    /** Absolute path to the SKILL.md file */
+    path: string;
+    /** Whether this is personal, project, or plugin skill */
     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
+    /**
+     * Full skill content (loaded on demand)
+     *
+     * @remarks
+     * For progressive disclosure, only metadata is loaded initially.
+     * The full content is loaded only when the skill is invoked.
+     */
+    content?: string;
+    /** Directory containing the skill (for resolving supporting files) */
+    directory: string;
+    /** Whether the skill passes validation */
+    isValid: boolean;
+    /** Validation errors if any */
+    errors?: string[];
 }
 
+/**
+ * YAML frontmatter parsed from SKILL.md
+ */
 export interface SkillFrontmatter {
+    /** Skill name */
     name: string;
+    /** Skill description */
     description: string;
+    /**
+     * Optional tool restrictions
+     *
+     * @remarks
+     * YAML key uses kebab-case: allowed-tools
+     */
     'allowed-tools'?: string[];
 }
 
@@ -28,13 +98,20 @@ export interface SkillFrontmatter {
  * Validation result for a skill
  */
 export interface SkillValidationResult {
+    /** Whether the skill is valid */
     isValid: boolean;
+    /** Validation errors that must be fixed */
     errors: string[];
+    /** Warnings that don't block usage */
     warnings: string[];
 }
 
 /**
- * Skill context format for model injection
+ * Minimal skill context for model injection
+ *
+ * @remarks
+ * This is the format used when injecting skills into the system prompt.
+ * Only name and description are included (progressive disclosure).
  */
 export interface SkillContext {
     name: string;
@@ -45,7 +122,10 @@ export interface SkillContext {
  * Options for skill discovery
  */
 export interface SkillDiscoveryOptions {
+    /** Include personal skills from ~/.mentis/skills */
     includePersonal?: boolean;
+    /** Include project skills from .mentis/skills */
     includeProject?: boolean;
+    /** Include plugin skills (not yet implemented) */
     includePlugin?: boolean;
 }

package/src/skills/SkillsManager.ts

@@ -43,11 +43,19 @@ export class SkillsManager {
         const discovered: Skill[] = [];
 
         if (includePersonal) {
-            discovered.push(...await this.discoverSkillsInDirectory(this.personalSkillsDir, 'personal'));
+            try {
+                discovered.push(...await this.discoverSkillsInDirectory(this.personalSkillsDir, 'personal'));
+            } catch (error: any) {
+                console.warn(`Warning: Failed to load personal skills from ${this.personalSkillsDir}: ${error.message}`);
+            }
         }
 
         if (includeProject) {
-            discovered.push(...await this.discoverSkillsInDirectory(this.projectSkillsDir, 'project'));
+            try {
+                discovered.push(...await this.discoverSkillsInDirectory(this.projectSkillsDir, 'project'));
+            } catch (error: any) {
+                console.warn(`Warning: Failed to load project skills from ${this.projectSkillsDir}: ${error.message}`);
+            }
         }
 
         // Store skills in map for quick lookup
@@ -102,6 +110,7 @@ export class SkillsManager {
             const frontmatter = this.extractFrontmatter(content);
 
             if (!frontmatter) {
+                console.warn(`Warning: Invalid or missing frontmatter in ${skillPath} (skipping)`);
                 return null;
             }
 
@@ -124,9 +133,22 @@ export class SkillsManager {
                 errors: validation.errors.length > 0 ? validation.errors : undefined
             };
 
+            // Log validation warnings
+            if (validation.warnings.length > 0) {
+                for (const warning of validation.warnings) {
+                    console.warn(`Warning (${skill.name}): ${warning}`);
+                }
+            }
+
             return skill;
         } catch (error: any) {
-            console.error(`Error loading skill metadata from ${skillPath}: ${error.message}`);
+            if (error.code === 'ENOENT') {
+                console.warn(`Warning: Skill file not found: ${skillPath}`);
+            } else if (error.code === 'EACCES') {
+                console.warn(`Warning: Permission denied reading skill: ${skillPath}`);
+            } else {
+                console.error(`Error loading skill metadata from ${skillPath}: ${error.message}`);
+            }
             return null;
         }
     }

package/src/skills/__tests__/SkillsManager.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Tests for SkillsManager
+ */
+
+import { SkillsManager } from '../SkillsManager';
+import { Skill } from '../Skill';
+
+describe('SkillsManager', () => {
+    let manager: SkillsManager;
+
+    beforeEach(() => {
+        manager = new SkillsManager();
+    });
+
+    describe('getAllSkills', () => {
+        it('should return empty array initially', () => {
+            const skills = manager.getAllSkills();
+            expect(skills).toEqual([]);
+        });
+    });
+
+    describe('getSkill', () => {
+        it('should return undefined for non-existent skill', () => {
+            const skill = manager.getSkill('non-existent');
+            expect(skill).toBeUndefined();
+        });
+    });
+
+    describe('getSkillsContext', () => {
+        it('should return empty string when no skills', () => {
+            const context = manager.getSkillsContext();
+            expect(context).toBe('');
+        });
+    });
+
+    describe('addSkill', () => {
+        it('should add skill to manager', () => {
+            const skill: Skill = {
+                name: 'test-skill',
+                description: 'Test skill',
+                path: '/skills/test.md',
+                type: 'personal',
+                directory: '/skills',
+                isValid: true,
+                content: 'Test content'
+            };
+
+            manager['skills'].set('test-skill', skill);
+            const retrieved = manager.getSkill('test-skill');
+
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.name).toBe('test-skill');
+        });
+
+        it('should return skills context with skills', () => {
+            const skill: Skill = {
+                name: 'reviewer',
+                description: 'Code reviewer skill',
+                path: '/skills/reviewer.md',
+                type: 'personal',
+                directory: '/skills',
+                isValid: true,
+                content: 'Review code'
+            };
+
+            manager['skills'].set('reviewer', skill);
+            const context = manager.getSkillsContext();
+
+            expect(context).toContain('Available Skills');
+            expect(context).toContain('reviewer');
+        });
+    });
+});