@indiccoder/mentis-cli 1.0.9 → 1.1.1

package/.mentis/commands/ls.md

@@ -0,0 +1,12 @@
+---
+description: List all files in current directory
+argument-hint: "[directory]"
+---
+## Usage
+Use this command to list files: /ls [directory]
+
+## Instructions
+List all files using the ls command. If $1 is provided, use it as the directory.
+
+!`ls -la $ARGUMENTS`
+

package/dist/commands/Command.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Custom Slash Commands System
+ * Users can define their own slash commands as markdown files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/CommandCreator.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * CommandCreator - Interactive wizard for creating new custom slash commands
+ */
+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.CommandCreator = void 0;
+exports.validateCommands = validateCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CommandManager_1 = require("./CommandManager");
+class CommandCreator {
+    constructor(commandManager) {
+        this.commandManager = commandManager || new CommandManager_1.CommandManager();
+    }
+    /**
+     * Run the interactive command creation wizard
+     */
+    async run(name) {
+        console.log('\n📝 Create a new Custom Slash Command\n');
+        let commandName;
+        let commandType;
+        let description;
+        let allowedTools;
+        let argumentHint;
+        let namespace;
+        // Step 1: Command Name
+        if (name) {
+            commandName = name;
+        }
+        else {
+            const { name: inputName } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Command 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;
+                    }
+                }
+            ]);
+            commandName = inputName;
+        }
+        // Step 2: Command Type
+        const { type } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Command type:',
+                choices: [
+                    { name: 'Personal (available in all projects)', value: 'personal' },
+                    { name: 'Project (shared with team via git)', value: 'project' }
+                ],
+                default: 'personal'
+            }
+        ]);
+        commandType = type;
+        // Step 3: Namespace (optional, for grouping)
+        const { useNamespace } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useNamespace',
+                message: 'Add a namespace for grouping?',
+                default: false
+            }
+        ]);
+        if (useNamespace) {
+            const { ns } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'ns',
+                    message: 'Namespace (e.g., "git", "review", "test"):',
+                    validate: (input) => {
+                        if (!input)
+                            return 'Namespace is required';
+                        if (!/^[a-z0-9-]+$/.test(input)) {
+                            return 'Namespace must contain only lowercase letters, numbers, and hyphens';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            namespace = ns;
+        }
+        // Step 4: Description
+        const { desc } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'desc',
+                message: 'Description:',
+                validate: (input) => {
+                    if (!input)
+                        return 'Description is required';
+                    if (input.length > 1024)
+                        return 'Description must be 1024 characters or less';
+                    return true;
+                }
+            }
+        ]);
+        description = desc;
+        // Step 5: Arguments (optional)
+        const { useArgs } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useArgs',
+                message: 'Does this command accept arguments?',
+                default: false
+            }
+        ]);
+        if (useArgs) {
+            const { hint } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'hint',
+                    message: 'Argument hint (e.g., "<file>", "[options]"):',
+                    validate: (input) => {
+                        if (!input)
+                            return 'Argument hint is required';
+                        return true;
+                    }
+                }
+            ]);
+            argumentHint = hint;
+        }
+        // Step 6: Allowed Tools (optional)
+        const { useAllowedTools } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useAllowedTools',
+                message: 'Restrict which tools this command 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 7: Create the command
+        return this.createCommand(commandName, commandType, description, allowedTools, argumentHint, namespace);
+    }
+    /**
+     * Create the command file
+     */
+    async createCommand(name, type, description, allowedTools, argumentHint, namespace) {
+        const baseDir = type === 'personal'
+            ? path.join(os.homedir(), '.mentis', 'commands')
+            : path.join(process.cwd(), '.mentis', 'commands');
+        const commandDir = namespace ? path.join(baseDir, namespace) : baseDir;
+        const commandFile = path.join(commandDir, `${name}.md`);
+        // Check if command already exists
+        if (fs.existsSync(commandFile)) {
+            const { overwrite } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Command "${name}" already exists. Overwrite?`,
+                    default: false
+                }
+            ]);
+            if (!overwrite) {
+                console.log('Cancelled.');
+                return false;
+            }
+        }
+        // Create directory
+        if (!fs.existsSync(commandDir)) {
+            fs.mkdirSync(commandDir, { recursive: true });
+        }
+        // Generate command content
+        let content = `---\ndescription: ${description}\n`;
+        if (allowedTools && allowedTools.length > 0) {
+            content += `allowed-tools: [${allowedTools.map(t => `"${t}"`).join(', ')}]\n`;
+        }
+        if (argumentHint) {
+            content += `argument-hint: "${argumentHint}"\n`;
+        }
+        content += `---\n\n`;
+        // Add usage instructions in markdown
+        content += `## Usage\n\n`;
+        content += `Use this command by typing: /${name}${argumentHint ? ` ${argumentHint}` : ''}\n\n`;
+        content += `## Instructions\n\n`;
+        content += `Add your instructions here. You can use:\n`;
+        content += `- \`$1\`, \`$2\`, etc. for positional arguments\n`;
+        content += `- \`$ARGUMENTS\` for all arguments\n`;
+        content += `- \`\!\\\`command\`\` for bash commands\n`;
+        content += `- \`@file\` for file references\n\n`;
+        // Write command file
+        fs.writeFileSync(commandFile, content, 'utf-8');
+        console.log(`\n✓ Command created at: ${commandFile}`);
+        console.log(`\nNext steps:`);
+        console.log(`  1. Edit ${commandFile} to add instructions`);
+        console.log(`  2. Restart Mentis or use /commands validate to load the new command`);
+        return true;
+    }
+}
+exports.CommandCreator = CommandCreator;
+/**
+ * Validate commands and show results
+ */
+async function validateCommands(commandManager) {
+    const commands = commandManager.getAllCommands();
+    console.log('\n📋 Command Validation Results\n');
+    if (commands.length === 0) {
+        console.log('No custom commands to validate.');
+        console.log('Create commands with: /commands create');
+        return;
+    }
+    for (const cmd of commands) {
+        const isValid = cmd.name && cmd.name.length > 0 && cmd.content.length > 0;
+        const icon = isValid ? '✓' : '✗';
+        console.log(`${icon} /${cmd.name} (${cmd.type})`);
+        if (!isValid) {
+            console.log(`  ERROR: Invalid command structure`);
+        }
+        if (cmd.frontmatter['allowed-tools'] && cmd.frontmatter['allowed-tools'].length > 0) {
+            console.log(`  Allowed tools: ${cmd.frontmatter['allowed-tools'].join(', ')}`);
+        }
+    }
+    console.log(`\n✓ Validated ${commands.length} commands`);
+}

