@indiccoder/mentis-cli 1.0.9 → 1.1.0

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/repl/ReplManager.ts

@@ -19,6 +19,11 @@ import { McpClient } from '../mcp/McpClient';
 import { CheckpointManager } from '../checkpoint/CheckpointManager';
 import { SkillsManager } from '../skills/SkillsManager';
 import { LoadSkillTool, ListSkillsTool, ReadSkillFileTool } from '../skills/LoadSkillTool';
+import { ContextVisualizer } from '../utils/ContextVisualizer';
+import { ProjectInitializer } from '../utils/ProjectInitializer';
+import { ConversationCompacter } from '../utils/ConversationCompacter';
+import { CommandManager } from '../commands/CommandManager';
+import { SlashCommandTool, ListCommandsTool } from '../commands/SlashCommandTool';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -34,6 +39,9 @@ export class ReplManager {
     private contextManager: ContextManager;
     private checkpointManager: CheckpointManager;
     private skillsManager: SkillsManager;
+    private contextVisualizer: ContextVisualizer;
+    private conversationCompacter: ConversationCompacter;
+    private commandManager: CommandManager;
     private history: ChatMessage[] = [];
     private mode: 'PLAN' | 'BUILD' = 'BUILD';
     private tools: Tool[] = [];
@@ -47,6 +55,9 @@ export class ReplManager {
         this.contextManager = new ContextManager();
         this.checkpointManager = new CheckpointManager();
         this.skillsManager = new SkillsManager();
+        this.contextVisualizer = new ContextVisualizer();
+        this.conversationCompacter = new ConversationCompacter();
+        this.commandManager = new CommandManager();
         this.shell = new PersistentShell();
 
         // Create tools array without skill tools first
@@ -77,12 +88,17 @@ export class ReplManager {
     }
 
     /**
-     * Initialize the skills system
+     * Initialize the skills and custom commands system
      */
     private async initializeSkills() {
+        // Initialize skills
         this.skillsManager.ensureDirectoriesExist();
         await this.skillsManager.discoverSkills();
 
+        // Initialize custom commands
+        this.commandManager.ensureDirectoriesExist();
+        await this.commandManager.discoverCommands();
+
         // Add skill tools to the tools list
         // Pass callback to LoadSkillTool to track active skill
         this.tools.push(
@@ -90,7 +106,9 @@ export class ReplManager {
                 this.activeSkill = skill ? skill.name : null;
             }),
             new ListSkillsTool(this.skillsManager),
-            new ReadSkillFileTool(this.skillsManager)
+            new ReadSkillFileTool(this.skillsManager),
+            new SlashCommandTool(this.commandManager),
+            new ListCommandsTool(this.commandManager)
         );
     }
 
@@ -127,7 +145,9 @@ export class ReplManager {
             'git_pull': 'GitPull',
             'load_skill': 'Read',
             'list_skills': 'Read',
-            'read_skill_file': 'Read'
+            'read_skill_file': 'Read',
+            'slash_command': 'Read',
+            'list_commands': 'Read'
         };
 
         const mappedToolName = toolMapping[toolName] || toolName;
@@ -256,11 +276,13 @@ export class ReplManager {
                 console.log('  /use <provider> [model] - Quick switch (legacy)');
                 console.log('  /mcp <cmd> - Manage MCP servers');
                 console.log('  /skills <list|show|create|validate> - Manage Agent Skills');
+                console.log('  /commands <list|create|validate> - Manage Custom Commands');
                 console.log('  /resume  - Resume last session');
                 console.log('  /checkpoint <save|load|list> [name] - Manage checkpoints');
                 console.log('  /search <query> - Search codebase');
                 console.log('  /run <cmd> - Run shell command');
                 console.log('  /commit [msg] - Git commit all changes');
+                console.log('  /init    - Initialize project with .mentis.md');
                 break;
             case '/plan':
                 this.mode = 'PLAN';
@@ -330,9 +352,15 @@ export class ReplManager {
                 const updater = new UpdateManager();
                 await updater.checkAndPerformUpdate(true);
                 break;
+            case '/init':
+                await this.handleInitCommand();
+                break;
             case '/skills':
                 await this.handleSkillsCommand(args);
                 break;
+            case '/commands':
+                await this.handleCommandsCommand(args);
+                break;
             default:
                 console.log(chalk.red(`Unknown command: ${command}`));
         }
@@ -341,6 +369,7 @@ export class ReplManager {
     private async handleChat(input: string) {
         const context = this.contextManager.getContextString();
         const skillsContext = this.skillsManager.getSkillsContext();
+        const commandsContext = this.commandManager.getCommandsContext();
         let fullInput = input;
 
         let modeInstruction = '';
@@ -357,6 +386,11 @@ export class ReplManager {
             fullInput = `${skillsContext}\n\n${fullInput}`;
         }
 
+        // Add commands context if available
+        if (commandsContext) {
+            fullInput = `${commandsContext}\n\n${fullInput}`;
+        }
+
         if (context) {
             fullInput = `${context}\n\nUser Question: ${fullInput}`;
         }
@@ -518,8 +552,22 @@ export class ReplManager {
                     console.log(chalk.dim(`\n(Tokens: ${input_tokens} in / ${output_tokens} out | Est. Cost: $${totalCost.toFixed(5)})`));
                 }
 
+                // Display context bar
+                const contextBar = this.contextVisualizer.getContextBar(this.history);
+                console.log(chalk.dim(`\n${contextBar}`));
+
                 console.log('');
                 this.history.push({ role: 'assistant', content: response.content });
+
+                // Auto-compact prompt when context is at 80%
+                const usage = this.contextVisualizer.calculateUsage(this.history);
+                if (usage.percentage >= 80) {
+                    this.history = await this.conversationCompacter.promptIfCompactNeeded(
+                        usage.percentage,
+                        this.history,
+                        this.modelClient
+                    );
+                }
             }
         } catch (error: any) {
             spinner.stop();
@@ -1034,6 +1082,86 @@ export class ReplManager {
         }
     }
 
+    private async handleInitCommand(): Promise<void> {
+        const initializer = new ProjectInitializer();
+        await initializer.run();
+    }
+
+    private async handleCommandsCommand(args: string[]) {
+        if (args.length < 1) {
+            // Show commands list by default
+            await this.handleCommandsCommand(['list']);
+            return;
+        }
+
+        const action = args[0];
+
+        switch (action) {
+            case 'list':
+                await this.handleCommandsList();
+                break;
+            case 'create':
+                await this.handleCommandsCreate(args[1]);
+                break;
+            case 'validate':
+                await this.handleCommandsValidate();
+                break;
+            default:
+                console.log(chalk.red(`Unknown commands action: ${action}`));
+                console.log(chalk.yellow('Available actions: list, create, validate'));
+        }
+    }
+
+    private async handleCommandsList(): Promise<void> {
+        const commands = this.commandManager.getAllCommands();
+
+        if (commands.length === 0) {
+            console.log(chalk.yellow('No custom commands available.'));
+            console.log(chalk.dim('Create commands with: /commands create'));
+            console.log(chalk.dim('Add commands to: ~/.mentis/commands/ or .mentis/commands/'));
+            return;
+        }
+
+        console.log(chalk.cyan(`\nCustom Commands (${commands.length}):\n`));
+
+        // Group by namespace
+        const grouped = new Map<string, any[]>();
+        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) {
+            console.log(chalk.bold(`\n${namespace}`));
+            for (const cmd of cmds) {
+                const params = cmd.frontmatter['argument-hint'] ? ` ${cmd.frontmatter['argument-hint']}` : '';
+                console.log(`  /${cmd.name}${params}`);
+                console.log(`    ${cmd.description.replace(/\s*\([^)]+\)/, '')}`);
+
+                if (cmd.frontmatter['allowed-tools'] && cmd.frontmatter['allowed-tools'].length > 0) {
+                    console.log(chalk.dim(`    Allowed tools: ${cmd.frontmatter['allowed-tools'].join(', ')}`));
+                }
+            }
+        }
+        console.log('');
+    }
+
+    private async handleCommandsCreate(name?: string): Promise<void> {
+        const { CommandCreator } = await import('../commands/CommandCreator');
+        const creator = new CommandCreator(this.commandManager);
+        await creator.run(name);
+        // Re-discover commands after creation
+        await this.commandManager.discoverCommands();
+    }
+
+    private async handleCommandsValidate(): Promise<void> {
+        const { validateCommands } = await import('../commands/CommandCreator');
+        await validateCommands(this.commandManager);
+    }
+
     private estimateCost(input: number, output: number): number {
         const config = this.configManager.getConfig();
         const provider = config.defaultProvider;

package/src/ui/UIManager.ts

@@ -14,13 +14,13 @@ export class UIManager {
             whitespaceBreak: true,
         });
         console.log(gradient.pastel.multiline(logoText));
-        console.log(chalk.gray('  v1.0.5 - AI Coding Agent'));
+        console.log(chalk.gray('  v1.1.0 - AI Coding Agent'));
         console.log('');
     }
 
     public static renderDashboard(config: { model: string, mode: string, cwd: string }) {
         const { model, cwd } = config;
-        const version = 'v1.0.8';
+        const version = 'v1.1.0';
 
         // Layout: Left (Status/Welcome) | Right (Tips/Activity)
         // Total width ~80 chars.