@indiccoder/mentis-cli 1.1.2 → 1.1.4

package/dist/repl/ReplManager.js

@@ -44,6 +44,7 @@ const ConfigManager_1 = require("../config/ConfigManager");
 const OpenAIClient_1 = require("../llm/OpenAIClient");
 const ContextManager_1 = require("../context/ContextManager");
 const UIManager_1 = require("../ui/UIManager");
+const InputBox_1 = require("../ui/InputBox");
 const FileTools_1 = require("../tools/FileTools");
 const SearchTools_1 = require("../tools/SearchTools");
 const PersistentShellTool_1 = require("../tools/PersistentShellTool");
@@ -224,46 +225,33 @@ class ReplManager {
             }
             catch (e) { }
         }
+        // Initialize InputBox with history
+        const inputBox = new InputBox_1.InputBox(commandHistory);
         while (true) {
-            // 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({
-                    input: process.stdin,
-                    output: process.stdout,
-                    history: commandHistory,
-                    historySize: 1000,
-                    prompt: promptText
-                });
-                rl.prompt();
-                rl.on('line', (line) => {
-                    rl.close();
-                    resolve(line);
-                });
+            // Calculate context usage for display
+            const usage = this.contextVisualizer.calculateUsage(this.history);
+            // Display enhanced input frame
+            inputBox.displayFrame({
+                messageCount: this.history.length,
+                contextPercent: usage.percentage
+            });
+            // 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);
-                }
-                // Append to file (as standard log, so append at end)
+                // Update history via InputBox
+                inputBox.addToHistory(input);
+                // 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);
                 continue;

package/dist/skills/Skill.js

