prab-cli 1.0.0

package/dist/lib/models/registry.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_REGISTRY = void 0;
+exports.getModelInfo = getModelInfo;
+exports.isValidModel = isValidModel;
+exports.getAllModelIds = getAllModelIds;
+exports.getDefaultModel = getDefaultModel;
+exports.getModelList = getModelList;
+exports.validateModelId = validateModelId;
+/**
+ * Registry of available models with their metadata
+ * Note: Whisper models are excluded as they are audio transcription models, not chat models
+ */
+exports.MODEL_REGISTRY = {
+    // OpenAI-compatible models on Groq - Better function calling
+    'openai/gpt-oss-20b': {
+        id: 'openai/gpt-oss-20b',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'GPT-OSS 20B - OpenAI-compatible model with better function calling'
+    },
+    // Groq Models
+    'llama-3.3-70b-versatile': {
+        id: 'llama-3.3-70b-versatile',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'Llama 3.3 70B - Fast and versatile, great for coding tasks'
+    },
+    'llama-3.1-70b-versatile': {
+        id: 'llama-3.1-70b-versatile',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'Llama 3.1 70B - Versatile model for various tasks'
+    },
+    'llama-3.1-8b-instant': {
+        id: 'llama-3.1-8b-instant',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'Llama 3.1 8B - Fast and efficient for quick responses'
+    },
+    'mixtral-8x7b-32768': {
+        id: 'mixtral-8x7b-32768',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'Mixtral 8x7B - Excellent for complex reasoning'
+    },
+    'gemma2-9b-it': {
+        id: 'gemma2-9b-it',
+        provider: 'groq',
+        capabilities: ['chat', 'streaming', 'function_calling'],
+        description: 'Gemma 2 9B - Google\'s efficient instruction-tuned model'
+    }
+};
+/**
+ * Get model information by ID
+ */
+function getModelInfo(modelId) {
+    return exports.MODEL_REGISTRY[modelId];
+}
+/**
+ * Check if a model ID is valid
+ */
+function isValidModel(modelId) {
+    return modelId in exports.MODEL_REGISTRY;
+}
+/**
+ * Get all available model IDs
+ */
+function getAllModelIds() {
+    return Object.keys(exports.MODEL_REGISTRY);
+}
+/**
+ * Get default model ID
+ */
+function getDefaultModel() {
+    return 'openai/gpt-oss-20b';
+}
+/**
+ * Get formatted list of models for display
+ */
+function getModelList() {
+    return Object.values(exports.MODEL_REGISTRY)
+        .map(model => `  ${model.id}\n    ${model.description}`)
+        .join('\n\n');
+}
+/**
+ * Validate and sanitize model ID
+ */
+function validateModelId(modelId) {
+    if (isValidModel(modelId)) {
+        return { valid: true };
+    }
+    // Try to find similar models
+    const allIds = getAllModelIds();
+    const similar = allIds.find(id => id.toLowerCase().includes(modelId.toLowerCase()));
+    return {
+        valid: false,
+        error: `Invalid model ID: ${modelId}`,
+        suggested: similar
+    };
+}

package/dist/lib/safety.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafetyChecker = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const config_1 = require("./config");
+/**
+ * Safety checker for tool operations
+ * Determines when to ask for user confirmation
+ */
+class SafetyChecker {
+    /**
+     * Check if a tool operation should require confirmation
+     */
+    async shouldConfirm(tool, params) {
+        const prefs = (0, config_1.getPreferences)();
+        // If autoConfirm is true and safeMode is false, skip most confirmations
+        if (prefs.autoConfirm && !prefs.safeMode) {
+            // Still confirm for extremely dangerous operations
+            return this.isExtremelyDangerous(tool, params);
+        }
+        // Safe mode: always confirm destructive operations
+        if (prefs.safeMode && tool.destructive) {
+            return true;
+        }
+        // Regular mode: confirm based on tool requirements
+        return tool.requiresConfirmation;
+    }
+    /**
+     * Check if an operation is extremely dangerous (always confirm)
+     */
+    isExtremelyDangerous(tool, params) {
+        // Git operations that can't be easily undone
+        if (tool.name === 'git_push' && params.force) {
+            return true;
+        }
+        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));
+        }
+        return false;
+    }
+    /**
+     * Prompt user for confirmation
+     */
+    async promptConfirmation(tool, params) {
+        const description = this.getOperationDescription(tool, params);
+        console.log('\n⚠️  Confirmation required:');
+        console.log(`Tool: ${tool.name}`);
+        console.log(`Operation: ${description}`);
+        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: 'remember',
+                message: 'Remember this choice for similar operations in this session?',
+                default: false,
+                when: (answers) => answers.proceed
+            }
+        ]);
+        return {
+            confirmed: proceed,
+            rememberChoice: remember || false
+        };
+    }
+    /**
+     * Get a human-readable description of the operation
+     */
+    getOperationDescription(tool, params) {
+        switch (tool.name) {
+            case 'write_file':
+                return `Write to file: ${params.file_path}`;
+            case 'edit_file':
+                return `Edit file: ${params.file_path} (replace "${params.search.substring(0, 50)}...")`;
+            case 'bash':
+                return `Execute command: ${params.command}`;
+            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'}`;
+            default:
+                return JSON.stringify(params, null, 2);
+        }
+    }
+}
+exports.SafetyChecker = SafetyChecker;

