@indiccoder/mentis-cli 1.0.9 → 1.1.1

package/dist/commands/SlashCommandTool.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * SlashCommandTool - Tool for model-invoked custom command execution
+ * The model can call this tool when it determines a custom command should be run
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCommandsTool = exports.SlashCommandTool = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SlashCommandTool {
+    constructor(commandManager) {
+        this.name = 'slash_command';
+        this.description = 'Execute a custom slash command. Available commands can be seen in /help. Example: slash_command({ name: "review", arguments: ["src/file.ts"] })';
+        this.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']
+        };
+        this.commandManager = commandManager;
+    }
+    async execute(args) {
+        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 = [];
+            for (const bashCmd of parsed.bashCommands) {
+                try {
+                    const result = await execAsync(bashCmd);
+                    bashResults.push(`${bashCmd}\n${result.stdout}`);
+                }
+                catch (error) {
+                    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 = [];
+            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) {
+                    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) {
+            return `Error executing command "${name}": ${error.message}`;
+        }
+    }
+}
+exports.SlashCommandTool = SlashCommandTool;
+/**
+ * ListCommandsTool - Tool for listing custom commands
+ */
+class ListCommandsTool {
+    constructor(commandManager) {
+        this.name = 'list_commands';
+        this.description = 'List all available custom slash commands with their descriptions';
+        this.parameters = {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+        this.commandManager = commandManager;
+    }
+    async execute() {
+        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();
+        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;
+    }
+}
+exports.ListCommandsTool = ListCommandsTool;

package/dist/index.js

@@ -2,14 +2,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ReplManager_1 = require("./repl/ReplManager");
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const options = {
+        resume: false,
+        yolo: false
+    };
+    let command = 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_1.ReplManager();
+    // Start REPL with options
+    const repl = new ReplManager_1.ReplManager(options);
     await repl.start();
 }
 main().catch((error) => {

package/dist/repl/ReplManager.js

@@ -54,6 +54,11 @@ const McpClient_1 = require("../mcp/McpClient");
 const CheckpointManager_1 = require("../checkpoint/CheckpointManager");
 const SkillsManager_1 = require("../skills/SkillsManager");
 const LoadSkillTool_1 = require("../skills/LoadSkillTool");
+const ContextVisualizer_1 = require("../utils/ContextVisualizer");
+const ProjectInitializer_1 = require("../utils/ProjectInitializer");
+const ConversationCompacter_1 = require("../utils/ConversationCompacter");
+const CommandManager_1 = require("../commands/CommandManager");
+const SlashCommandTool_1 = require("../commands/SlashCommandTool");
 const readline = __importStar(require("readline"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -62,17 +67,21 @@ const marked_1 = require("marked");
 const marked_terminal_1 = __importDefault(require("marked-terminal"));
 const HISTORY_FILE = path.join(os.homedir(), '.mentis_history');
 class ReplManager {
-    constructor() {
+    constructor(options = { resume: false, yolo: false }) {
         this.history = [];
         this.mode = 'BUILD';
         this.tools = [];
         this.mcpClients = [];
         this.currentModelName = 'Unknown';
         this.activeSkill = null; // Track currently active skill for allowed-tools
+        this.options = options;
         this.configManager = new ConfigManager_1.ConfigManager();
         this.contextManager = new ContextManager_1.ContextManager();
         this.checkpointManager = new CheckpointManager_1.CheckpointManager();
         this.skillsManager = new SkillsManager_1.SkillsManager();
+        this.contextVisualizer = new ContextVisualizer_1.ContextVisualizer();
+        this.conversationCompacter = new ConversationCompacter_1.ConversationCompacter();
+        this.commandManager = new CommandManager_1.CommandManager();
         this.shell = new PersistentShell_1.PersistentShell();
         // Create tools array without skill tools first
         this.tools = [
@@ -99,16 +108,20 @@ class ReplManager {
         this.initializeSkills();
     }
     /**
-     * Initialize the skills system
+     * Initialize the skills and custom commands system
      */
     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(new LoadSkillTool_1.LoadSkillTool(this.skillsManager, (skill) => {
             this.activeSkill = skill ? skill.name : null;
-        }), new LoadSkillTool_1.ListSkillsTool(this.skillsManager), new LoadSkillTool_1.ReadSkillFileTool(this.skillsManager));
+        }), new LoadSkillTool_1.ListSkillsTool(this.skillsManager), new LoadSkillTool_1.ReadSkillFileTool(this.skillsManager), new SlashCommandTool_1.SlashCommandTool(this.commandManager), new SlashCommandTool_1.ListCommandsTool(this.commandManager));
     }
     /**
      * Check if a tool is allowed by the currently active skill
@@ -141,7 +154,9 @@ 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;
         return skill.allowedTools.includes(mappedToolName);
@@ -183,6 +198,18 @@ class ReplManager {
             mode: this.mode,
             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_1.default.green(`\n✓ Resumed session from ${new Date(cp.timestamp).toLocaleString()}`));
+                console.log(chalk_1.default.dim(`  Messages: ${this.history.length}\n`));
+            }
+            else {
+                console.log(chalk_1.default.yellow('\n⚠ No previous session found to resume.\n'));
+            }
+        }
         // Load History
         let commandHistory = [];
         if (fs.existsSync(HISTORY_FILE)) {
@@ -256,11 +283,13 @@ 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';
@@ -332,9 +361,15 @@ 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_1.default.red(`Unknown command: ${command}`));
         }
@@ -342,6 +377,7 @@ class ReplManager {
     async handleChat(input) {
         const context = this.contextManager.getContextString();
         const skillsContext = this.skillsManager.getSkillsContext();
+        const commandsContext = this.commandManager.getCommandsContext();
         let fullInput = input;
         let modeInstruction = '';
         if (this.mode === 'PLAN') {
@@ -355,6 +391,10 @@ class ReplManager {
         if (skillsContext) {
             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}`;
         }
@@ -494,8 +534,16 @@ class ReplManager {
                     const totalCost = this.estimateCost(input_tokens, output_tokens);
                     console.log(chalk_1.default.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_1.default.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) {
@@ -966,6 +1014,74 @@ class ReplManager {
             console.log(chalk_1.default.dim(`\nSupporting files: ${files.join(', ')}`));
         }
     }
+    async handleInitCommand() {
+        const initializer = new ProjectInitializer_1.ProjectInitializer();
+        await initializer.run();
+    }
+    async handleCommandsCommand(args) {
+        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_1.default.red(`Unknown commands action: ${action}`));
+                console.log(chalk_1.default.yellow('Available actions: list, create, validate'));
+        }
+    }
+    async handleCommandsList() {
+        const commands = this.commandManager.getAllCommands();
+        if (commands.length === 0) {
+            console.log(chalk_1.default.yellow('No custom commands available.'));
+            console.log(chalk_1.default.dim('Create commands with: /commands create'));
+            console.log(chalk_1.default.dim('Add commands to: ~/.mentis/commands/ or .mentis/commands/'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`\nCustom Commands (${commands.length}):\n`));
+        // Group by namespace
+        const grouped = new Map();
+        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_1.default.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_1.default.dim(`    Allowed tools: ${cmd.frontmatter['allowed-tools'].join(', ')}`));
+                }
+            }
+        }
+        console.log('');
+    }
+    async handleCommandsCreate(name) {
+        const { CommandCreator } = await Promise.resolve().then(() => __importStar(require('../commands/CommandCreator')));
+        const creator = new CommandCreator(this.commandManager);
+        await creator.run(name);
+        // Re-discover commands after creation
+        await this.commandManager.discoverCommands();
+    }
+    async handleCommandsValidate() {
+        const { validateCommands } = await Promise.resolve().then(() => __importStar(require('../commands/CommandCreator')));
+        await validateCommands(this.commandManager);
+    }
     estimateCost(input, output) {
         const config = this.configManager.getConfig();
         const provider = config.defaultProvider;

package/dist/ui/UIManager.js

@@ -19,12 +19,12 @@ class UIManager {
             whitespaceBreak: true,
         });
         console.log(gradient_string_1.default.pastel.multiline(logoText));
-        console.log(chalk_1.default.gray('  v1.0.5 - AI Coding Agent'));
+        console.log(chalk_1.default.gray('  v1.1.1 - AI Coding Agent'));
         console.log('');
     }
     static renderDashboard(config) {
         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. 
         // Left ~45, Right ~30.

package/dist/utils/ContextVisualizer.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * ContextVisualizer - Auto context bar display
+ * Shows token usage as a colored progress bar
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextVisualizer = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class ContextVisualizer {
+    constructor(maxTokens) {
+        this.maxTokens = 128000; // Default context window
+        if (maxTokens) {
+            this.maxTokens = maxTokens;
+        }
+    }
+    /**
+     * Calculate approximate token count from text
+     * Rough estimate: ~4 characters per token
+     */
+    estimateTokens(text) {
+        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) {
+        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) {
+        const { percentage, tokens, maxTokens } = usage;
+        // Create progress bar (20 chars wide)
+        const filled = Math.round(percentage / 5);
+        const empty = 20 - filled;
+        let bar;
+        if (percentage < 60) {
+            bar = chalk_1.default.green('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+        }
+        else if (percentage < 80) {
+            bar = chalk_1.default.yellow('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+        }
+        else {
+            bar = chalk_1.default.red('█'.repeat(filled)) + chalk_1.default.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) {
+        const usage = this.calculateUsage(history);
+        return this.formatBar(usage);
+    }
+    /**
+     * Check if context is at warning threshold (>=80%)
+     */
+    shouldCompact(history) {
+        const usage = this.calculateUsage(history);
+        return usage.percentage >= 80;
+    }
+    /**
+     * Set custom max tokens (for different models)
+     */
+    setMaxTokens(max) {
+        this.maxTokens = max;
+    }
+}
+exports.ContextVisualizer = ContextVisualizer;

package/dist/utils/ConversationCompacter.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * ConversationCompacter - Compact conversation to save tokens
+ * Summarizes conversation history while preserving important context
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompacter = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+class ConversationCompacter {
+    /**
+     * Compact conversation history using AI
+     */
+    async compact(history, modelClient, options) {
+        const { keepSystemMessages = true, focusTopic } = options || {};
+        // Preserve system-style messages
+        const preserved = [];
+        const toCompact = [];
+        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 = [...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, history, modelClient, yolo = false) {
+        if (percentage < 80) {
+            return history;
+        }
+        console.log(chalk_1.default.yellow(`\n⚠️  Context is ${percentage}% full. Consider compacting to save tokens.`));
+        // Skip confirmation if yolo mode is enabled
+        if (!yolo) {
+            const { shouldCompact } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'shouldCompact',
+                    message: 'Compact conversation now?',
+                    default: true
+                }
+            ]);
+            if (!shouldCompact) {
+                return history;
+            }
+        }
+        const focusTopic = yolo ? '' : await inquirer_1.default.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
+        });
+    }
+}
+exports.ConversationCompacter = ConversationCompacter;