@indiccoder/mentis-cli 1.1.3 → 1.1.5

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/tools/AskQuestionTool.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AskQuestionTool = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * AskQuestionTool - Allows the AI to ask clarifying questions
+ * This enables interactive plan mode where AI can gather requirements
+ */
+class AskQuestionTool {
+    constructor() {
+        this.name = 'ask_question';
+        this.description = 'Ask the user a clarifying question. Use this in plan mode to gather requirements before implementation. Supports: text, confirm (yes/no), list (single choice), checkbox (multi-select).';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'The question to ask the user'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['text', 'confirm', 'list', 'checkbox'],
+                    description: 'Type of question: text (free input), confirm (yes/no), list (single choice), checkbox (multi-select)'
+                },
+                options: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            label: { type: 'string', description: 'Display text for the option' },
+                            description: { type: 'string', description: 'Additional context (optional)' }
+                        }
+                    },
+                    description: 'Options for list/checkbox questions. Required for list/checkbox types.'
+                },
+                default: {
+                    oneOf: [{ type: 'string' }, { type: 'boolean' }, { type: 'array' }],
+                    description: 'Default value (optional)'
+                }
+            },
+            required: ['question', 'type']
+        };
+    }
+    /**
+     * Execute the question and return the user's answer
+     */
+    async execute(args) {
+        const questionType = args.type || 'text';
+        // Show question header
+        console.log('');
+        console.log(chalk_1.default.cyan('🤔 Question from AI:'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        try {
+            let result;
+            switch (questionType) {
+                case 'text':
+                    result = await this.askText(args.question, args.default);
+                    break;
+                case 'confirm':
+                    result = await this.askConfirm(args.question, args.default);
+                    break;
+                case 'list':
+                    if (!args.options || args.options.length === 0) {
+                        return 'Error: list questions require options';
+                    }
+                    result = await this.askList(args.question, args.options, args.default);
+                    break;
+                case 'checkbox':
+                    if (!args.options || args.options.length === 0) {
+                        return 'Error: checkbox questions require options';
+                    }
+                    result = await this.askCheckbox(args.question, args.options, args.default);
+                    break;
+                default:
+                    return `Error: Unknown question type: ${questionType}`;
+            }
+            console.log(chalk_1.default.gray('─'.repeat(60)));
+            // Format result as string for return to LLM
+            return this.formatResult(result, questionType);
+        }
+        catch (error) {
+            return `Error asking question: ${error.message}`;
+        }
+    }
+    /**
+     * Ask a free-text question
+     */
+    async askText(question, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'answer',
+                message: question,
+                default: defaultValue
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a yes/no confirmation
+     */
+    async askConfirm(question, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'answer',
+                message: question,
+                default: defaultValue ?? true
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a single-choice list question
+     */
+    async askList(question, options, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'answer',
+                message: question,
+                choices: options.map((opt, i) => ({
+                    name: opt.label,
+                    value: opt.label,
+                    short: opt.label
+                })),
+                default: defaultValue
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Ask a multi-select checkbox question
+     */
+    async askCheckbox(question, options, defaultValue) {
+        const { answer } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'answer',
+                message: question,
+                choices: options.map((opt, i) => ({
+                    name: opt.label,
+                    value: opt.label,
+                    checked: defaultValue?.includes(opt.label),
+                    short: opt.label
+                }))
+            }
+        ]);
+        return answer;
+    }
+    /**
+     * Format the result for return to the LLM
+     */
+    formatResult(result, questionType) {
+        switch (questionType) {
+            case 'confirm':
+                return result === true ? 'Yes' : 'No';
+            case 'checkbox':
+                if (Array.isArray(result) && result.length > 0) {
+                    return `Selected: ${result.join(', ')}`;
+                }
+                return 'None selected';
+            default:
+                return String(result);
+        }
+    }
+}
+exports.AskQuestionTool = AskQuestionTool;

package/dist/tools/EditFileTool.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditFileTool = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * EditFileTool - Performs string replacement in files (like Claude's Edit tool)
+ * Returns a unified diff preview instead of writing immediately
+ */
+class EditFileTool {
+    constructor() {
+        this.name = 'edit_file';
+        this.description = 'Make targeted edits to files using string replacement. Returns diff preview. Requires approval before writing.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit'
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The exact string to replace. Must match exactly (including whitespace).'
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The new string to replace old_string with.'
+                },
+                auto_format: {
+                    type: 'boolean',
+                    description: 'Auto-format code after edit (default: false)'
+                }
+            },
+            required: ['file_path', 'old_string', 'new_string']
+        };
+    }
+    /**
+     * Execute the edit and return a diff preview
+     * Note: This does NOT write the file - it returns what WOULD change
+     * The caller (ReplManager) should handle approval before calling applyEdit()
+     */
+    async execute(args) {
+        const filePath = (0, path_1.resolve)(process.cwd(), args.file_path);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return `Error: File not found: ${args.file_path}`;
+        }
+        const originalContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        if (!originalContent.includes(args.old_string)) {
+            return `Error: old_string not found in file. The string must match exactly (including whitespace and indentation).`;
+        }
+        // Count occurrences
+        const occurrences = (originalContent.match(new RegExp(this.escapeRegex(args.old_string), 'g')) || []).length;
+        if (occurrences > 1) {
+            return `Warning: old_string found ${occurrences} times. All occurrences will be replaced.\n\n${this.generateDiff(originalContent, args.old_string, args.new_string, args.file_path)}`;
+        }
+        // Generate and return diff
+        return this.generateDiff(originalContent, args.old_string, args.new_string, args.file_path);
+    }
+    /**
+     * Apply the edit after approval
+     * This should be called after user approves the diff
+     */
+    applyEdit(args) {
+        const filePath = (0, path_1.resolve)(process.cwd(), args.file_path);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return { success: false, message: `File not found: ${args.file_path}` };
+        }
+        const originalContent = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        if (!originalContent.includes(args.old_string)) {
+            return { success: false, message: 'old_string not found in file' };
+        }
+        const newContent = originalContent.replace(args.old_string, args.new_string);
+        (0, fs_1.writeFileSync)(filePath, newContent, 'utf-8');
+        return {
+            success: true,
+            message: `Successfully edited ${args.file_path}`
+        };
+    }
+    /**
+     * Generate a unified diff preview
+     */
+    generateDiff(content, oldString, newString, filePath) {
+        const lines = content.split('\n');
+        const oldLines = oldString.split('\n');
+        const newLines = newString.split('\n');
+        // Find the line number where old_string starts
+        let startLine = -1;
+        for (let i = 0; i <= lines.length - oldLines.length; i++) {
+            let match = true;
+            for (let j = 0; j < oldLines.length; j++) {
+                if (lines[i + j] !== oldLines[j]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                startLine = i;
+                break;
+            }
+        }
+        if (startLine === -1) {
+            return 'Error: Could not locate old_string in file';
+        }
+        // Build unified diff
+        let diff = `\n${'─'.repeat(60)}\n`;
+        diff += `📝 Edit Preview: ${filePath}\n`;
+        diff += `${'─'.repeat(60)}\n`;
+        diff += `Line ${startLine + 1}:\n\n`;
+        // Show context (2 lines before)
+        const contextStart = Math.max(0, startLine - 2);
+        if (contextStart < startLine) {
+            for (let i = contextStart; i < startLine; i++) {
+                diff += `  ${lines[i]}\n`;
+            }
+        }
+        // Show removed lines (red)
+        for (const line of oldLines) {
+            diff += `\x1b[31m- ${line}\x1b[0m\n`;
+        }
+        // Show added lines (green)
+        for (const line of newLines) {
+            diff += `\x1b[32m+ ${line}\x1b[0m\n`;
+        }
+        // Show context (2 lines after)
+        const contextEnd = Math.min(lines.length, startLine + oldLines.length + 2);
+        if (startLine + oldLines.length < contextEnd) {
+            for (let i = startLine + oldLines.length; i < contextEnd; i++) {
+                diff += `  ${lines[i]}\n`;
+            }
+        }
+        diff += `${'─'.repeat(60)}\n`;
+        return diff;
+    }
+    /**
+     * Escape special regex characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.EditFileTool = EditFileTool;

package/dist/tools/FileTools.js

@@ -3,9 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListDirTool = exports.ReadFileTool = exports.WriteFileTool = void 0;
+exports.ListDirTool = exports.ReadFileTool = exports.WriteFileTool = exports.PlanModeTool = exports.AskQuestionTool = exports.EditFileTool = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+var EditFileTool_1 = require("./EditFileTool");
+Object.defineProperty(exports, "EditFileTool", { enumerable: true, get: function () { return EditFileTool_1.EditFileTool; } });
+var AskQuestionTool_1 = require("./AskQuestionTool");
+Object.defineProperty(exports, "AskQuestionTool", { enumerable: true, get: function () { return AskQuestionTool_1.AskQuestionTool; } });
+var PlanModeTool_1 = require("./PlanModeTool");
+Object.defineProperty(exports, "PlanModeTool", { enumerable: true, get: function () { return PlanModeTool_1.PlanModeTool; } });
 class WriteFileTool {
     constructor() {
         this.name = 'write_file';

package/dist/tools/PlanModeTool.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanModeTool = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const PlanModeUI_1 = require("../ui/PlanModeUI");
+/**
+ * PlanModeTool - Allows AI to suggest switching to plan mode
+ * Use this when the task is complex, requires architecture design, or needs requirements gathering
+ */
+class PlanModeTool {
+    constructor() {
+        this.name = 'enter_plan_mode';
+        this.description = 'Suggest switching to plan mode for complex tasks. Call this when you need to gather requirements, design architecture, or break down a complex implementation before coding.';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: 'Explain why plan mode is recommended for this task'
+                }
+            },
+            required: ['reason']
+        };
+    }
+    /**
+     * Execute - Ask user if they want to switch to plan mode
+     */
+    async execute(args) {
+        console.log('');
+        console.log(chalk_1.default.cyan('🎯 AI suggests entering PLAN MODE'));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        console.log(chalk_1.default.dim(`Reason: ${args.reason}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        const { confirm } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Switch to plan mode?',
+                default: true
+            }
+        ]);
+        if (confirm) {
+            PlanModeUI_1.PlanModeUI.showPlanHeader();
+            return 'User approved. Switching to plan mode for requirements gathering and planning.';
+        }
+        return 'User declined. Continuing in current mode.';
+    }
+}
+exports.PlanModeTool = PlanModeTool;