package/dist/lib/tools/base.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.Tool = void 0;
+const tools_1 = require("@langchain/core/tools");
+/**
+ * Base interface for all tools
+ */
+class Tool {
+    /**
+     * Get a short summary of what this tool does for the AI
+     */
+    getSummary() {
+        return `${this.name}: ${this.description}`;
+    }
+    /**
+     * Convert this tool to a LangChain tool for binding to models
+     */
+    toLangChainTool() {
+        return new tools_1.DynamicStructuredTool({
+            name: this.name,
+            description: this.description,
+            schema: this.schema,
+            func: async (input) => {
+                const result = await this.execute(input);
+                if (!result.success) {
+                    throw new Error(result.error || 'Tool execution failed');
+                }
+                return result.output;
+            }
+        });
+    }
+    /**
+     * Format a successful result
+     */
+    success(output, metadata) {
+        return {
+            success: true,
+            output,
+            metadata
+        };
+    }
+    /**
+     * Format an error result
+     */
+    error(error, metadata) {
+        return {
+            success: false,
+            output: '',
+            error,
+            metadata
+        };
+    }
+}
+exports.Tool = Tool;
+/**
+ * Registry to manage all available tools
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    /**
+     * Register a tool
+     */
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    /**
+     * Get a tool by name
+     */
+    get(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Get all registered tools
+     */
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get all tools as LangChain tools
+     */
+    getAllAsLangChainTools() {
+        return this.getAll().map(tool => tool.toLangChainTool());
+    }
+    /**
+     * Get a description of all tools for the AI system prompt
+     */
+    getToolDescriptions() {
+        const descriptions = this.getAll().map(tool => {
+            const params = Object.keys(tool.schema.shape).join(', ');
+            return `- ${tool.name}(${params}): ${tool.description}`;
+        });
+        return descriptions.join('\n');
+    }
+    /**
+     * Get list of tool names
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+    /**
+     * Check if a tool exists
+     */
+    has(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * Get count of registered tools
+     */
+    count() {
+        return this.tools.size;
+    }
+}
+exports.ToolRegistry = ToolRegistry;

package/dist/lib/tools/executor.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+const ui_1 = require("../ui");
+const tracker_1 = require("../tracker");
+const ora_1 = __importDefault(require("ora"));
+/**
+ * Executes tools called by the AI
+ */
+class ToolExecutor {
+    constructor(registry, safetyChecker) {
+        this.sessionOverrides = new Map();
+        this.registry = registry;
+        this.safetyChecker = safetyChecker;
+    }
+    /**
+     * Execute a single tool call
+     */
+    async executeSingle(toolCall) {
+        const tool = this.registry.get(toolCall.name);
+        const startTime = Date.now();
+        if (!tool) {
+            tracker_1.tracker.toolError(toolCall.name, 'Tool not found', 0);
+            return {
+                success: false,
+                output: '',
+                error: `Tool '${toolCall.name}' not found`
+            };
+        }
+        // Log tool start
+        tracker_1.tracker.toolStart(tool.name, toolCall.args);
+        try {
+            // Check if confirmation is needed
+            const needsConfirm = await this.safetyChecker.shouldConfirm(tool, toolCall.args);
+            if (needsConfirm) {
+                // Check session override
+                const overrideKey = `${tool.name}:${JSON.stringify(toolCall.args)}`;
+                if (!this.sessionOverrides.get(overrideKey)) {
+                    const { confirmed, rememberChoice } = await this.safetyChecker.promptConfirmation(tool, toolCall.args);
+                    if (!confirmed) {
+                        const duration = Date.now() - startTime;
+                        tracker_1.tracker.toolCancelled(tool.name);
+                        return {
+                            success: false,
+                            output: '',
+                            error: 'Operation cancelled by user'
+                        };
+                    }
+                    if (rememberChoice) {
+                        this.sessionOverrides.set(overrideKey, true);
+                    }
+                }
+            }
+            // Execute the tool with spinner feedback
+            const spinner = (0, ora_1.default)(`Executing ${tool.name}...`).start();
+            ui_1.log.tool(tool.name, 'executing');
+            const result = await tool.execute(toolCall.args);
+            const duration = Date.now() - startTime;
+            if (result.success) {
+                spinner.succeed(`${tool.name} completed`);
+                ui_1.log.toolResult(true, result.output);
+                // Show formatted output with colors
+                if (result.output && result.output.trim()) {
+                    ui_1.log.toolOutput(tool.name, result.output);
+                }
+                tracker_1.tracker.toolSuccess(tool.name, result.output, duration);
+            }
+            else {
+                spinner.fail(`${tool.name} failed`);
+                ui_1.log.toolResult(false, result.error || 'Unknown error');
+                // Log error with args for debugging
+                tracker_1.tracker.toolError(tool.name, result.error || 'Unknown error', duration, toolCall.args);
+            }
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            ui_1.log.error(`Tool execution error: ${error.message}`);
+            tracker_1.tracker.toolError(tool.name, error.message, duration, toolCall.args);
+            return {
+                success: false,
+                output: '',
+                error: error.message || 'Unknown error occurred'
+            };
+        }
+    }
+    /**
+     * Execute multiple tool calls in sequence
+     */
+    async executeMultiple(toolCalls) {
+        const results = [];
+        for (const toolCall of toolCalls) {
+            const result = await this.executeSingle(toolCall);
+            results.push(result);
+            // If a tool fails, we might want to continue or stop
+            // For now, we continue executing remaining tools
+        }
+        return results;
+    }
+    /**
+     * Format tool results as messages for the AI
+     */
+    formatResultsAsMessages(toolCalls, results) {
+        return toolCalls.map((call, index) => {
+            const result = results[index];
+            const content = result.success
+                ? result.output
+                : `Error: ${result.error}`;
+            return {
+                role: 'tool',
+                content,
+                tool_call_id: call.id,
+                name: call.name
+            };
+        });
+    }
+    /**
+     * Clear session overrides (confirmations)
+     */
+    clearSessionOverrides() {
+        this.sessionOverrides.clear();
+    }
+}
+exports.ToolExecutor = ToolExecutor;