prab-cli 1.1.0 → 1.2.0

package/dist/index.js

@@ -60,6 +60,7 @@ const groq_models_1 = require("./lib/groq-models");
 // Import chat handler and safety
 const chat_handler_1 = require("./lib/chat-handler");
 const safety_1 = require("./lib/safety");
+const chalk_1 = __importDefault(require("chalk"));
 const tracker_1 = require("./lib/tracker");
 // Cache for available models
 let cachedModels = [];
@@ -370,7 +371,90 @@ program.action(async () => {
             continue;
         }
         // Process user input with chat handler
-        await chatHandler.processUserInput(userInput);
+        const result = await chatHandler.processUserInput(userInput);
+        // Handle model errors - offer to switch models
+        if (!result.success && result.isModelError) {
+            console.log("");
+            console.log(chalk_1.default.yellow("┌─────────────────────────────────────────────────────┐"));
+            console.log(chalk_1.default.yellow("│") +
+                chalk_1.default.red.bold("  Model Error Detected                               ") +
+                chalk_1.default.yellow("│"));
+            console.log(chalk_1.default.yellow("└─────────────────────────────────────────────────────┘"));
+            const errorMessages = {
+                rate_limit: "Rate limit exceeded. The model is receiving too many requests.",
+                model_unavailable: "Model is currently unavailable or overloaded.",
+                auth_error: "Authentication error. Please check your API key.",
+                unknown: "An error occurred with the current model.",
+            };
+            console.log(chalk_1.default.dim(`  ${errorMessages[result.errorType || "unknown"]}`));
+            console.log("");
+            console.log(chalk_1.default.cyan("  Would you like to switch to a different model?"));
+            console.log("");
+            // Fetch models if not cached
+            if (cachedModels.length === 0) {
+                const spinner = (0, ora_1.default)("Fetching available models...").start();
+                cachedModels = await (0, groq_models_1.fetchGroqModels)(apiKey);
+                spinner.succeed(`Found ${cachedModels.length} models`);
+            }
+            // Filter out the current model and build choices
+            const currentModel = modelProvider.modelId;
+            const availableModels = cachedModels.filter((m) => m.id !== currentModel);
+            const grouped = (0, groq_models_1.groupModelsByOwner)(availableModels);
+            const modelChoices = [];
+            // Add "Cancel" option first
+            modelChoices.push({
+                name: chalk_1.default.dim("  Cancel (keep current model)"),
+                value: "__cancel__",
+            });
+            modelChoices.push(new select_1.Separator("─── Available Models ───"));
+            for (const [owner, models] of grouped) {
+                modelChoices.push(new select_1.Separator(`─── ${owner} ───`));
+                for (const model of models) {
+                    const ctx = (0, groq_models_1.formatContextWindow)(model.context_window);
+                    modelChoices.push({
+                        name: `  ${model.id} (${ctx} ctx)`,
+                        value: model.id,
+                    });
+                }
+            }
+            try {
+                const selectedModel = await (0, select_1.default)({
+                    message: "Select a model to switch to:",
+                    choices: modelChoices,
+                    pageSize: 12,
+                    loop: false,
+                });
+                if (selectedModel && selectedModel !== "__cancel__") {
+                    const oldModel = currentModel;
+                    (0, config_1.setActiveModel)(selectedModel);
+                    modelProvider.setModel(selectedModel);
+                    chatHandler.updateModelProvider(modelProvider);
+                    ui_1.log.success(`Switched to model: ${selectedModel}`);
+                    tracker_1.tracker.modelSwitch(oldModel, selectedModel, true);
+                    // Ask if user wants to retry the last message
+                    console.log("");
+                    const { retry } = await inquirer_1.default.prompt([
+                        {
+                            type: "confirm",
+                            name: "retry",
+                            message: "Retry your last message with the new model?",
+                            default: true,
+                        },
+                    ]);
+                    if (retry) {
+                        console.log(chalk_1.default.dim("Retrying with new model..."));
+                        await chatHandler.processUserInput(userInput);
+                    }
+                }
+                else {
+                    ui_1.log.info("Keeping current model. You can try again or switch models with /model");
+                }
+            }
+            catch (e) {
+                // User cancelled with Ctrl+C
+                ui_1.log.info("Model switch cancelled.");
+            }
+        }
     }
 });
 program.parse(process.argv);

