@indiccoder/mentis-cli 1.0.9 → 1.1.1

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';
@@ -28,12 +33,20 @@ import TerminalRenderer from 'marked-terminal';
 
 const HISTORY_FILE = path.join(os.homedir(), '.mentis_history');
 
+export interface CliOptions {
+    resume: boolean;
+    yolo: boolean;
+}
+
 export class ReplManager {
     private configManager: ConfigManager;
     private modelClient!: ModelClient;
     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[] = [];
@@ -41,12 +54,17 @@ export class ReplManager {
     private shell: PersistentShell;
     private currentModelName: string = 'Unknown';
     private activeSkill: string | null = null;  // Track currently active skill for allowed-tools
+    private options: CliOptions;
 
-    constructor() {
+    constructor(options: CliOptions = { resume: false, yolo: false }) {
+        this.options = options;
         this.configManager = new ConfigManager();
         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 +95,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 +113,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 +152,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;
@@ -173,6 +200,18 @@ export class ReplManager {
             cwd: process.cwd()
         });
 
+        // Auto-resume if --resume flag is set
+        if (this.options.resume) {
+            const cp = this.checkpointManager.load('latest');
+            if (cp) {
+                this.history = cp.history;
+                console.log(chalk.green(`\n✓ Resumed session from ${new Date(cp.timestamp).toLocaleString()}`));
+                console.log(chalk.dim(`  Messages: ${this.history.length}\n`));
+            } else {
+                console.log(chalk.yellow('\n⚠ No previous session found to resume.\n'));
+            }
+        }
+
         // Load History
         let commandHistory: string[] = [];
         if (fs.existsSync(HISTORY_FILE)) {
@@ -256,11 +295,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 +371,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 +388,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 +405,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 +571,23 @@ 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,
+                        this.options.yolo
+                    );
+                }
             }
         } catch (error: any) {
             spinner.stop();
@@ -1034,6 +1102,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.1 - 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.1';
 
         // Layout: Left (Status/Welcome) | Right (Tips/Activity)
         // Total width ~80 chars. 

package/src/utils/ContextVisualizer.ts

@@ -0,0 +1,105 @@
+/**
+ * ContextVisualizer - Auto context bar display
+ * Shows token usage as a colored progress bar
+ */
+
+import chalk from 'chalk';
+
+export interface ContextUsage {
+    tokens: number;
+    percentage: number;
+    maxTokens: number;
+}
+
+export class ContextVisualizer {
+    private maxTokens: number = 128000; // Default context window
+
+    constructor(maxTokens?: number) {
+        if (maxTokens) {
+            this.maxTokens = maxTokens;
+        }
+    }
+
+    /**
+     * Calculate approximate token count from text
+     * Rough estimate: ~4 characters per token
+     */
+    private estimateTokens(text: string): number {
+        if (!text) return 0;
+        // Rough estimation: ~4 characters per token for English text
+        return Math.ceil(text.length / 4);
+    }
+
+    /**
+     * Calculate total tokens from message history
+     */
+    calculateUsage(history: any[]): ContextUsage {
+        let totalChars = 0;
+
+        for (const msg of history) {
+            if (msg.content) {
+                totalChars += msg.content.length;
+            }
+            if (msg.tool_calls) {
+                totalChars += JSON.stringify(msg.tool_calls).length;
+            }
+        }
+
+        // Add overhead for system prompt, skills, etc.
+        totalChars += 2000;
+
+        // Rough estimation: ~4 characters per token
+        const tokens = Math.ceil(totalChars / 4);
+        const percentage = Math.min(100, Math.round((tokens / this.maxTokens) * 100));
+
+        return { tokens, percentage, maxTokens: this.maxTokens };
+    }
+
+    /**
+     * Format the context bar for display
+     */
+    formatBar(usage: ContextUsage): string {
+        const { percentage, tokens, maxTokens } = usage;
+
+        // Create progress bar (20 chars wide)
+        const filled = Math.round(percentage / 5);
+        const empty = 20 - filled;
+
+        let bar: string;
+        if (percentage < 60) {
+            bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+        } else if (percentage < 80) {
+            bar = chalk.yellow('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+        } else {
+            bar = chalk.red('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+        }
+
+        const tokensK = Math.round(tokens / 1000);
+        const maxTokensK = Math.round(maxTokens / 1000);
+
+        return `${bar} ${percentage}% | ${tokensK}k/${maxTokensK} tokens`;
+    }
+
+    /**
+     * Get the context bar string for current history
+     */
+    getContextBar(history: any[]): string {
+        const usage = this.calculateUsage(history);
+        return this.formatBar(usage);
+    }
+
+    /**
+     * Check if context is at warning threshold (>=80%)
+     */
+    shouldCompact(history: any[]): boolean {
+        const usage = this.calculateUsage(history);
+        return usage.percentage >= 80;
+    }
+
+    /**
+     * Set custom max tokens (for different models)
+     */
+    setMaxTokens(max: number): void {
+        this.maxTokens = max;
+    }
+}

package/src/utils/ConversationCompacter.ts

@@ -0,0 +1,128 @@
+/**
+ * ConversationCompacter - Compact conversation to save tokens
+ * Summarizes conversation history while preserving important context
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { ModelClient, ChatMessage } from '../llm/ModelInterface';
+
+export class ConversationCompacter {
+    /**
+     * Compact conversation history using AI
+     */
+    async compact(
+        history: ChatMessage[],
+        modelClient: ModelClient,
+        options?: {
+            keepSystemMessages?: boolean;
+            focusTopic?: string;
+        }
+    ): Promise<ChatMessage[]> {
+        const { keepSystemMessages = true, focusTopic } = options || {};
+
+        // Preserve system-style messages
+        const preserved: ChatMessage[] = [];
+        const toCompact: ChatMessage[] = [];
+
+        for (const msg of history) {
+            if (msg.role === 'system' || msg.role === 'tool') {
+                preserved.push(msg);
+            } else {
+                toCompact.push(msg);
+            }
+        }
+
+        if (toCompact.length === 0) {
+            return history;
+        }
+
+        // Create compaction prompt
+        let compactPrompt = 'Please summarize the following conversation into a concise overview. ';
+        compactPrompt += 'Include:\n';
+        compactPrompt += '- The main topic/problem being discussed\n';
+        compactPrompt += '- Key decisions made\n';
+        compactPrompt += '- Important technical details\n';
+        compactPrompt += '- Current status/next steps\n\n';
+
+        if (focusTopic) {
+            compactPrompt += `Focus primarily on content related to: ${focusTopic}\n\n`;
+        }
+
+        compactPrompt += 'Return ONLY the summary, no other text.\n\n---\n\n';
+
+        for (const msg of toCompact.slice(-10)) { // Last 10 messages for context
+            compactPrompt += `${msg.role.toUpperCase()}: ${msg.content}\n\n`;
+        }
+
+        try {
+            // Call AI to summarize
+            const summaryResponse = await modelClient.chat(
+                [{ role: 'user', content: compactPrompt }],
+                []
+            );
+
+            const summary = summaryResponse.content;
+
+            // Create new compacted history
+            const newHistory: ChatMessage[] = [...preserved];
+
+            // Add summary as a system message for context
+            newHistory.push({
+                role: 'system',
+                content: `[Previous Conversation Summary]\n${summary}`
+            });
+
+            return newHistory;
+        } catch (error) {
+            console.error('Compaction failed:', error);
+            return history; // Return original if compaction fails
+        }
+    }
+
+    /**
+     * Prompt user to compact when threshold is reached
+     */
+    async promptIfCompactNeeded(
+        percentage: number,
+        history: ChatMessage[],
+        modelClient: ModelClient,
+        yolo: boolean = false
+    ): Promise<ChatMessage[]> {
+        if (percentage < 80) {
+            return history;
+        }
+
+        console.log(chalk.yellow(`\n⚠️  Context is ${percentage}% full. Consider compacting to save tokens.`));
+
+        // Skip confirmation if yolo mode is enabled
+        if (!yolo) {
+            const { shouldCompact } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'shouldCompact',
+                    message: 'Compact conversation now?',
+                    default: true
+                }
+            ]);
+
+            if (!shouldCompact) {
+                return history;
+            }
+        }
+
+        const focusTopic = yolo ? '' : await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'focusTopic',
+                message: 'Focus on specific topic? (leave empty for general)',
+                default: ''
+            }
+        ]).then(a => a.focusTopic);
+
+        return await this.compact(history, modelClient, {
+            keepSystemMessages: true,
+            focusTopic: focusTopic || undefined
+        });
+    }
+}

