@indiccoder/mentis-cli 1.0.9 → 1.1.1

package/src/commands/CommandManager.ts

@@ -0,0 +1,280 @@
+/**
+ * CommandManager - Discover, parse, and execute custom slash commands
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { glob } from 'fast-glob';
+import YAML from 'yaml';
+import {
+    Command,
+    CommandFrontmatter,
+    CommandExecutionContext,
+    ParsedCommand
+} from './Command';
+
+export class CommandManager {
+    private commands: Map<string, Command> = new Map();
+    private personalCommandsDir: string;
+    private projectCommandsDir: string;
+
+    constructor(cwd: string = process.cwd()) {
+        this.personalCommandsDir = path.join(os.homedir(), '.mentis', 'commands');
+        this.projectCommandsDir = path.join(cwd, '.mentis', 'commands');
+    }
+
+    /**
+     * Discover all commands from configured directories
+     */
+    async discoverCommands(): Promise<Command[]> {
+        const discovered: Command[] = [];
+
+        // 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
+     */
+    private async discoverCommandsInDirectory(dir: string, type: 'personal' | 'project'): Promise<Command[]> {
+        if (!fs.existsSync(dir)) {
+            return [];
+        }
+
+        const commands: Command[] = [];
+
+        try {
+            // Find all .md files in subdirectories
+            const commandFiles = await 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: any) {
+            console.error(`Error discovering commands in ${dir}: ${error.message}`);
+        }
+
+        return commands;
+    }
+
+    /**
+     * Parse a command file
+     */
+    private async parseCommandFile(commandPath: string, type: 'personal' | 'project'): Promise<Command | null> {
+        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: 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: any) {
+            console.error(`Error parsing command ${commandPath}: ${error.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Get command name from file path
+     */
+    private getCommandName(commandPath: string, type: 'personal' | 'project'): string | null {
+        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
+     */
+    private extractFrontmatter(content: string): CommandFrontmatter {
+        const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
+        const match = content.match(frontmatterRegex);
+
+        if (!match) {
+            return {};
+        }
+
+        try {
+            const parsed = YAML.parse(match[1]) as CommandFrontmatter;
+            return parsed;
+        } catch (error) {
+            return {};
+        }
+    }
+
+    /**
+     * Extract first line of content as description
+     */
+    private extractFirstLine(content: string): string {
+        // 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: string): Command | undefined {
+        return this.commands.get(name);
+    }
+
+    /**
+     * Get all commands
+     */
+    getAllCommands(): Command[] {
+        return Array.from(this.commands.values());
+    }
+
+    /**
+     * Get commands context for system prompt injection
+     */
+    getCommandsContext(): string {
+        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: Command, args: string[]): Promise<ParsedCommand> {
+        let content = command.content;
+        const bashCommands: string[] = [];
+        const fileReferences: string[] = [];
+
+        // 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.)
+     */
+    private substitutePositionalArgs(content: string, args: string[]): string {
+        return content.replace(/\$(\d+)/g, (match, index) => {
+            const argIndex = parseInt(index) - 1;
+            return args[argIndex] || '';
+        });
+    }
+
+    /**
+     * Substitute $ARGUMENTS placeholder
+     */
+    private substituteAllArgs(content: string, args: string[]): string {
+        return content.replace(/\$ARGUMENTS/g, args.join(' '));
+    }
+
+    /**
+     * Ensure commands directories exist
+     */
+    ensureDirectoriesExist(): void {
+        if (!fs.existsSync(this.personalCommandsDir)) {
+            fs.mkdirSync(this.personalCommandsDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Get personal commands directory path
+     */
+    getPersonalCommandsDir(): string {
+        return this.personalCommandsDir;
+    }
+
+    /**
+     * Get project commands directory path
+     */
+    getProjectCommandsDir(): string {
+        return this.projectCommandsDir;
+    }
+}

package/src/commands/SlashCommandTool.ts

@@ -0,0 +1,152 @@
+/**
+ * SlashCommandTool - Tool for model-invoked custom command execution
+ * The model can call this tool when it determines a custom command should be run
+ */
+
+import { Tool } from '../tools/Tool';
+import { CommandManager } from './CommandManager';
+import { Command } from './Command';
+import * as fs from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+interface SlashCommandArgs {
+    name: string;
+    arguments?: string[];
+}
+
+export class SlashCommandTool implements Tool {
+    name = 'slash_command';
+    description = 'Execute a custom slash command. Available commands can be seen in /help. Example: slash_command({ name: "review", arguments: ["src/file.ts"] })';
+    parameters = {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'The name of the custom command to execute'
+            },
+            arguments: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Arguments to pass to the command'
+            }
+        },
+        required: ['name']
+    };
+
+    private commandManager: CommandManager;
+
+    constructor(commandManager: CommandManager) {
+        this.commandManager = commandManager;
+    }
+
+    async execute(args: SlashCommandArgs): Promise<string> {
+        const { name, arguments: cmdArgs = [] } = args;
+
+        if (!name) {
+            return 'Error: Command name is required';
+        }
+
+        const command = this.commandManager.getCommand(name);
+        if (!command) {
+            const availableCommands = this.commandManager.getAllCommands().map(c => c.name).join(', ');
+            return `Error: Command "${name}" not found. Available commands: ${availableCommands || 'none'}`;
+        }
+
+        try {
+            // Parse command and handle substitutions
+            const parsed = await this.commandManager.parseCommand(command, cmdArgs);
+            let content = parsed.content;
+
+            // Execute bash commands and collect results
+            const bashResults: string[] = [];
+            for (const bashCmd of parsed.bashCommands) {
+                try {
+                    const result = await execAsync(bashCmd);
+                    bashResults.push(`${bashCmd}\n${result.stdout}`);
+                } catch (error: any) {
+                    bashResults.push(`${bashCmd}\nError: ${error.message}`);
+                }
+            }
+
+            // Substitute bash outputs into content
+            let bashIndex = 0;
+            content = content.replace(/\[BASH_OUTPUT\]/g, () => {
+                return bashResults[bashIndex++] || '';
+            });
+
+            // Read file references
+            const fileContents: string[] = [];
+            for (const filePath of parsed.fileReferences) {
+                try {
+                    const fileContent = fs.readFileSync(filePath, 'utf-8');
+                    fileContents.push(`\n=== File: ${filePath} ===\n${fileContent}\n=== End of ${filePath} ===\n`);
+                } catch (error: any) {
+                    fileContents.push(`\n=== File: ${filePath} ===\nError: ${error.message}\n=== End of ${filePath} ===\n`);
+                }
+            }
+
+            // Substitute file references
+            let fileIndex = 0;
+            content = content.replace(/@[^\s]+/g, () => {
+                return fileContents[fileIndex++] || '';
+            });
+
+            return `# Executing: /${name}${cmdArgs.length ? ' ' + cmdArgs.join(' ') : ''}\n\n${content}`;
+        } catch (error: any) {
+            return `Error executing command "${name}": ${error.message}`;
+        }
+    }
+}
+
+/**
+ * ListCommandsTool - Tool for listing custom commands
+ */
+export class ListCommandsTool implements Tool {
+    name = 'list_commands';
+    description = 'List all available custom slash commands with their descriptions';
+    parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    private commandManager: CommandManager;
+
+    constructor(commandManager: CommandManager) {
+        this.commandManager = commandManager;
+    }
+
+    async execute(): Promise<string> {
+        const commands = this.commandManager.getAllCommands();
+
+        if (commands.length === 0) {
+            return 'No custom commands available. Add commands to ~/.mentis/commands/ or .mentis/commands/';
+        }
+
+        let response = `# Custom Commands (${commands.length})\n\n`;
+
+        // Group by namespace
+        const grouped = new Map<string, Command[]>();
+        for (const cmd of commands) {
+            const ns = cmd.description.match(/\(([^)]+)\)/)?.[1] || cmd.type;
+            if (!grouped.has(ns)) {
+                grouped.set(ns, []);
+            }
+            grouped.get(ns)!.push(cmd);
+        }
+
+        for (const [namespace, cmds] of grouped) {
+            response += `## ${namespace}\n\n`;
+            for (const cmd of cmds) {
+                const params = cmd.frontmatter['argument-hint'] ? ` ${cmd.frontmatter['argument-hint']}` : '';
+                response += `**/${cmd.name}${params}**\n`;
+                response += `${cmd.description}\n\n`;
+            }
+        }
+
+        return response;
+    }
+}

