prab-cli 1.0.0 → 1.2.0

package/dist/lib/chat-handler.js

@@ -11,7 +11,13 @@ const tracker_1 = require("./tracker");
 class ChatHandler {
     constructor(toolRegistry, toolExecutor, modelProvider, initialContext) {
         this.messages = [];
-        this.contextMessage = '';
+        this.contextMessage = "";
+        this.usage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            requestCount: 0,
+        };
         this.toolRegistry = toolRegistry;
         this.toolExecutor = toolExecutor;
         this.modelProvider = modelProvider;
@@ -52,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
@@ -67,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);
@@ -92,7 +98,15 @@ When you need to perform file operations, use the appropriate tools rather than
                         if (chunk.tool_calls && chunk.tool_calls.length > 0) {
                             toolCalls = chunk.tool_calls;
                         }
+                        // Capture usage metadata from the chunk
+                        if (chunk.usage_metadata) {
+                            this.usage.promptTokens += chunk.usage_metadata.input_tokens || 0;
+                            this.usage.completionTokens += chunk.usage_metadata.output_tokens || 0;
+                            this.usage.totalTokens += chunk.usage_metadata.total_tokens || 0;
+                        }
                     }
+                    // Increment request count
+                    this.usage.requestCount++;
                     // Flush any remaining content in the formatter
                     const remaining = formatter.flush();
                     if (remaining) {
@@ -106,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);
@@ -114,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);
@@ -132,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;
                 }
@@ -143,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);
     }
@@ -178,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) {
@@ -197,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
@@ -205,6 +286,12 @@ When you need to perform file operations, use the appropriate tools rather than
     getMessageCount() {
         return this.messages.length;
     }
+    /**
+     * Get usage statistics
+     */
+    getUsageStats() {
+        return { ...this.usage };
+    }
     /**
      * Update context (e.g., if file tree changes)
      */
@@ -215,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);
         }

package/dist/lib/slash-commands.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLASH_COMMANDS = void 0;
+exports.showSlashCommandMenu = showSlashCommandMenu;
+const search_1 = __importDefault(require("@inquirer/search"));
+const chalk_1 = __importDefault(require("chalk"));
+exports.SLASH_COMMANDS = [
+    {
+        name: "/model",
+        description: "Switch between available AI models",
+        shortcut: "m",
+        action: "model",
+    },
+    {
+        name: "/usage",
+        description: "Show model info and session statistics",
+        shortcut: "u",
+        action: "usage",
+    },
+    {
+        name: "/tools",
+        description: "List all available tools",
+        shortcut: "t",
+        action: "tools",
+    },
+    {
+        name: "/todos",
+        description: "Display current todo list",
+        action: "todos",
+    },
+    {
+        name: "/clear-todos",
+        description: "Clear all todos",
+        action: "clear-todos",
+    },
+    {
+        name: "/context",
+        description: "Show file context from current directory",
+        shortcut: "c",
+        action: "context",
+    },
+    {
+        name: "/clear",
+        description: "Clear chat history",
+        action: "clear",
+    },
+    {
+        name: "/api-key",
+        description: "Update your Groq API key",
+        action: "api-key",
+    },
+    {
+        name: "/exit",
+        description: "Exit the application",
+        shortcut: "q",
+        action: "exit",
+    },
+];
+function formatCommandChoice(cmd) {
+    const shortcut = cmd.shortcut ? chalk_1.default.dim(` (${cmd.shortcut})`) : "";
+    return `${chalk_1.default.cyan(cmd.name)}${shortcut}  ${chalk_1.default.dim("─")}  ${cmd.description}`;
+}
+async function showSlashCommandMenu() {
+    try {
+        const answer = await (0, search_1.default)({
+            message: "Command",
+            source: async (input) => {
+                const searchTerm = (input || "").toLowerCase().replace(/^\//, "");
+                return exports.SLASH_COMMANDS.filter((cmd) => {
+                    if (!searchTerm)
+                        return true;
+                    return (cmd.name.toLowerCase().includes(searchTerm) ||
+                        cmd.description.toLowerCase().includes(searchTerm) ||
+                        cmd.shortcut?.toLowerCase() === searchTerm);
+                }).map((cmd) => ({
+                    name: formatCommandChoice(cmd),
+                    value: cmd.action,
+                    description: cmd.description,
+                }));
+            },
+        });
+        return answer;
+    }
+    catch (error) {
+        // User cancelled (Ctrl+C)
+        if (error.message?.includes("cancelled") || error.name === "ExitPromptError") {
+            return null;
+        }
+        throw error;
+    }
+}