package/src/utils/ProjectInitializer.ts

@@ -0,0 +1,170 @@
+/**
+ * ProjectInitializer - Initialize project with .mentis.md
+ * Interactive wizard for creating project guide files
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export class ProjectInitializer {
+    /**
+     * Run the interactive project initialization wizard
+     */
+    async run(cwd: string = process.cwd()): Promise<boolean> {
+        console.log('\n📁 Initialize Project with .mentis.md\n');
+
+        // Step 1: Project name
+        const { projectName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: path.basename(cwd)
+            }
+        ]);
+
+        // Step 2: Project description
+        const { description } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Brief description:',
+                default: 'A software project'
+            }
+        ]);
+
+        // Step 3: Tech stack
+        const { techStack } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'techStack',
+                message: 'Select technologies:',
+                choices: [
+                    'TypeScript',
+                    'JavaScript',
+                    'Python',
+                    'React',
+                    'Vue',
+                    'Node.js',
+                    'Express',
+                    'PostgreSQL',
+                    'MongoDB',
+                    'Redis',
+                    'Docker',
+                    'GraphQL',
+                    'REST API',
+                    'Other'
+                ]
+            }
+        ]);
+
+        // Step 4: Project type
+        const { projectType } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'projectType',
+                message: 'Project type:',
+                choices: ['Web Application', 'API/Backend', 'CLI Tool', 'Library/Package', 'Mobile App', 'Desktop App', 'Other']
+            }
+        ]);
+
+        // Step 5: Conventions
+        const { useConventions } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'useConventions',
+                message: 'Add coding conventions?',
+                default: true
+            }
+        ]);
+
+        let conventions = '';
+        if (useConventions) {
+            const { conventionStyle } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'conventionStyle',
+                    message: 'Style guide:',
+                    choices: ['Standard', 'Airbnb', 'Google', 'Prettier', 'Custom']
+                }
+            ]);
+
+            conventions = this.getConventionText(conventionStyle);
+        }
+
+        // Create .mentis.md content
+        const content = this.generateMentisMd({
+            projectName,
+            description,
+            techStack,
+            projectType,
+            conventions
+        });
+
+        // Write to file
+        const mentisMdPath = path.join(cwd, '.mentis.md');
+        fs.writeFileSync(mentisMdPath, content, 'utf-8');
+
+        console.log(chalk.green(`\n✓ Created .mentis.md`));
+        console.log(chalk.dim(`\nTip: Edit .mentis.md to add project-specific instructions for Mentis.\n`));
+
+        return true;
+    }
+
+    /**
+     * Generate .mentis.md content
+     */
+    private generateMentisMd(options: {
+        projectName: string;
+        description: string;
+        techStack: string[];
+        projectType: string;
+        conventions: string;
+    }): string {
+        const { projectName, description, techStack, projectType, conventions } = options;
+
+        let content = `# ${projectName}\n\n`;
+        content += `${description}\n\n`;
+        content += `**Type**: ${projectType}\n\n`;
+        content += `## Tech Stack\n\n`;
+        content += techStack.map(t => `- ${t}`).join('\n');
+        content += `\n\n`;
+
+        if (conventions) {
+            content += `## Coding Conventions\n\n`;
+            content += `${conventions}\n\n`;
+        }
+
+        content += `## Project Structure\n\n`;
+        content += `<!-- Add project structure here -->\n\n`;
+
+        content += `## Guidelines for Mentis\n\n`;
+        content += `- When writing code, follow the conventions above\n`;
+        content += `- Prefer existing patterns in the codebase\n`;
+        content += `- Add comments for complex logic\n`;
+        content += `- Run tests before suggesting changes\n\n`;
+
+        content += `## Common Commands\n\n`;
+        content += `<!-- Add common development commands here -->\n`;
+
+        return content;
+    }
+
+    /**
+     * Get convention text based on style
+     */
+    private getConventionText(style: string): string {
+        const conventions: Record<string, string> = {
+            'Standard': `- Use 2 spaces for indentation\n- Use camelCase for variables\n- Use PascalCase for classes\n- Prefer const over let\n- Use arrow functions`,
+            'Airbnb': `- Follow Airbnb Style Guide\n- Use 2 spaces for indentation\n- Prefer named exports\n- Use template literals`,
+            'Google': `- Follow Google JavaScript Style Guide\n- Use 2 spaces for indentation\n- JSDoc comments for functions`,
+            'Prettier': `- Use Prettier for formatting\n- 2 spaces for indentation\n- Single quotes for strings\n- No trailing commas`,
+            'Custom': `- Define your conventions below`
+        };
+
+        return conventions[style] || conventions['Standard'];
+    }
+}