package/dist/commands/CommandManager.js

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * CommandManager - Discover, parse, and execute custom slash commands
+ */
+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.CommandManager = 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 CommandManager {
+    constructor(cwd = process.cwd()) {
+        this.commands = new Map();
+        this.personalCommandsDir = path.join(os.homedir(), '.mentis', 'commands');
+        this.projectCommandsDir = path.join(cwd, '.mentis', 'commands');
+    }
+    /**
+     * Discover all commands from configured directories
+     */
+    async discoverCommands() {
+        const discovered = [];
+        // Personal commands
+        discovered.push(...await this.discoverCommandsInDirectory(this.personalCommandsDir, 'personal'));
+        // Project commands
+        discovered.push(...await this.discoverCommandsInDirectory(this.projectCommandsDir, 'project'));
+        // Store commands in map (project commands override personal)
+        for (const command of discovered) {
+            this.commands.set(command.name, command);
+        }
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Discover commands in a specific directory
+     */
+    async discoverCommandsInDirectory(dir, type) {
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+        const commands = [];
+        try {
+            // Find all .md files in subdirectories
+            const commandFiles = await (0, fast_glob_1.glob)('**/*.md', {
+                cwd: dir,
+                absolute: true,
+                onlyFiles: true
+            });
+            for (const commandFile of commandFiles) {
+                const command = await this.parseCommandFile(commandFile, type);
+                if (command) {
+                    commands.push(command);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error discovering commands in ${dir}: ${error.message}`);
+        }
+        return commands;
+    }
+    /**
+     * Parse a command file
+     */
+    async parseCommandFile(commandPath, type) {
+        try {
+            const content = fs.readFileSync(commandPath, 'utf-8');
+            const frontmatter = this.extractFrontmatter(content);
+            const commandName = this.getCommandName(commandPath, type);
+            if (!commandName) {
+                return null;
+            }
+            // Get namespace (subdirectory)
+            const relativePath = path.relative(type === 'personal' ? this.personalCommandsDir : this.projectCommandsDir, commandPath);
+            const namespace = path.dirname(relativePath) !== '.' ? path.dirname(relativePath) : '';
+            const description = frontmatter.description || this.extractFirstLine(content);
+            const command = {
+                name: commandName,
+                type,
+                path: commandPath,
+                directory: path.dirname(commandPath),
+                frontmatter,
+                content: content,
+                description: namespace ? `${description} (${type}:${namespace})` : description,
+                hasParameters: content.includes('$1') || content.includes('$ARGUMENTS')
+            };
+            return command;
+        }
+        catch (error) {
+            console.error(`Error parsing command ${commandPath}: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Get command name from file path
+     */
+    getCommandName(commandPath, type) {
+        const relativePath = path.relative(type === 'personal' ? this.personalCommandsDir : this.projectCommandsDir, commandPath);
+        const nameWithExt = path.basename(relativePath); // e.g., "review.md"
+        const name = nameWithExt.replace(/\.md$/, ''); // e.g., "review"
+        if (!name || name.startsWith('.')) {
+            return null;
+        }
+        return name;
+    }
+    /**
+     * 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 {};
+        }
+        try {
+            const parsed = yaml_1.default.parse(match[1]);
+            return parsed;
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    /**
+     * Extract first line of content as description
+     */
+    extractFirstLine(content) {
+        // Remove frontmatter
+        const withoutFrontmatter = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, '');
+        // Get first non-empty line
+        const lines = withoutFrontmatter.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                return trimmed;
+            }
+        }
+        return 'No description';
+    }
+    /**
+     * Get command by name
+     */
+    getCommand(name) {
+        return this.commands.get(name);
+    }
+    /**
+     * Get all commands
+     */
+    getAllCommands() {
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Get commands context for system prompt injection
+     */
+    getCommandsContext() {
+        const commands = this.getAllCommands();
+        if (commands.length === 0) {
+            return '';
+        }
+        const context = commands.map(cmd => {
+            let line = `/${cmd.name}`;
+            if (cmd.frontmatter['argument-hint']) {
+                line += ` ${cmd.frontmatter['argument-hint']}`;
+            }
+            line += `: ${cmd.description.replace(/\s*\([^)]+\)/, '')}`;
+            return line;
+        }).join('\n');
+        return `Available Custom Commands:\n${context}`;
+    }
+    /**
+     * Parse command content and execute substitutions
+     */
+    async parseCommand(command, args) {
+        let content = command.content;
+        const bashCommands = [];
+        const fileReferences = [];
+        // Remove frontmatter from content
+        content = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, '');
+        // Substitute $1, $2, etc.
+        content = this.substitutePositionalArgs(content, args);
+        // Substitute $ARGUMENTS
+        content = this.substituteAllArgs(content, args);
+        // Extract and collect bash commands (!`cmd`)
+        const bashRegex = /!`([^`]+)`/g;
+        let bashMatch;
+        while ((bashMatch = bashRegex.exec(content)) !== null) {
+            bashCommands.push(bashMatch[1]);
+        }
+        // Remove bash command markers
+        content = content.replace(/!`[^`]+`/g, '[BASH_OUTPUT]');
+        // Extract and collect file references (@file)
+        const fileRegex = /@([^\s]+)/g;
+        let fileMatch;
+        while ((fileMatch = fileRegex.exec(content)) !== null) {
+            fileReferences.push(fileMatch[1]);
+        }
+        return { content, bashCommands, fileReferences };
+    }
+    /**
+     * Substitute positional arguments ($1, $2, etc.)
+     */
+    substitutePositionalArgs(content, args) {
+        return content.replace(/\$(\d+)/g, (match, index) => {
+            const argIndex = parseInt(index) - 1;
+            return args[argIndex] || '';
+        });
+    }
+    /**
+     * Substitute $ARGUMENTS placeholder
+     */
+    substituteAllArgs(content, args) {
+        return content.replace(/\$ARGUMENTS/g, args.join(' '));
+    }
+    /**
+     * Ensure commands directories exist
+     */
+    ensureDirectoriesExist() {
+        if (!fs.existsSync(this.personalCommandsDir)) {
+            fs.mkdirSync(this.personalCommandsDir, { recursive: true });
+        }
+    }
+    /**
+     * Get personal commands directory path
+     */
+    getPersonalCommandsDir() {
+        return this.personalCommandsDir;
+    }
+    /**
+     * Get project commands directory path
+     */
+    getProjectCommandsDir() {
+        return this.projectCommandsDir;
+    }
+}
+exports.CommandManager = CommandManager;