@majkapp/majk-chat-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,1001 @@
+#!/usr/bin/env node
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("yaml"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const majk_chat_core_1 = require("@majkapp/majk-chat-core");
+const interactive_1 = require("./interactive/interactive");
+const credentials_1 = require("./utils/credentials");
+const config_1 = require("./utils/config");
+const bash_tool_1 = require("./tools/bash.tool");
+const filesystem_tool_1 = require("./tools/filesystem.tool");
+const majk_chat_mcp_1 = require("@majkapp/majk-chat-mcp");
+const majk_chat_basic_tools_1 = require("@majkapp/majk-chat-basic-tools");
+const majk_chat_sessions_1 = require("@majkapp/majk-chat-sessions");
+const models_1 = require("./utils/models");
+const tool_filter_1 = require("./utils/tool-filter");
+const output_1 = require("./utils/output");
+// Load environment variables
+dotenv_1.default.config();
+const program = new commander_1.Command();
+program
+    .name('majk-chat')
+    .description('CLI for multi-provider LLM chat interactions')
+    .version('1.0.0');
+// Add credential options helper function
+function addCredentialOptions(command) {
+    return command
+        // Generic credentials
+        .option('--api-key <key>', 'Generic API key (overrides environment)')
+        .option('--api-key-file <file>', 'Read API key from file')
+        .option('--env-file <file>', 'Load environment variables from file')
+        // OpenAI specific
+        .option('--openai-api-key <key>', 'OpenAI API key')
+        .option('--openai-org-id <id>', 'OpenAI organization ID')
+        // Anthropic specific
+        .option('--anthropic-api-key <key>', 'Anthropic API key')
+        // Azure OpenAI specific
+        .option('--azure-openai-api-key <key>', 'Azure OpenAI API key')
+        .option('--azure-openai-endpoint <url>', 'Azure OpenAI endpoint URL')
+        .option('--azure-openai-deployment <name>', 'Azure OpenAI deployment name')
+        // AWS Bedrock specific
+        .option('--aws-access-key-id <id>', 'AWS access key ID')
+        .option('--aws-secret-access-key <key>', 'AWS secret access key')
+        .option('--aws-session-token <token>', 'AWS session token')
+        .option('--aws-region <region>', 'AWS region');
+}
+// Chat command
+const chatCommand = program
+    .command('chat')
+    .description('Send a chat message to an LLM provider')
+    .option('--provider <provider>', 'Provider to use (openai, anthropic, azure-openai, bedrock)')
+    .option('--model <model>', 'Model or alias (e.g., "sonnet", "opus", "claude-3-5-sonnet-20241022")')
+    .option('-M, --message <message>', 'Message to send')
+    .option('-p <value>', 'JSON messages array or prompt string')
+    .option('-f, --file <file>', 'Read message from file')
+    .option('--prompts <file>', 'File with one prompt per line (sequential execution)')
+    .option('-s, --system <system>', 'System message')
+    .option('-S, --system-file <file>', 'Read system message from file')
+    .option('--append-system-prompt <prompt>', 'Append to the default system prompt')
+    .option('-t, --temperature <temp>', 'Temperature (0-2)', parseFloat)
+    .option('--max-tokens <tokens>', 'Maximum tokens', parseInt)
+    .option('-j, --json', 'Output JSON response')
+    .option('--output-format <format>', 'Output format: "text" (default) or "stream-json"', 'text')
+    .option('--tools', 'Enable tool execution')
+    .option('--enable-core-tools', 'Enable majk-chat-basic-tools (bash, ls, read, etc.)')
+    .option('--tool-result-limit <limit>', 'Truncate tool results over this character limit', parseInt, 8000)
+    .option('--max-steps <steps>', 'Maximum tool execution steps', parseInt)
+    .option('-c, --config <file>', 'Configuration file')
+    .option('--mcp-config <value>', 'MCP configuration file path or JSON string')
+    .option('--mcp-servers <json>', 'MCP servers configuration as JSON string (deprecated, use --mcp-config)')
+    .option('--allowed-tools, --allowedTools <tools>', 'Comma/space-separated allowed tools (supports wildcards like "mcp__*")')
+    .option('--disallowed-tools, --disallowedTools <tools>', 'Comma/space-separated disallowed tools (supports wildcards)')
+    .option('--permission-prompt-tool <tool>', 'MCP tool to use for permission prompts')
+    .option('--save-session', 'Save conversation to a persistent session')
+    .option('--continue', 'Continue the most recent session in current directory')
+    .option('--session <uuid>', 'Continue a specific session by UUID')
+    .option('--session-title <title>', 'Set title for new session')
+    .option('--list-sessions', 'List all sessions for current directory')
+    .option('--delete-session <uuid>', 'Delete a specific session by UUID');
+addCredentialOptions(chatCommand)
+    .action(async (options) => {
+    let cleanup = null;
+    try {
+        // Initialize output handler early so we can pass callbacks
+        const outputHandler = new output_1.OutputHandler(options.outputFormat);
+        const setupOptions = {
+            ...options,
+            outputFormat: options.outputFormat, // Pass output format to suppress logs
+            onToolCall: options.outputFormat === 'stream-json'
+                ? (toolCall) => outputHandler.outputToolCallMessage(toolCall)
+                : undefined,
+            onToolResult: options.outputFormat === 'stream-json'
+                ? (toolCall, result) => outputHandler.outputToolResult(toolCall.id, result)
+                : undefined
+        };
+        const setupResult = await setupChat(setupOptions);
+        const { chat, toolRegistry } = setupResult;
+        cleanup = setupResult.cleanup;
+        // Resolve model alias if provided
+        const model = options.model
+            ? (0, models_1.resolveModel)(options.model)
+            : (0, models_1.getDefaultModelForProvider)(options.provider);
+        // Get tool definitions from registry
+        const tools = toolRegistry.getDefinitions();
+        const toolNames = tools.map((t) => t.function.name);
+        // Update output handler with model and tool info
+        outputHandler.options.model = model;
+        outputHandler.options.tools = toolNames;
+        outputHandler.options.cwd = process.cwd();
+        // Initialize session manager and handle session operations
+        const currentWorkingDir = process.cwd();
+        const usesSessions = options.saveSession || options.continue || options.session || options.listSessions || options.deleteSession;
+        let sessionManager = null;
+        let existingMessages = [];
+        let sessionId = null;
+        if (usesSessions) {
+            sessionManager = new majk_chat_sessions_1.SessionManager();
+            // Handle session operations first
+            if (options.listSessions) {
+                await handleListSessions(sessionManager, currentWorkingDir, outputHandler);
+                await cleanup();
+                process.exit(0);
+                return;
+            }
+            if (options.deleteSession) {
+                await handleDeleteSession(sessionManager, currentWorkingDir, options.deleteSession, outputHandler);
+                await cleanup();
+                process.exit(0);
+                return;
+            }
+            // Load existing session if requested
+            if (options.continue) {
+                const sessionData = await sessionManager.continueLatestSession(currentWorkingDir);
+                if (sessionData) {
+                    existingMessages = sessionData.messages;
+                    sessionId = sessionData.metadata.id;
+                    if (options.outputFormat !== 'stream-json') {
+                        console.log(chalk_1.default.cyan(`Continuing session: ${sessionId}${sessionData.metadata.title ? ` (${sessionData.metadata.title})` : ''}`));
+                    }
+                }
+                else if (options.outputFormat !== 'stream-json') {
+                    console.log(chalk_1.default.yellow('No existing sessions found in this directory. Starting new session.'));
+                }
+            }
+            else if (options.session) {
+                const sessionData = await sessionManager.loadSession(options.session, currentWorkingDir);
+                if (sessionData) {
+                    existingMessages = sessionData.messages;
+                    sessionId = sessionData.metadata.id;
+                    if (options.outputFormat !== 'stream-json') {
+                        console.log(chalk_1.default.cyan(`Loaded session: ${sessionId}${sessionData.metadata.title ? ` (${sessionData.metadata.title})` : ''}`));
+                    }
+                }
+                else {
+                    outputHandler.outputError(`Session ${options.session} not found in current directory`);
+                    await cleanup();
+                    process.exit(1);
+                }
+            }
+        }
+        // Initialize session for stream-json
+        outputHandler.initializeSession(toolNames, [], model);
+        // Handle sequential prompts from file
+        if (options.prompts) {
+            if (sessionManager) {
+                await handleSequentialPromptsWithSessions(chat, toolRegistry, options, outputHandler, sessionManager, sessionId);
+            }
+            else {
+                await handleSequentialPrompts(chat, toolRegistry, options, outputHandler);
+            }
+            await cleanup();
+            process.exit(0);
+            return;
+        }
+        // Get messages based on input method
+        const newMessages = await buildMessages(options);
+        if (!newMessages || newMessages.length === 0) {
+            outputHandler.outputError('No message provided');
+            await cleanup();
+            process.exit(1);
+        }
+        // Combine existing messages with new messages, excluding duplicate system messages
+        const allMessages = [...existingMessages];
+        for (const newMsg of newMessages) {
+            if (newMsg.role === 'system' && allMessages.some(m => m.role === 'system')) {
+                continue; // Skip duplicate system message
+            }
+            allMessages.push(newMsg);
+        }
+        const spinner = outputHandler.startSpinner('Sending message...');
+        const request = {
+            model,
+            messages: allMessages,
+            temperature: options.temperature,
+            max_tokens: options.maxTokens,
+            // Always include tools if any are registered (from MCP or --tools flag)
+            tools: tools.length > 0 ? tools : undefined,
+            // Enable auto-execution if MCP is configured or --tools flag is set or --enable-core-tools is set
+            max_steps: (options.tools || options.enableCoreTools || options.mcpConfig || options.mcpServers)
+                ? (options.maxSteps || 5)
+                : 0
+        };
+        const chatSession = chat.createSession(options.provider);
+        const lastMessage = allMessages[allMessages.length - 1];
+        const messageContent = typeof lastMessage.content === 'string'
+            ? lastMessage.content
+            : JSON.stringify(lastMessage.content);
+        const apiStart = Date.now();
+        const response = await chatSession.send(messageContent, request);
+        const apiDuration = Date.now() - apiStart;
+        if (spinner)
+            spinner.succeed('Response received');
+        if (options.json) {
+            console.log(JSON.stringify(response, null, 2));
+        }
+        else {
+            const assistantMessage = response.choices[0].message;
+            // Output assistant message with tool calls
+            outputHandler.outputMessage('assistant', assistantMessage.content, response.usage, assistantMessage.tool_calls);
+            // Output tool results if any (for text format)
+            if (assistantMessage.tool_calls && options.outputFormat === 'text') {
+                for (const toolCall of assistantMessage.tool_calls) {
+                    outputHandler.outputToolCall(toolCall.function.name, JSON.parse(toolCall.function.arguments));
+                }
+            }
+            outputHandler.outputComplete(response.usage, apiDuration);
+        }
+        // Save conversation to session (only if session tracking is enabled)
+        if (sessionManager) {
+            await saveConversationToSession(sessionManager, currentWorkingDir, sessionId, allMessages, response.choices[0].message, {
+                provider: options.provider,
+                model,
+                title: options.sessionTitle
+            });
+        }
+        // Clean up and exit
+        await cleanup();
+        // Force exit after a short delay to ensure cleanup completes
+        setTimeout(() => {
+            process.exit(0);
+        }, 100);
+    }
+    catch (error) {
+        const errorHandler = new output_1.OutputHandler(options.outputFormat);
+        errorHandler.outputError(error instanceof Error ? error : String(error));
+        if (cleanup) {
+            try {
+                await cleanup();
+            }
+            catch (cleanupError) {
+                if (options.outputFormat !== 'stream-json') {
+                    console.error('Cleanup error:', cleanupError);
+                }
+            }
+        }
+        process.exit(1);
+    }
+});
+// Interactive mode command
+const interactiveCommand = program
+    .command('interactive')
+    .alias('i')
+    .description('Start interactive chat mode')
+    .option('-p, --provider <provider>', 'Provider to use')
+    .option('-m, --model <model>', 'Model to use')
+    .option('-s, --system <system>', 'System message')
+    .option('-S, --system-file <file>', 'Read system message from file')
+    .option('--tools', 'Enable tool execution')
+    .option('--enable-core-tools', 'Enable majk-chat-basic-tools (bash, ls, read, etc.)')
+    .option('--tool-result-limit <limit>', 'Truncate tool results over this character limit', parseInt, 8000)
+    .option('--auto-execute', 'Auto-execute tools without confirmation')
+    .option('-c, --config <file>', 'Configuration file')
+    .option('--mcp-config <value>', 'MCP configuration file path or JSON string')
+    .option('--mcp-servers <json>', 'MCP servers configuration as JSON string (deprecated, use --mcp-config)')
+    .option('--allowed-tools <tools>', 'Comma-separated list of allowed MCP tools')
+    .option('--disallowed-tools <tools>', 'Comma-separated list of disallowed MCP tools')
+    .option('--permission-prompt-tool <tool>', 'MCP tool to use for permission prompts');
+addCredentialOptions(interactiveCommand)
+    .action(async (options) => {
+    let cleanup = null;
+    try {
+        const setupResult = await setupChat(options);
+        const { chat, toolRegistry } = setupResult;
+        cleanup = setupResult.cleanup;
+        const systemMessage = await getSystemMessage(options);
+        // Check if we have tools available from MCP or --tools flag
+        const hasTools = toolRegistry.getDefinitions().length > 0;
+        const interactive = new interactive_1.InteractiveMode(chat, {
+            provider: options.provider,
+            model: options.model || getDefaultModel(options.provider),
+            systemMessage,
+            enableTools: options.tools || hasTools, // Enable if tools flag or MCP tools available
+            autoExecute: options.autoExecute
+        });
+        await interactive.start();
+        // Clean up when interactive mode exits
+        if (cleanup) {
+            await cleanup();
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : error);
+        if (cleanup) {
+            try {
+                await cleanup();
+            }
+            catch (cleanupError) {
+                if (options.outputFormat !== 'stream-json') {
+                    console.error('Cleanup error:', cleanupError);
+                }
+            }
+        }
+        process.exit(1);
+    }
+});
+// List models command
+const modelsCommand = program
+    .command('models')
+    .description('List available models')
+    .option('-p, --provider <provider>', 'Filter by provider')
+    .option('-c, --config <file>', 'Configuration file');
+addCredentialOptions(modelsCommand)
+    .action(async (options) => {
+    try {
+        const { chat } = await setupChat(options);
+        const spinner = (0, ora_1.default)('Fetching models...').start();
+        const providers = options.provider
+            ? [options.provider]
+            : chat.listProviders();
+        const allModels = [];
+        for (const provider of providers) {
+            try {
+                const providerAdapter = chat.getProvider(provider);
+                const response = await providerAdapter.listModels({
+                    requestId: `models-${Date.now()}`
+                });
+                for (const model of response.data) {
+                    allModels.push({
+                        ...model,
+                        provider
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`Warning: Could not fetch models from ${provider}`));
+            }
+        }
+        spinner.succeed('Models fetched');
+        if (allModels.length === 0) {
+            console.log(chalk_1.default.yellow('No models found'));
+            return;
+        }
+        console.log(chalk_1.default.cyan('\nAvailable Models:'));
+        for (const model of allModels) {
+            console.log(`  ${chalk_1.default.green(model.id)} (${model.provider})`);
+            if (model.capabilities) {
+                const caps = [];
+                if (model.capabilities.tools)
+                    caps.push('tools');
+                if (model.capabilities.modalities?.includes('vision'))
+                    caps.push('vision');
+                if (model.capabilities.json_mode)
+                    caps.push('json');
+                if (caps.length > 0) {
+                    console.log(`    Capabilities: ${caps.join(', ')}`);
+                }
+                if (model.capabilities.max_output_tokens) {
+                    console.log(`    Max tokens: ${model.capabilities.max_output_tokens}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Configure command
+program
+    .command('config')
+    .description('Configure providers and credentials')
+    .option('--init', 'Initialize configuration')
+    .option('--set <key=value>', 'Set configuration value')
+    .option('--get <key>', 'Get configuration value')
+    .option('--list', 'List configuration')
+    .action(async (options) => {
+    const configPath = path.join(process.env.HOME || '~', '.majk-chat', 'config.yaml');
+    if (options.init) {
+        await initializeConfig(configPath);
+        console.log(chalk_1.default.green(`Configuration initialized at ${configPath}`));
+    }
+    else if (options.set) {
+        await setConfigValue(configPath, options.set);
+    }
+    else if (options.get) {
+        await getConfigValue(configPath, options.get);
+    }
+    else if (options.list) {
+        await listConfig(configPath);
+    }
+    else {
+        console.log(chalk_1.default.yellow('Please specify an action: --init, --set, --get, or --list'));
+    }
+});
+// Helper functions
+// Extract credential options from CLI arguments
+function extractCredentialOptions(options) {
+    return {
+        // Generic
+        apiKey: options.apiKey,
+        apiKeyFile: options.apiKeyFile,
+        envFile: options.envFile,
+        // OpenAI
+        openaiApiKey: options.openaiApiKey,
+        openaiOrgId: options.openaiOrgId,
+        // Anthropic
+        anthropicApiKey: options.anthropicApiKey,
+        // Azure OpenAI
+        azureOpenaiApiKey: options.azureOpenaiApiKey,
+        azureOpenaiEndpoint: options.azureOpenaiEndpoint,
+        azureOpenaiDeployment: options.azureOpenaiDeployment,
+        // AWS Bedrock
+        awsAccessKeyId: options.awsAccessKeyId,
+        awsSecretAccessKey: options.awsSecretAccessKey,
+        awsSessionToken: options.awsSessionToken,
+        awsRegion: options.awsRegion
+    };
+}
+async function setupChat(options) {
+    const builder = new majk_chat_core_1.MajkChatBuilder();
+    const credManager = new credentials_1.CredentialManager();
+    const credOptions = extractCredentialOptions(options);
+    // Load configuration
+    if (options.config) {
+        const config = await config_1.ConfigLoader.load(options.config);
+        await applyConfig(builder, config);
+    }
+    // Setup providers with credentials
+    const providers = await credManager.loadProviders(credOptions);
+    // Check if we have any providers or if a specific provider was requested
+    let hasProviders = false;
+    if (providers.openai || options.provider === 'openai') {
+        const creds = await credManager.getCredentials('openai', credOptions);
+        if (creds?.apiKey) {
+            builder.withOpenAI(creds);
+            hasProviders = true;
+        }
+    }
+    if (providers.anthropic || options.provider === 'anthropic') {
+        const creds = await credManager.getCredentials('anthropic', credOptions);
+        if (creds?.apiKey) {
+            builder.withAnthropic(creds);
+            hasProviders = true;
+        }
+    }
+    if (providers.azureOpenai || options.provider === 'azure-openai') {
+        const creds = await credManager.getCredentials('azure-openai', credOptions);
+        if (creds?.apiKey) {
+            builder.withAzureOpenAI(creds);
+            hasProviders = true;
+        }
+    }
+    if (providers.bedrock || options.provider === 'bedrock') {
+        const creds = await credManager.getCredentials('bedrock', credOptions);
+        if (creds?.accessKeyId) {
+            builder.withBedrock(creds);
+            hasProviders = true;
+        }
+    }
+    // Throw error if no valid credentials found
+    if (!hasProviders) {
+        throw new Error('No valid API credentials found. Please provide API keys via command line options, environment variables, or .env files. Use --help to see available credential options.');
+    }
+    // Add tools if enabled
+    if (options.tools) {
+        builder
+            .withTool(new bash_tool_1.BashTool())
+            .withTool(new filesystem_tool_1.FileSystemTool())
+            .withAutoToolExecution(options.maxSteps || 5);
+    }
+    // Add core tools if enabled
+    if (options.enableCoreTools) {
+        const toolRegistry = builder.getToolRegistry();
+        if (toolRegistry) {
+            (0, majk_chat_basic_tools_1.registerBasicTools)(toolRegistry);
+            // Apply tool filtering if specified
+            if (options.allowedTools || options.disallowedTools) {
+                applyToolFiltering(toolRegistry, options.allowedTools, options.disallowedTools);
+            }
+            // Setup tool result truncation and auto-registration
+            if (options.toolResultLimit) {
+                setupToolResultManagement(builder, options.toolResultLimit, options);
+            }
+            builder.withAutoToolExecution(options.maxSteps || 5);
+        }
+    }
+    let mcpPlugin = null;
+    // Setup MCP if configured - this will add tools to the registry
+    if (options.mcpConfig || options.mcpServers) {
+        mcpPlugin = await setupMCP(builder, options);
+        // Enable auto tool execution if MCP is configured
+        if (!options.tools) {
+            builder.withAutoToolExecution(options.maxSteps || 5);
+        }
+    }
+    // Set tool callbacks if provided
+    if (options.onToolCall || options.onToolResult) {
+        builder.withToolCallbacks(options.onToolCall, options.onToolResult);
+    }
+    const toolRegistry = builder.getToolRegistry();
+    return {
+        chat: builder.build(),
+        toolRegistry,
+        cleanup: async () => {
+            if (mcpPlugin) {
+                try {
+                    await mcpPlugin.shutdown();
+                }
+                catch (error) {
+                    if (options.outputFormat !== 'stream-json') {
+                        console.error('Error during MCP cleanup:', error);
+                    }
+                }
+            }
+            // Remove any stdin listeners that might be keeping process alive
+            process.stdin.removeAllListeners();
+            // Close stdin to prevent hanging
+            if (process.stdin.readable) {
+                process.stdin.destroy();
+            }
+        }
+    };
+}
+async function buildMessages(options) {
+    const messages = [];
+    // Add system message if provided
+    const systemMessage = await getSystemMessage(options);
+    if (systemMessage) {
+        messages.push({ role: 'system', content: systemMessage });
+    }
+    // Handle -p option (JSON array or prompt string)
+    if (options.p) {
+        const pValue = options.p.trim();
+        if (pValue.startsWith('[')) {
+            // Parse as JSON messages array
+            try {
+                const parsedMessages = JSON.parse(pValue);
+                if (Array.isArray(parsedMessages)) {
+                    messages.push(...parsedMessages);
+                }
+            }
+            catch (e) {
+                throw new Error(`Invalid JSON in -p option: ${e}`);
+            }
+        }
+        else {
+            // Treat as a simple prompt string
+            messages.push({ role: 'user', content: pValue });
+        }
+    }
+    else {
+        // Use traditional message options
+        const message = await getMessage(options);
+        if (message) {
+            messages.push({ role: 'user', content: message });
+        }
+    }
+    return messages;
+}
+async function handleSequentialPrompts(chat, toolRegistry, options, outputHandler) {
+    const promptsFile = await fs.readFile(options.prompts, 'utf-8');
+    const prompts = promptsFile.split('\n').filter(line => line.trim().length > 0);
+    const model = options.model
+        ? (0, models_1.resolveModel)(options.model)
+        : (0, models_1.getDefaultModelForProvider)(options.provider);
+    const session = chat.createSession(options.provider);
+    const conversationMessages = [];
+    // Add system message if provided
+    const systemMessage = await getSystemMessage(options);
+    if (systemMessage) {
+        conversationMessages.push({ role: 'system', content: systemMessage });
+    }
+    // Get tool definitions from registry
+    const tools = toolRegistry.getDefinitions();
+    for (const prompt of prompts) {
+        outputHandler.outputMessage('user', prompt);
+        conversationMessages.push({ role: 'user', content: prompt });
+        const request = {
+            model,
+            messages: conversationMessages,
+            temperature: options.temperature,
+            max_tokens: options.maxTokens,
+            // Always include tools if any are registered
+            tools: tools.length > 0 ? tools : undefined,
+            // Enable auto-execution if MCP is configured or --tools flag is set
+            max_steps: (options.tools || options.mcpConfig || options.mcpServers)
+                ? (options.maxSteps || 5)
+                : 0
+        };
+        const spinner = outputHandler.startSpinner('Processing...');
+        const response = await session.send(prompt, request);
+        if (spinner)
+            spinner.stop();
+        const assistantMessage = response.choices[0].message;
+        conversationMessages.push(assistantMessage);
+        outputHandler.outputMessage('assistant', assistantMessage.content);
+        // Show tool calls if any
+        if (assistantMessage.tool_calls) {
+            for (const toolCall of assistantMessage.tool_calls) {
+                outputHandler.outputToolCall(toolCall.function.name, JSON.parse(toolCall.function.arguments));
+            }
+        }
+    }
+    outputHandler.outputComplete();
+}
+async function setupMCP(builder, options) {
+    const mcpOptions = {};
+    if (options.mcpConfig) {
+        // Check if it's a JSON string or a file path
+        const configValue = options.mcpConfig.trim();
+        if (configValue.startsWith('{')) {
+            // It's a JSON string
+            mcpOptions.configString = configValue;
+        }
+        else {
+            // It's a file path
+            mcpOptions.configPath = configValue;
+        }
+    }
+    // Support legacy --mcp-servers option
+    if (options.mcpServers) {
+        mcpOptions.configString = options.mcpServers;
+    }
+    // Parse tool filtering patterns
+    if (options.allowedTools || options.disallowedTools) {
+        // Note: We could use createToolFilter here for more advanced filtering
+        // but for now we pass patterns directly to MCP plugin
+        if (options.allowedTools) {
+            mcpOptions.allowedTools = options.allowedTools
+                .split(/[,\s]+/)
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0);
+        }
+        if (options.disallowedTools) {
+            mcpOptions.disallowedTools = options.disallowedTools
+                .split(/[,\s]+/)
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0);
+        }
+    }
+    if (options.permissionPromptTool) {
+        mcpOptions.permissionPromptTool = options.permissionPromptTool;
+    }
+    // Enable quiet mode for stream-json to suppress console output
+    mcpOptions.quiet = options.outputFormat === 'stream-json';
+    const mcpPlugin = new majk_chat_mcp_1.MCPPlugin(mcpOptions);
+    const registry = builder.getToolRegistry();
+    if (registry) {
+        try {
+            await mcpPlugin.initialize(registry);
+            if (options.outputFormat !== 'stream-json') {
+                console.log(chalk_1.default.cyan('MCP servers connected and tools registered'));
+            }
+        }
+        catch (error) {
+            if (options.outputFormat !== 'stream-json') {
+                console.error(chalk_1.default.red('Failed to initialize MCP:'), error instanceof Error ? error.message : error);
+            }
+            // Continue without MCP rather than failing completely
+        }
+    }
+    return mcpPlugin;
+}
+async function getMessage(options) {
+    if (options.message) {
+        return options.message;
+    }
+    if (options.file) {
+        const content = await fs.readFile(options.file, 'utf-8');
+        return content.trim();
+    }
+    // Only try to read from stdin if it's a TTY (interactive terminal)
+    // In tests and CI environments, just return null instead of hanging
+    if (!process.stdin.isTTY) {
+        return null;
+    }
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.on('data', chunk => data += chunk);
+        process.stdin.on('end', () => resolve(data.trim()));
+    });
+}
+async function getSystemMessage(options) {
+    let systemMessage = '';
+    // Get base system message
+    if (options.system) {
+        systemMessage = options.system;
+    }
+    else if (options.systemFile) {
+        const content = await fs.readFile(options.systemFile, 'utf-8');
+        systemMessage = content.trim();
+    }
+    // Append additional system prompt if provided
+    if (options.appendSystemPrompt) {
+        if (systemMessage) {
+            systemMessage += '\n\n' + options.appendSystemPrompt;
+        }
+        else {
+            systemMessage = options.appendSystemPrompt;
+        }
+    }
+    return systemMessage || null;
+}
+function getDefaultModel(provider) {
+    return (0, models_1.getDefaultModelForProvider)(provider || 'openai');
+}
+async function applyConfig(builder, config) {
+    if (config.providers) {
+        for (const [provider, providerConfig] of Object.entries(config.providers)) {
+            switch (provider) {
+                case 'openai':
+                    builder.withOpenAI(providerConfig);
+                    break;
+                case 'anthropic':
+                    builder.withAnthropic(providerConfig);
+                    break;
+                case 'azure-openai':
+                    builder.withAzureOpenAI(providerConfig);
+                    break;
+                case 'bedrock':
+                    builder.withBedrock(providerConfig);
+                    break;
+            }
+        }
+    }
+    if (config.defaultProvider) {
+        builder.setDefaultProvider(config.defaultProvider);
+    }
+}
+async function initializeConfig(configPath) {
+    const defaultConfig = {
+        providers: {
+            openai: {
+                apiKey: '${OPENAI_API_KEY}'
+            },
+            anthropic: {
+                apiKey: '${ANTHROPIC_API_KEY}'
+            },
+            'azure-openai': {
+                apiKey: '${AZURE_OPENAI_API_KEY}',
+                endpoint: '${AZURE_OPENAI_ENDPOINT}',
+                deploymentName: '${AZURE_OPENAI_DEPLOYMENT}'
+            },
+            bedrock: {
+                region: '${AWS_REGION}',
+                accessKeyId: '${AWS_ACCESS_KEY_ID}',
+                secretAccessKey: '${AWS_SECRET_ACCESS_KEY}'
+            }
+        },
+        defaultProvider: 'openai',
+        tools: {
+            autoExecute: false,
+            maxSteps: 5
+        }
+    };
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeFile(configPath, yaml.stringify(defaultConfig), 'utf-8');
+}
+async function setConfigValue(configPath, keyValue) {
+    const [key, ...valueParts] = keyValue.split('=');
+    const value = valueParts.join('=');
+    let config = {};
+    if (await fs.pathExists(configPath)) {
+        const content = await fs.readFile(configPath, 'utf-8');
+        config = yaml.parse(content);
+    }
+    // Set nested value
+    const keys = key.split('.');
+    let current = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (!current[keys[i]]) {
+            current[keys[i]] = {};
+        }
+        current = current[keys[i]];
+    }
+    current[keys[keys.length - 1]] = value;
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeFile(configPath, yaml.stringify(config), 'utf-8');
+    console.log(chalk_1.default.green(`Set ${key} = ${value}`));
+}
+async function getConfigValue(configPath, key) {
+    if (!await fs.pathExists(configPath)) {
+        console.log(chalk_1.default.yellow('Configuration file not found'));
+        return;
+    }
+    const content = await fs.readFile(configPath, 'utf-8');
+    const config = yaml.parse(content);
+    // Get nested value
+    const keys = key.split('.');
+    let current = config;
+    for (const k of keys) {
+        if (current && typeof current === 'object' && k in current) {
+            current = current[k];
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Key not found: ${key}`));
+            return;
+        }
+    }
+    console.log(current);
+}
+async function listConfig(configPath) {
+    if (!await fs.pathExists(configPath)) {
+        console.log(chalk_1.default.yellow('Configuration file not found'));
+        return;
+    }
+    const content = await fs.readFile(configPath, 'utf-8');
+    console.log(content);
+}
+/**
+ * Apply tool filtering to remove disallowed tools from the registry
+ */
+function applyToolFiltering(registry, allowedTools, disallowedTools) {
+    if (!allowedTools && !disallowedTools)
+        return;
+    const toolFilter = (0, tool_filter_1.createToolFilter)(allowedTools, disallowedTools);
+    const definitions = registry.getDefinitions();
+    // Remove filtered tools
+    for (const definition of definitions) {
+        const toolName = definition.function?.name;
+        if (toolName && !toolFilter(toolName)) {
+            // Note: This assumes the registry has a remove method
+            // If not available, we would need to implement it or use a different approach
+            if (registry.remove) {
+                registry.remove(toolName);
+            }
+        }
+    }
+}
+/**
+ * Setup tool result management with automatic ReadToolResult registration
+ */
+function setupToolResultManagement(builder, resultLimit, options) {
+    let readToolResultRegistered = false;
+    const truncationConfig = {
+        maxLength: resultLimit,
+        previewLength: Math.floor(resultLimit * 0.6),
+        tailLength: Math.floor(resultLimit * 0.3),
+        storeResult: true
+    };
+    // Set up tool result callback to handle truncation
+    const originalOnToolResult = options.onToolResult;
+    const onToolResult = (toolName, result, context) => {
+        // Check if result should be truncated
+        if (majk_chat_basic_tools_1.ToolResultTruncator.shouldTruncate(result, truncationConfig)) {
+            // Set conversation ID from context if available
+            const conversationId = context?.metadata?.conversationId || context?.requestId || 'cli-session';
+            const configWithConversation = { ...truncationConfig, conversationId };
+            // Process the result with truncation
+            const truncatedResult = majk_chat_basic_tools_1.ToolResultTruncator.processToolResult(result, toolName, configWithConversation);
+            // Auto-register ReadToolResult tool on first truncation
+            if (!readToolResultRegistered && truncatedResult.truncated) {
+                const registry = builder.getToolRegistry();
+                if (registry && !registry.has('read_tool_result')) {
+                    registry.register(new majk_chat_basic_tools_1.ReadToolResultTool());
+                    readToolResultRegistered = true;
+                    console.log(chalk_1.default.yellow('📋 Large tool result detected. ReadToolResult tool auto-registered.'));
+                    console.log(chalk_1.default.gray(`    Use read_tool_result with ID: ${truncatedResult.full_result_id}`));
+                }
+            }
+            // Call original callback with truncated result
+            if (originalOnToolResult) {
+                originalOnToolResult(toolName, truncatedResult, context);
+            }
+            return truncatedResult;
+        }
+        // Call original callback for non-truncated results
+        if (originalOnToolResult) {
+            originalOnToolResult(toolName, result, context);
+        }
+        return result;
+    };
+    // Update the options to include our callback
+    options.onToolResult = onToolResult;
+}
+// Session helper functions
+async function handleListSessions(sessionManager, workingDirectory, outputHandler) {
+    try {
+        const sessions = await sessionManager.listSessions(workingDirectory);
+        if (sessions.length === 0) {
+            console.log(chalk_1.default.yellow('No sessions found in this directory.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan('\nSessions in current directory:'));
+        for (const session of sessions) {
+            console.log(`  ${chalk_1.default.green(session.id)}`);
+            if (session.title) {
+                console.log(`    Title: ${session.title}`);
+            }
+            console.log(`    Created: ${session.createdAt.toLocaleDateString()} ${session.createdAt.toLocaleTimeString()}`);
+            console.log(`    Updated: ${session.updatedAt.toLocaleDateString()} ${session.updatedAt.toLocaleTimeString()}`);
+            console.log(`    Messages: ${session.totalMessages}`);
+            if (session.lastMessage) {
+                console.log(`    Last: ${session.lastMessage}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        outputHandler.outputError(`Failed to list sessions: ${error instanceof Error ? error.message : error}`);
+    }
+}
+async function handleDeleteSession(sessionManager, workingDirectory, sessionId, outputHandler) {
+    try {
+        const deleted = await sessionManager.deleteSession(sessionId, workingDirectory);
+        if (deleted) {
+            console.log(chalk_1.default.green(`Session ${sessionId} deleted successfully.`));
+        }
+        else {
+            outputHandler.outputError(`Session ${sessionId} not found.`);
+        }
+    }
+    catch (error) {
+        outputHandler.outputError(`Failed to delete session: ${error instanceof Error ? error.message : error}`);
+    }
+}
+async function saveConversationToSession(sessionManager, workingDirectory, sessionId, allMessages, assistantMessage, options) {
+    try {
+        // Add the assistant's response to the conversation
+        const finalMessages = [...allMessages, assistantMessage];
+        if (sessionId) {
+            // Update existing session
+            await sessionManager.addMessage(assistantMessage);
+        }
+        else {
+            // Create new session
+            sessionId = await sessionManager.createSession(workingDirectory, {
+                title: options.title,
+                provider: options.provider,
+                model: options.model,
+                initialMessages: finalMessages
+            });
+            // Auto-generate title if not provided
+            if (!options.title) {
+                await sessionManager.generateSessionTitle();
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.yellow(`Warning: Failed to save session: ${error instanceof Error ? error.message : error}`));
+    }
+}
+async function handleSequentialPromptsWithSessions(chat, toolRegistry, options, outputHandler, _sessionManager, _sessionId) {
+    // This is a modified version of handleSequentialPrompts that works with sessions
+    // For now, we'll delegate to the original function and add session support later
+    await handleSequentialPrompts(chat, toolRegistry, options, outputHandler);
+}
+// Parse and execute
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map