package/src/index.ts

@@ -1,15 +1,75 @@
 #!/usr/bin/env node
 import { ReplManager } from './repl/ReplManager';
 
+interface CliOptions {
+    resume: boolean;
+    yolo: boolean;
+}
+
+function parseArgs(): { command: string | null, options: CliOptions } {
+    const args = process.argv.slice(2);
+    const options: CliOptions = {
+        resume: false,
+        yolo: false
+    };
+
+    let command: string | null = null;
+
+    for (const arg of args) {
+        switch (arg) {
+            case 'update':
+                command = 'update';
+                break;
+            case '--resume':
+                options.resume = true;
+                break;
+            case '--yolo':
+                options.yolo = true;
+                break;
+            case '-h':
+            case '--help':
+                console.log(`
+Mentis CLI - AI Coding Assistant
+
+Usage:
+  mentis                    Start interactive REPL
+  mentis update             Update to latest version
+  mentis --resume           Resume last session
+  mentis --yolo             Auto-confirm mode (skip confirmations)
+
+Options:
+  --resume                  Load latest checkpoint on start
+  --yolo                    Skip all confirmation prompts
+  -h, --help                Show this help message
+
+Commands (in REPL):
+  /help                     Show all available commands
+  /resume                   Resume last session
+  /init                     Initialize project with .mentis.md
+  /skills <list|show|create|validate>  Manage Agent Skills
+  /commands <list|create|validate>     Manage Custom Commands
+`);
+                process.exit(0);
+                break;
+        }
+    }
+
+    return { command, options };
+}
+
 async function main() {
-    if (process.argv.includes('update')) {
+    const { command, options } = parseArgs();
+
+    // Handle update command
+    if (command === 'update') {
         const { UpdateManager } = require('./utils/UpdateManager');
         const updater = new UpdateManager();
         await updater.checkAndPerformUpdate(true);
         return;
     }
 
-    const repl = new ReplManager();
+    // Start REPL with options
+    const repl = new ReplManager(options);
     await repl.start();
 }