@indiccoder/mentis-cli 1.0.9 → 1.1.0

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,124 @@
+/**
+ * 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
+    ): Promise<ChatMessage[]> {
+        if (percentage < 80) {
+            return history;
+        }
+
+        console.log(chalk.yellow(`\n⚠️  Context is ${percentage}% full. Consider compacting to save tokens.`));
+
+        const { shouldCompact } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldCompact',
+                message: 'Compact conversation now?',
+                default: true
+            }
+        ]);
+
+        if (!shouldCompact) {
+            return history;
+        }
+
+        const { focusTopic } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'focusTopic',
+                message: 'Focus on specific topic? (leave empty for general)',
+                default: ''
+            }
+        ]);
+
+        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'];
+    }
+}