@@ -1,6 +1,21 @@
 "use strict";
 /**
- * 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...
+ * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/skills/SkillsManager.js

@@ -60,10 +60,20 @@ class SkillsManager {
          } = options;
         const discovered = [];
         if (includePersonal) {
-            discovered.push(...await this.discoverSkillsInDirectory(this.personalSkillsDir, 'personal'));
+            try {
+                discovered.push(...await this.discoverSkillsInDirectory(this.personalSkillsDir, 'personal'));
+            }
+            catch (error) {
+                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) {
+                console.warn(`Warning: Failed to load project skills from ${this.projectSkillsDir}: ${error.message}`);
+            }
         }
         // Store skills in map for quick lookup
         for (const skill of discovered) {
@@ -109,6 +119,7 @@ class SkillsManager {
             const content = fs.readFileSync(skillPath, 'utf-8');
             const frontmatter = this.extractFrontmatter(content);
             if (!frontmatter) {
+                console.warn(`Warning: Invalid or missing frontmatter in ${skillPath} (skipping)`);
                 return null;
             }
             // Convert SkillFrontmatter to SkillMetadata for validation
@@ -128,10 +139,24 @@ class SkillsManager {
                 isValid: validation.isValid,
                 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) {
-            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/dist/skills/__tests__/SkillsManager.test.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Tests for SkillsManager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SkillsManager_1 = require("../SkillsManager");
+describe('SkillsManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new SkillsManager_1.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 = {
+                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 = {
+                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');
+        });
+    });
+});

package/dist/ui/InputBox.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * InputBox - Simple clean input with top line only
+ * Bottom line appears after submission (cross-platform compatible)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputBox = void 0;
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+class InputBox {
+    constructor(history = []) {
+        this.history = [];
+        this.historySize = 1000;
+        this.history = history;
+    }
+    /**
+     * Get terminal width
+     */
+    getTerminalWidth() {
+        return process.stdout.columns || 80;
+    }
+    /**
+     * Create horizontal line
+     */
+    createLine() {
+        const width = this.getTerminalWidth();
+        return chalk_1.default.gray('─'.repeat(width));
+    }
+    /**
+     * Get user input with horizontal lines around it
+     */
+    async prompt(options = {}) {
+        const { showHint = false, hint } = options;
+        // Display top horizontal line
+        console.log(this.createLine());
+        // Display hint if provided
+        if (showHint && hint) {
+            console.log(chalk_1.default.dim(`  ${hint}`));
+        }
+        return new Promise((resolve) => {
+            // Create readline with simple prompt
+            const rl = readline_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                prompt: chalk_1.default.cyan('> '),
+                history: this.history,
+                historySize: this.historySize,
+                completer: this.completer.bind(this)
+            });
+            rl.prompt();
+            rl.on('line', (line) => {
+                // Display bottom horizontal line after input
+                console.log(this.createLine());
+                rl.close();
+                resolve(line);
+            });
+            // Handle Ctrl+C
+            rl.on('SIGINT', () => {
+                console.log(this.createLine());
+                rl.close();
+                resolve('/exit');
+            });
+        });
+    }
+    /**
+     * Simple tab completer for commands
+     */
+    completer(line) {
+        const commands = [
+            '/help', '/clear', '/exit', '/update', '/config',
+            '/init', '/resume', '/skills', '/commands', '/checkpoint',
+            '/model', '/use', '/mcp', '/search', '/run', '/commit'
+        ];
+        const hits = commands.filter(c => c.startsWith(line));
+        return [hits.length ? hits : commands, line];
+    }
+    /**
+     * Add input to history
+     */
+    addToHistory(input) {
+        if (!input || input === this.history[0])
+            return;
+        this.history.unshift(input);
+        if (this.history.length > this.historySize) {
+            this.history = this.history.slice(0, this.historySize);
+        }
+    }
+    /**
+     * Get current history
+     */
+    getHistory() {
+        return this.history;
+    }
+    /**
+     * Display separator and context info before input
+     */
+    displayFrame(contextInfo) {
+        console.log('');
+        // Context bar with message count and percentage
+        if (contextInfo) {
+            const { messageCount, contextPercent } = contextInfo;
+            const color = contextPercent < 60 ? chalk_1.default.green : contextPercent < 80 ? chalk_1.default.yellow : chalk_1.default.red;
+            const bar = this.createProgressBar(contextPercent);
+            console.log(chalk_1.default.dim(`  ${bar} ${messageCount} msgs ${color(contextPercent + '%')}`));
+        }
+    }
+    /**
+     * Display separator (alias for displayFrame)
+     */
+    displaySeparator(contextInfo) {
+        this.displayFrame(contextInfo);
+    }
+    /**
+     * Create a visual progress bar
+     */
+    createProgressBar(percentage) {
+        const width = 15;
+        const filled = Math.round(percentage / 100 * width);
+        const empty = width - filled;
+        const color = percentage < 60 ? chalk_1.default.green : percentage < 80 ? chalk_1.default.yellow : chalk_1.default.red;
+        return color('█'.repeat(filled)) + chalk_1.default.dim('░'.repeat(empty));
+    }
+}
+exports.InputBox = InputBox;

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.1.2 - AI Coding Agent'));
+        console.log(chalk_1.default.gray('  v1.1.3 - AI Coding Agent'));
         console.log('');
     }
     static renderDashboard(config) {
         const { model, cwd } = config;
-        const version = 'v1.1.2';
+        const version = 'v1.1.3';
         // Layout: Left (Status/Welcome) | Right (Tips/Activity)
         // Total width ~80 chars. 
         // Left ~45, Right ~30.

package/dist/utils/__mocks__/chalk.js

@@ -0,0 +1,20 @@
+"use strict";
+// Manual mock for chalk to avoid ESM issues in Jest
+module.exports = {
+    dim: (str) => str,
+    green: (str) => str,
+    yellow: (str) => str,
+    red: (str) => str,
+    gray: (str) => str,
+    bold: (str) => str,
+    cyan: (str) => str,
+    default: {
+        dim: (str) => str,
+        green: (str) => str,
+        yellow: (str) => str,
+        red: (str) => str,
+        gray: (str) => str,
+        bold: (str) => str,
+        cyan: (str) => str
+    }
+};

package/dist/utils/__tests__/ContextVisualizer.test.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Tests for ContextVisualizer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextVisualizer_1 = require("../ContextVisualizer");
+describe('ContextVisualizer', () => {
+    let visualizer;
+    beforeEach(() => {
+        visualizer = new ContextVisualizer_1.ContextVisualizer();
+    });
+    describe('calculateUsage', () => {
+        it('should handle empty history', () => {
+            const history = [];
+            const usage = visualizer.calculateUsage(history);
+            // Includes 2000 char overhead = 500 tokens
+            expect(usage.tokens).toBe(500);
+            expect(usage.maxTokens).toBe(128000);
+            expect(usage).toHaveProperty('percentage');
+            expect(usage).toHaveProperty('tokens');
+            expect(usage).toHaveProperty('maxTokens');
+        });
+        it('should calculate tokens for messages', () => {
+            const history = [
+                { role: 'system', content: 'You are a helpful assistant.' },
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi there!' }
+            ];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.tokens).toBeGreaterThan(500);
+            expect(usage.tokens).toBeLessThan(1000);
+            expect(usage.maxTokens).toBe(128000);
+        });
+        it('should handle large messages', () => {
+            const largeContent = 'x'.repeat(10000);
+            const history = [
+                { role: 'user', content: largeContent }
+            ];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.tokens).toBeGreaterThan(1500);
+        });
+    });
+    describe('formatBar', () => {
+        it('should format bar at low usage', () => {
+            const usage = { tokens: 1000, percentage: 5, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            // Check that bar contains expected data (without chalk dependency)
+            expect(bar).toContain('5');
+            expect(bar).toContain('1k');
+            expect(bar).toContain('128');
+        });
+        it('should format bar at medium usage', () => {
+            const usage = { tokens: 50000, percentage: 40, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            expect(bar).toContain('40');
+            expect(bar).toContain('50k');
+        });
+        it('should format bar at high usage', () => {
+            const usage = { tokens: 100000, percentage: 80, maxTokens: 128000 };
+            const bar = visualizer.formatBar(usage);
+            expect(bar).toContain('80');
+            expect(bar).toContain('100k');
+        });
+    });
+    describe('shouldCompact', () => {
+        it('should return false for low percentage', () => {
+            const history = [
+                { role: 'user', content: 'small message' }
+            ];
+            const shouldCompact = visualizer.shouldCompact(history);
+            expect(shouldCompact).toBe(false);
+        });
+        it('should return true at 80% threshold', () => {
+            // Create enough content to exceed 80%
+            // 80% of 128000 tokens = 102400 tokens = ~409600 chars
+            // Subtract 2000 overhead = ~407400 chars needed
+            const largeContent = 'x'.repeat(410000);
+            const history = [
+                { role: 'system', content: largeContent },
+                { role: 'user', content: largeContent }
+            ];
+            const shouldCompact = visualizer.shouldCompact(history);
+            expect(shouldCompact).toBe(true);
+        });
+    });
+    describe('setMaxTokens', () => {
+        it('should update max tokens', () => {
+            visualizer.setMaxTokens(32000);
+            const history = [];
+            const usage = visualizer.calculateUsage(history);
+            expect(usage.maxTokens).toBe(32000);
+            expect(usage.percentage).toBeGreaterThan(1); // Should be higher percentage with smaller max
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indiccoder/mentis-cli",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "publishConfig": {
     "access": "public"
   },
@@ -12,7 +12,9 @@
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "keywords": [
     "cli",
@@ -33,6 +35,7 @@
     "axios": "^1.13.2",
     "boxen": "^8.0.1",
     "chalk": "^5.6.2",
+    "cli-cursor": "^5.0.0",
     "cli-highlight": "^2.1.11",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
@@ -54,11 +57,31 @@
     "yaml": "^2.7.0"
   },
   "devDependencies": {
+    "@types/cli-cursor": "^2.1.0",
     "@types/figlet": "^1.7.0",
     "@types/fs-extra": "^11.0.4",
     "@types/gradient-string": "^1.1.6",
     "@types/inquirer": "^9.0.9",
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.0.2",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "roots": ["<rootDir>/src"],
+    "testMatch": ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
+    "collectCoverageFrom": ["src/**/*.ts", "!src/**/*.d.ts"],
+    "transformIgnorePatterns": ["node_modules/(?!(chalk)/)"],
+    "coverageThreshold": {
+      "global": {
+        "branches": 20,
+        "functions": 30,
+        "lines": 30,
+        "statements": 30
+      }
+    }
   }
 }

package/src/commands/Command.ts

@@ -1,40 +1,91 @@
 /**
  * Custom Slash Commands System
- * Users can define their own slash commands as markdown files
+ *
+ * Users can define their own slash commands as markdown files with YAML frontmatter.
+ * Commands support parameter substitution, bash execution, and file references.
+ *
+ * @packageDocumentation
+ *
+ * @example
+ * ```markdown
+ * ---
+ * description: Run tests and show coverage
+ * argument-hint: [test-pattern]
+ * ---
+ *
+ * Run tests with !`npm test $1`
+ * ```
  */
 
+/**
+ * YAML frontmatter options for custom commands
+ */
 export interface CommandFrontmatter {
+    /** Human-readable description of what the command does */
     description?: string;
+    /** Restrict which tools the AI can use when executing this command */
     'allowed-tools'?: string[];
+    /** Hint shown to user about expected arguments (e.g., "[pattern]") */
     'argument-hint'?: string;
+    /** Specific model to use for this command */
     model?: string;
+    /** Disable AI model invocation (execute bash/reads only) */
     'disable-model-invocation'?: boolean;
 }
 
+/**
+ * A custom slash command
+ */
 export interface Command {
-    name: string;              // Command name (from filename)
-    type: 'personal' | 'project';  // Personal or project command
-    path: string;               // Path to command file
-    directory: string;          // Directory containing the command
+    /** Command name (derived from filename, without .md extension) */
+    name: string;
+    /** Whether this is a personal or project-level command */
+    type: 'personal' | 'project';
+    /** Absolute path to the command's .md file */
+    path: string;
+    /** Directory containing the command file */
+    directory: string;
+    /** Parsed YAML frontmatter from the command file */
     frontmatter: CommandFrontmatter;
-    content: string;            // Command content (markdown)
-    description: string;        // Command description
-    hasParameters: boolean;     // Whether command uses parameters
+    /** Raw markdown content of the command */
+    content: string;
+    /** Human-readable description for display */
+    description: string;
+    /** Whether the command uses $1, $2, or $ARGUMENTS placeholders */
+    hasParameters: boolean;
 }
 
+/**
+ * Execution context for running a custom command
+ */
 export interface CommandExecutionContext {
+    /** The command being executed */
     command: Command;
-    args: string[];             // Command arguments
+    /** Arguments passed to the command */
+    args: string[];
+    /** Function to substitute $1, $2, $ARGUMENTS placeholders */
     substitutePlaceholders: (content: string, args: string[]) => string;
+    /** Function to execute bash commands */
     executeBash: (bashCommand: string) => Promise<string>;
+    /** Function to read file contents */
     readFile: (filePath: string) => Promise<string>;
 }
 
 /**
- * Parsed command with substitutions applied
+ * Parsed command with all substitutions applied
+ *
+ * @remarks
+ * After parsing, the command content will have:
+ * - $1, $2, etc. replaced with positional arguments
+ * - $ARGUMENTS replaced with all arguments joined by spaces
+ * - !`cmd` patterns extracted to bashCommands and replaced with [BASH_OUTPUT]
+ * - @file patterns extracted to fileReferences
  */
 export interface ParsedCommand {
-    content: string;            // Content with substitutions applied
-    bashCommands: string[];     // Bash commands to execute
-    fileReferences: string[];   // Files to read
+    /** Content with all substitutions applied */
+    content: string;
+    /** Bash commands extracted from !`cmd` patterns */
+    bashCommands: string[];
+    /** File paths extracted from @file patterns */
+    fileReferences: string[];
 }