package/dist/lib/chat-handler.js

@@ -11,7 +11,7 @@ const tracker_1 = require("./tracker");
 class ChatHandler {
     constructor(toolRegistry, toolExecutor, modelProvider, initialContext) {
         this.messages = [];
-        this.contextMessage = '';
+        this.contextMessage = "";
         this.usage = {
             promptTokens: 0,
             completionTokens: 0,
@@ -58,9 +58,9 @@ When you need to perform file operations, use the appropriate tools rather than
         try {
             // Auto-attach file context if files are mentioned
             const attachedFiles = await this.attachMentionedFiles(input);
-            let finalInput = input;
+            const finalInput = input;
             if (attachedFiles.length > 0) {
-                ui_1.log.info(`Attached context for: ${attachedFiles.join(', ')}`);
+                ui_1.log.info(`Attached context for: ${attachedFiles.join(", ")}`);
                 tracker_1.tracker.contextAttached(attachedFiles);
             }
             // Add user message
@@ -73,20 +73,20 @@ When you need to perform file operations, use the appropriate tools rather than
             const maxIterations = 10; // Prevent infinite loops
             while (continueLoop && iterationCount < maxIterations) {
                 iterationCount++;
-                tracker_1.tracker.iteration(iterationCount, 'Starting API call');
+                tracker_1.tracker.iteration(iterationCount, "Starting API call");
                 // Log API request
                 tracker_1.tracker.apiRequest(this.modelProvider.modelId, this.messages.length, tools.length);
                 const apiStartTime = Date.now();
                 // Stream response from model
                 const stream = this.modelProvider.streamChat(this.messages, tools);
-                let fullResponse = '';
+                let fullResponse = "";
                 let toolCalls = [];
                 const formatter = new ui_1.StreamFormatter();
-                process.stdout.write('\n');
+                process.stdout.write("\n");
                 try {
                     for await (const chunk of stream) {
                         // Handle text content
-                        if (chunk.content && typeof chunk.content === 'string') {
+                        if (chunk.content && typeof chunk.content === "string") {
                             fullResponse += chunk.content;
                             // Format and output the chunk with syntax highlighting
                             const formatted = formatter.processChunk(chunk.content);
@@ -120,7 +120,7 @@ When you need to perform file operations, use the appropriate tools rather than
                     tracker_1.tracker.apiError(apiError.message, { stack: apiError.stack });
                     throw apiError;
                 }
-                process.stdout.write('\n\n');
+                process.stdout.write("\n\n");
                 // Log AI response if there's content
                 if (fullResponse.length > 0) {
                     tracker_1.tracker.aiResponse(fullResponse);
@@ -128,14 +128,14 @@ When you need to perform file operations, use the appropriate tools rather than
                 // If we have tool calls, execute them
                 if (toolCalls.length > 0) {
                     // Log AI's tool decision
-                    tracker_1.tracker.aiToolDecision(toolCalls.map(tc => ({
+                    tracker_1.tracker.aiToolDecision(toolCalls.map((tc) => ({
                         name: tc.name,
-                        args: tc.args || {}
+                        args: tc.args || {},
                     })));
                     // Add AI message with tool calls
                     this.messages.push(new messages_1.AIMessage({
                         content: fullResponse,
-                        tool_calls: toolCalls
+                        tool_calls: toolCalls,
                     }));
                     // Execute tools
                     const results = await this.executeToolCalls(toolCalls);
@@ -146,10 +146,10 @@ When you need to perform file operations, use the appropriate tools rather than
                         this.messages.push(new messages_1.ToolMessage({
                             content: result.success ? result.output : `Error: ${result.error}`,
                             tool_call_id: toolCall.id,
-                            name: toolCall.name
+                            name: toolCall.name,
                         }));
                     }
-                    tracker_1.tracker.iteration(iterationCount, 'Tool execution complete, continuing loop');
+                    tracker_1.tracker.iteration(iterationCount, "Tool execution complete, continuing loop");
                     // Continue loop to get AI's response after tool execution
                     continue;
                 }
@@ -157,31 +157,98 @@ When you need to perform file operations, use the appropriate tools rather than
                     // No tool calls, add final AI message and end loop
                     this.messages.push(new messages_1.AIMessage(fullResponse));
                     continueLoop = false;
-                    tracker_1.tracker.iteration(iterationCount, 'No tool calls, ending loop');
+                    tracker_1.tracker.iteration(iterationCount, "No tool calls, ending loop");
                 }
             }
             if (iterationCount >= maxIterations) {
-                ui_1.log.warning('Maximum iteration limit reached. Ending conversation turn.');
-                tracker_1.tracker.warn('Max iterations reached', { iterations: iterationCount });
+                ui_1.log.warning("Maximum iteration limit reached. Ending conversation turn.");
+                tracker_1.tracker.warn("Max iterations reached", { iterations: iterationCount });
             }
             // Log success
             const duration = Date.now() - startTime;
             tracker_1.tracker.promptComplete(input, duration, iterationCount);
+            return { success: true };
         }
         catch (error) {
-            ui_1.log.error(`Error: ${error.message}`);
-            tracker_1.tracker.promptFailed(input, error.message);
-            tracker_1.tracker.error('Chat processing failed', error);
+            const errorMessage = error.message || "Unknown error";
+            ui_1.log.error(`Error: ${errorMessage}`);
+            tracker_1.tracker.promptFailed(input, errorMessage);
+            tracker_1.tracker.error("Chat processing failed", error);
+            // Detect model-specific errors
+            const isModelError = this.isModelError(errorMessage);
+            const errorType = this.classifyError(errorMessage);
+            if (isModelError) {
+                // Remove the user message so they can retry with a different model
+                this.messages.pop();
+            }
+            return {
+                success: false,
+                error: errorMessage,
+                isModelError,
+                errorType,
+            };
+        }
+    }
+    /**
+     * Check if error is related to the model (rate limit, unavailable, etc.)
+     */
+    isModelError(errorMessage) {
+        const modelErrorPatterns = [
+            "rate limit",
+            "rate_limit",
+            "quota exceeded",
+            "model not found",
+            "model is not available",
+            "model_not_available",
+            "overloaded",
+            "capacity",
+            "too many requests",
+            "429",
+            "503",
+            "502",
+            "service unavailable",
+            "timeout",
+            "context length",
+            "maximum context",
+            "token limit",
+        ];
+        const lowerMessage = errorMessage.toLowerCase();
+        return modelErrorPatterns.some((pattern) => lowerMessage.includes(pattern));
+    }
+    /**
+     * Classify the type of error
+     */
+    classifyError(errorMessage) {
+        const lowerMessage = errorMessage.toLowerCase();
+        if (lowerMessage.includes("rate limit") ||
+            lowerMessage.includes("rate_limit") ||
+            lowerMessage.includes("too many requests") ||
+            lowerMessage.includes("429")) {
+            return "rate_limit";
+        }
+        if (lowerMessage.includes("model not found") ||
+            lowerMessage.includes("not available") ||
+            lowerMessage.includes("overloaded") ||
+            lowerMessage.includes("503") ||
+            lowerMessage.includes("502")) {
+            return "model_unavailable";
+        }
+        if (lowerMessage.includes("auth") ||
+            lowerMessage.includes("api key") ||
+            lowerMessage.includes("unauthorized") ||
+            lowerMessage.includes("401")) {
+            return "auth_error";
         }
+        return "unknown";
     }
     /**
      * Execute tool calls from AI
      */
     async executeToolCalls(toolCalls) {
-        const formattedCalls = toolCalls.map(tc => ({
+        const formattedCalls = toolCalls.map((tc) => ({
             id: tc.id || `call-${Date.now()}`,
             name: tc.name,
-            args: tc.args || {}
+            args: tc.args || {},
         }));
         return await this.toolExecutor.executeMultiple(formattedCalls);
     }
@@ -192,7 +259,7 @@ When you need to perform file operations, use the appropriate tools rather than
         const allFiles = await (0, context_1.getFileTree)();
         const attached = [];
         for (const file of allFiles) {
-            const base = file.split('/').pop() || '';
+            const base = file.split("/").pop() || "";
             const isBaseMatch = base.length > 2 && input.includes(base);
             const isPathMatch = input.includes(file);
             if (isPathMatch || isBaseMatch) {
@@ -211,7 +278,7 @@ When you need to perform file operations, use the appropriate tools rather than
     clearHistory() {
         const systemMsg = this.messages[0];
         this.messages = [systemMsg];
-        tracker_1.tracker.debug('Chat history cleared');
+        tracker_1.tracker.debug("Chat history cleared");
     }
     /**
      * Get message count
@@ -235,5 +302,23 @@ When you need to perform file operations, use the appropriate tools rather than
         this.messages[0] = systemMsg; // Keep the same message for now
         // In a more sophisticated implementation, we'd rebuild the system message
     }
+    /**
+     * Update the model provider (for switching models)
+     */
+    updateModelProvider(modelProvider) {
+        this.modelProvider = modelProvider;
+    }
+    /**
+     * Get the last user input (for retry after model switch)
+     */
+    getLastUserInput() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            const msg = this.messages[i];
+            if (msg instanceof messages_1.HumanMessage) {
+                return msg.content;
+            }
+        }
+        return null;
+    }
 }
 exports.ChatHandler = ChatHandler;

package/dist/lib/config.js

@@ -8,8 +8,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const registry_1 = require("./models/registry");
-const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.config', 'groq-cli-tool');
-const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".config", "groq-cli-tool");
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, "config.json");
 const ensureConfigDir = () => {
     if (!fs_1.default.existsSync(CONFIG_DIR)) {
         fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
@@ -19,7 +19,7 @@ const readConfig = () => {
     try {
         if (!fs_1.default.existsSync(CONFIG_FILE))
             return {};
-        return JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, 'utf-8'));
+        return JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, "utf-8"));
     }
     catch {
         return {};
@@ -35,22 +35,22 @@ const writeConfig = (data) => {
 const getConfig = () => {
     const config = readConfig();
     // Handle legacy config format (old apiKey -> new apiKeys.groq)
-    if ('apiKey' in config && typeof config.apiKey === 'string') {
+    if ("apiKey" in config && typeof config.apiKey === "string") {
         const legacyKey = config.apiKey;
         delete config.apiKey;
         config.apiKeys = { groq: legacyKey };
         writeConfig(config);
     }
     return {
-        apiKeys: config.apiKeys || { groq: '' },
+        apiKeys: config.apiKeys || { groq: "" },
         activeModel: config.activeModel || (0, registry_1.getDefaultModel)(),
         preferences: {
             temperature: config.preferences?.temperature ?? 0.7,
             autoConfirm: config.preferences?.autoConfirm ?? false,
             safeMode: config.preferences?.safeMode ?? true,
-            maxTokens: config.preferences?.maxTokens
+            maxTokens: config.preferences?.maxTokens,
         },
-        session: config.session || { todos: [] }
+        session: config.session || { todos: [] },
     };
 };
 exports.getConfig = getConfig;
@@ -59,7 +59,7 @@ exports.getConfig = getConfig;
  */
 const getApiKey = () => {
     const config = (0, exports.getConfig)();
-    return config.apiKeys.groq || '';
+    return config.apiKeys.groq || "";
 };
 exports.getApiKey = getApiKey;
 /**
@@ -68,7 +68,7 @@ exports.getApiKey = getApiKey;
 const setApiKey = (key) => {
     const config = readConfig();
     if (!config.apiKeys) {
-        config.apiKeys = { groq: '' };
+        config.apiKeys = { groq: "" };
     }
     config.apiKeys.groq = key;
     writeConfig(config);
@@ -80,7 +80,7 @@ exports.setApiKey = setApiKey;
 const clearApiKey = () => {
     const config = readConfig();
     if (config.apiKeys) {
-        config.apiKeys.groq = '';
+        config.apiKeys.groq = "";
     }
     writeConfig(config);
 };
@@ -92,7 +92,7 @@ const getModelConfig = () => {
     const config = (0, exports.getConfig)();
     return {
         modelId: config.activeModel,
-        temperature: config.preferences.temperature
+        temperature: config.preferences.temperature,
     };
 };
 exports.getModelConfig = getModelConfig;
@@ -121,7 +121,7 @@ const setPreference = (key, value) => {
         config.preferences = {
             temperature: 0.7,
             autoConfirm: false,
-            safeMode: true
+            safeMode: true,
         };
     }
     config.preferences[key] = value;

package/dist/lib/context.js

@@ -12,33 +12,28 @@ const isGitRepo = async () => {
     try {
         return await git.checkIsRepo();
     }
-    catch (e) {
+    catch {
         return false;
     }
 };
 exports.isGitRepo = isGitRepo;
 const getFileTree = async (cwd = process.cwd()) => {
     // Ignore node_modules, .git, dist, etc.
-    const ignore = ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/.env', '**/*.lock'];
-    const files = await (0, glob_1.glob)('**/*', { cwd, ignore, nodir: true });
+    const ignore = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.env", "**/*.lock"];
+    const files = await (0, glob_1.glob)("**/*", { cwd, ignore, nodir: true });
     return files;
 };
 exports.getFileTree = getFileTree;
 const getFileContent = (filePath) => {
     try {
-        return fs_1.default.readFileSync(filePath, 'utf-8');
+        return fs_1.default.readFileSync(filePath, "utf-8");
     }
-    catch (e) {
-        return '';
+    catch {
+        return "";
     }
 };
 exports.getFileContent = getFileContent;
 const writeFile = (filePath, content) => {
-    try {
-        fs_1.default.writeFileSync(filePath, content, 'utf-8');
-    }
-    catch (e) {
-        throw e;
-    }
+    fs_1.default.writeFileSync(filePath, content, "utf-8");
 };
 exports.writeFile = writeFile;

package/dist/lib/groq-models.js

@@ -16,12 +16,12 @@ async function fetchGroqModels(apiKey) {
         const response = await groq.models.list();
         // Filter and sort models
         const models = response.data
-            .filter(m => m.active !== false)
+            .filter((m) => m.active !== false)
             .sort((a, b) => a.id.localeCompare(b.id));
         return models;
     }
     catch (error) {
-        console.error('Failed to fetch models:', error.message);
+        console.error("Failed to fetch models:", error.message);
         return [];
     }
 }
@@ -31,7 +31,7 @@ async function fetchGroqModels(apiKey) {
 function groupModelsByOwner(models) {
     const groups = new Map();
     for (const model of models) {
-        const owner = model.owned_by || 'Other';
+        const owner = model.owned_by || "Other";
         if (!groups.has(owner)) {
             groups.set(owner, []);
         }

package/dist/lib/groq.js

@@ -8,22 +8,22 @@ let model = null;
 const initGroq = () => {
     const apiKey = (0, config_1.getApiKey)();
     if (!apiKey) {
-        throw new Error('API Key not found');
+        throw new Error("API Key not found");
     }
     model = new groq_1.ChatGroq({
         apiKey,
-        model: 'llama-3.3-70b-versatile',
-        temperature: 0.7
+        model: "llama-3.3-70b-versatile",
+        temperature: 0.7,
     });
 };
 exports.initGroq = initGroq;
 const streamChat = async (messages) => {
     if (!model)
         (0, exports.initGroq)();
-    const langChainMessages = messages.map(m => {
-        if (m.role === 'system')
+    const langChainMessages = messages.map((m) => {
+        if (m.role === "system")
             return new messages_1.SystemMessage(m.content);
-        if (m.role === 'user')
+        if (m.role === "user")
             return new messages_1.HumanMessage(m.content);
         return new messages_1.AIMessage(m.content);
     });

package/dist/lib/safety.js

@@ -33,23 +33,16 @@ class SafetyChecker {
      */
     isExtremelyDangerous(tool, params) {
         // Git operations that can't be easily undone
-        if (tool.name === 'git_push' && params.force) {
+        if (tool.name === "git_push" && params.force) {
             return true;
         }
-        if (tool.name === 'git_branch' && params.action === 'delete') {
+        if (tool.name === "git_branch" && params.action === "delete") {
             return true;
         }
         // Shell commands with dangerous patterns
-        if (tool.name === 'bash') {
-            const dangerous = [
-                /rm\s+-rf/,
-                /rm\s+.*\/\*/,
-                />\s*\/dev/,
-                /dd\s+if=/,
-                /mkfs/,
-                /format/i
-            ];
-            return dangerous.some(pattern => pattern.test(params.command));
+        if (tool.name === "bash") {
+            const dangerous = [/rm\s+-rf/, /rm\s+.*\/\*/, />\s*\/dev/, /dd\s+if=/, /mkfs/, /format/i];
+            return dangerous.some((pattern) => pattern.test(params.command));
         }
         return false;
     }
@@ -58,28 +51,28 @@ class SafetyChecker {
      */
     async promptConfirmation(tool, params) {
         const description = this.getOperationDescription(tool, params);
-        console.log('\n⚠️  Confirmation required:');
+        console.log("\n⚠️  Confirmation required:");
         console.log(`Tool: ${tool.name}`);
         console.log(`Operation: ${description}`);
-        console.log('');
+        console.log("");
         const { proceed, remember } = await inquirer_1.default.prompt([
             {
-                type: 'confirm',
-                name: 'proceed',
-                message: 'Do you want to proceed with this operation?',
-                default: false
+                type: "confirm",
+                name: "proceed",
+                message: "Do you want to proceed with this operation?",
+                default: false,
             },
             {
-                type: 'confirm',
-                name: 'remember',
-                message: 'Remember this choice for similar operations in this session?',
+                type: "confirm",
+                name: "remember",
+                message: "Remember this choice for similar operations in this session?",
                 default: false,
-                when: (answers) => answers.proceed
-            }
+                when: (answers) => answers.proceed,
+            },
         ]);
         return {
             confirmed: proceed,
-            rememberChoice: remember || false
+            rememberChoice: remember || false,
         };
     }
     /**
@@ -87,20 +80,22 @@ class SafetyChecker {
      */
     getOperationDescription(tool, params) {
         switch (tool.name) {
-            case 'write_file':
+            case "write_file":
                 return `Write to file: ${params.file_path}`;
-            case 'edit_file':
+            case "edit_file":
                 return `Edit file: ${params.file_path} (replace "${params.search.substring(0, 50)}...")`;
-            case 'bash':
+            case "bash":
                 return `Execute command: ${params.command}`;
-            case 'git_commit':
-                const files = params.files ? ` (${params.files.length} files)` : '';
+            case "git_commit": {
+                const files = params.files ? ` (${params.files.length} files)` : "";
                 return `Create git commit${files}: "${params.message}"`;
-            case 'git_push':
-                const force = params.force ? ' (FORCE)' : '';
-                return `Push to remote${force}: ${params.branch || 'current branch'}`;
-            case 'git_branch':
-                return `${params.action} branch: ${params.name || 'N/A'}`;
+            }
+            case "git_push": {
+                const force = params.force ? " (FORCE)" : "";
+                return `Push to remote${force}: ${params.branch || "current branch"}`;
+            }
+            case "git_branch":
+                return `${params.action} branch: ${params.name || "N/A"}`;
             default:
                 return JSON.stringify(params, null, 2);
         }