prab-cli 1.0.0

package/dist/lib/chat-handler.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatHandler = void 0;
+const messages_1 = require("@langchain/core/messages");
+const context_1 = require("./context");
+const ui_1 = require("./ui");
+const tracker_1 = require("./tracker");
+/**
+ * Handles chat interactions with AI, tool calling, and context management
+ */
+class ChatHandler {
+    constructor(toolRegistry, toolExecutor, modelProvider, initialContext) {
+        this.messages = [];
+        this.contextMessage = '';
+        this.toolRegistry = toolRegistry;
+        this.toolExecutor = toolExecutor;
+        this.modelProvider = modelProvider;
+        this.contextMessage = initialContext;
+        // Initialize with system message
+        this.initializeSystemMessage();
+    }
+    /**
+     * Initialize system message with tool descriptions and context
+     */
+    initializeSystemMessage() {
+        const toolDescriptions = this.toolRegistry.getToolDescriptions();
+        const systemPrompt = `You are an expert AI coding assistant with access to powerful tools for file operations, shell commands, and git management.
+
+Available Tools:
+${toolDescriptions}
+
+Guidelines:
+- Use tools proactively to read, edit, and create files when the user asks for code changes
+- For multi-step tasks, use the manage_todos tool to track progress
+- Always use read_file before editing files to understand the current content
+- Use glob and grep to explore unfamiliar codebases
+- Provide clear explanations of what you're doing
+- Ask for clarification if requirements are ambiguous
+
+${this.contextMessage}
+
+When you need to perform file operations, use the appropriate tools rather than just suggesting changes.`;
+        this.messages.push(new messages_1.SystemMessage(systemPrompt));
+    }
+    /**
+     * Process user input and generate response with tool support
+     */
+    async processUserInput(input) {
+        const startTime = Date.now();
+        // Log prompt received
+        tracker_1.tracker.promptReceived(input);
+        try {
+            // Auto-attach file context if files are mentioned
+            const attachedFiles = await this.attachMentionedFiles(input);
+            let finalInput = input;
+            if (attachedFiles.length > 0) {
+                ui_1.log.info(`Attached context for: ${attachedFiles.join(', ')}`);
+                tracker_1.tracker.contextAttached(attachedFiles);
+            }
+            // Add user message
+            this.messages.push(new messages_1.HumanMessage(finalInput));
+            // Get tools as LangChain tools
+            const tools = this.toolRegistry.getAllAsLangChainTools();
+            // Main response loop (handles tool calls)
+            let continueLoop = true;
+            let iterationCount = 0;
+            const maxIterations = 10; // Prevent infinite loops
+            while (continueLoop && iterationCount < maxIterations) {
+                iterationCount++;
+                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 toolCalls = [];
+                const formatter = new ui_1.StreamFormatter();
+                process.stdout.write('\n');
+                try {
+                    for await (const chunk of stream) {
+                        // Handle text content
+                        if (chunk.content && typeof chunk.content === 'string') {
+                            fullResponse += chunk.content;
+                            // Format and output the chunk with syntax highlighting
+                            const formatted = formatter.processChunk(chunk.content);
+                            if (formatted) {
+                                process.stdout.write(formatted);
+                            }
+                        }
+                        // Handle tool calls
+                        if (chunk.tool_calls && chunk.tool_calls.length > 0) {
+                            toolCalls = chunk.tool_calls;
+                        }
+                    }
+                    // Flush any remaining content in the formatter
+                    const remaining = formatter.flush();
+                    if (remaining) {
+                        process.stdout.write(remaining);
+                    }
+                    // Log API response
+                    const apiDuration = Date.now() - apiStartTime;
+                    tracker_1.tracker.apiResponse(fullResponse.length > 0, toolCalls.length > 0, toolCalls.length, apiDuration);
+                }
+                catch (apiError) {
+                    tracker_1.tracker.apiError(apiError.message, { stack: apiError.stack });
+                    throw apiError;
+                }
+                process.stdout.write('\n\n');
+                // Log AI response if there's content
+                if (fullResponse.length > 0) {
+                    tracker_1.tracker.aiResponse(fullResponse);
+                }
+                // If we have tool calls, execute them
+                if (toolCalls.length > 0) {
+                    // Log AI's tool decision
+                    tracker_1.tracker.aiToolDecision(toolCalls.map(tc => ({
+                        name: tc.name,
+                        args: tc.args || {}
+                    })));
+                    // Add AI message with tool calls
+                    this.messages.push(new messages_1.AIMessage({
+                        content: fullResponse,
+                        tool_calls: toolCalls
+                    }));
+                    // Execute tools
+                    const results = await this.executeToolCalls(toolCalls);
+                    // Add tool results as messages
+                    for (let i = 0; i < toolCalls.length; i++) {
+                        const toolCall = toolCalls[i];
+                        const result = results[i];
+                        this.messages.push(new messages_1.ToolMessage({
+                            content: result.success ? result.output : `Error: ${result.error}`,
+                            tool_call_id: toolCall.id,
+                            name: toolCall.name
+                        }));
+                    }
+                    tracker_1.tracker.iteration(iterationCount, 'Tool execution complete, continuing loop');
+                    // Continue loop to get AI's response after tool execution
+                    continue;
+                }
+                else {
+                    // 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');
+                }
+            }
+            if (iterationCount >= maxIterations) {
+                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);
+        }
+        catch (error) {
+            ui_1.log.error(`Error: ${error.message}`);
+            tracker_1.tracker.promptFailed(input, error.message);
+            tracker_1.tracker.error('Chat processing failed', error);
+        }
+    }
+    /**
+     * Execute tool calls from AI
+     */
+    async executeToolCalls(toolCalls) {
+        const formattedCalls = toolCalls.map(tc => ({
+            id: tc.id || `call-${Date.now()}`,
+            name: tc.name,
+            args: tc.args || {}
+        }));
+        return await this.toolExecutor.executeMultiple(formattedCalls);
+    }
+    /**
+     * Auto-attach file context for mentioned files
+     */
+    async attachMentionedFiles(input) {
+        const allFiles = await (0, context_1.getFileTree)();
+        const attached = [];
+        for (const file of allFiles) {
+            const base = file.split('/').pop() || '';
+            const isBaseMatch = base.length > 2 && input.includes(base);
+            const isPathMatch = input.includes(file);
+            if (isPathMatch || isBaseMatch) {
+                const content = (0, context_1.getFileContent)(file);
+                if (content) {
+                    // Add file content to the messages as context
+                    attached.push(file);
+                }
+            }
+        }
+        return attached;
+    }
+    /**
+     * Clear chat history but keep system message
+     */
+    clearHistory() {
+        const systemMsg = this.messages[0];
+        this.messages = [systemMsg];
+        tracker_1.tracker.debug('Chat history cleared');
+    }
+    /**
+     * Get message count
+     */
+    getMessageCount() {
+        return this.messages.length;
+    }
+    /**
+     * Update context (e.g., if file tree changes)
+     */
+    updateContext(newContext) {
+        this.contextMessage = newContext;
+        // Re-initialize system message with new context
+        const systemMsg = this.messages[0];
+        this.messages[0] = systemMsg; // Keep the same message for now
+        // In a more sophisticated implementation, we'd rebuild the system message
+    }
+}
+exports.ChatHandler = ChatHandler;

package/dist/lib/config.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSessionData = exports.setSessionData = exports.getSessionData = exports.setPreference = exports.getPreferences = exports.setActiveModel = exports.getModelConfig = exports.clearApiKey = exports.setApiKey = exports.getApiKey = exports.getConfig = void 0;
+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 ensureConfigDir = () => {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+};
+const readConfig = () => {
+    try {
+        if (!fs_1.default.existsSync(CONFIG_FILE))
+            return {};
+        return JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+};
+const writeConfig = (data) => {
+    ensureConfigDir();
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2));
+};
+/**
+ * Get full config with defaults
+ */
+const getConfig = () => {
+    const config = readConfig();
+    // Handle legacy config format (old apiKey -> new apiKeys.groq)
+    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: '' },
+        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
+        },
+        session: config.session || { todos: [] }
+    };
+};
+exports.getConfig = getConfig;
+/**
+ * Get API key (backward compatible)
+ */
+const getApiKey = () => {
+    const config = (0, exports.getConfig)();
+    return config.apiKeys.groq || '';
+};
+exports.getApiKey = getApiKey;
+/**
+ * Set API key (backward compatible)
+ */
+const setApiKey = (key) => {
+    const config = readConfig();
+    if (!config.apiKeys) {
+        config.apiKeys = { groq: '' };
+    }
+    config.apiKeys.groq = key;
+    writeConfig(config);
+};
+exports.setApiKey = setApiKey;
+/**
+ * Clear API key (backward compatible)
+ */
+const clearApiKey = () => {
+    const config = readConfig();
+    if (config.apiKeys) {
+        config.apiKeys.groq = '';
+    }
+    writeConfig(config);
+};
+exports.clearApiKey = clearApiKey;
+/**
+ * Get active model configuration
+ */
+const getModelConfig = () => {
+    const config = (0, exports.getConfig)();
+    return {
+        modelId: config.activeModel,
+        temperature: config.preferences.temperature
+    };
+};
+exports.getModelConfig = getModelConfig;
+/**
+ * Set active model
+ */
+const setActiveModel = (modelId) => {
+    const config = readConfig();
+    config.activeModel = modelId;
+    writeConfig(config);
+};
+exports.setActiveModel = setActiveModel;
+/**
+ * Get user preferences
+ */
+const getPreferences = () => {
+    return (0, exports.getConfig)().preferences;
+};
+exports.getPreferences = getPreferences;
+/**
+ * Set a preference
+ */
+const setPreference = (key, value) => {
+    const config = readConfig();
+    if (!config.preferences) {
+        config.preferences = {
+            temperature: 0.7,
+            autoConfirm: false,
+            safeMode: true
+        };
+    }
+    config.preferences[key] = value;
+    writeConfig(config);
+};
+exports.setPreference = setPreference;
+/**
+ * Get session data (todos, etc.)
+ */
+const getSessionData = () => {
+    const config = (0, exports.getConfig)();
+    return config.session || { todos: [] };
+};
+exports.getSessionData = getSessionData;
+/**
+ * Set session data
+ */
+const setSessionData = (data) => {
+    const config = readConfig();
+    config.session = data;
+    writeConfig(config);
+};
+exports.setSessionData = setSessionData;
+/**
+ * Clear session data
+ */
+const clearSessionData = () => {
+    const config = readConfig();
+    config.session = { todos: [] };
+    writeConfig(config);
+};
+exports.clearSessionData = clearSessionData;

package/dist/lib/context.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFile = exports.getFileContent = exports.getFileTree = exports.isGitRepo = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const glob_1 = require("glob");
+const fs_1 = __importDefault(require("fs"));
+const git = (0, simple_git_1.default)();
+const isGitRepo = async () => {
+    try {
+        return await git.checkIsRepo();
+    }
+    catch (e) {
+        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 });
+    return files;
+};
+exports.getFileTree = getFileTree;
+const getFileContent = (filePath) => {
+    try {
+        return fs_1.default.readFileSync(filePath, 'utf-8');
+    }
+    catch (e) {
+        return '';
+    }
+};
+exports.getFileContent = getFileContent;
+const writeFile = (filePath, content) => {
+    try {
+        fs_1.default.writeFileSync(filePath, content, 'utf-8');
+    }
+    catch (e) {
+        throw e;
+    }
+};
+exports.writeFile = writeFile;

package/dist/lib/groq-models.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchGroqModels = fetchGroqModels;
+exports.groupModelsByOwner = groupModelsByOwner;
+exports.formatContextWindow = formatContextWindow;
+const groq_sdk_1 = __importDefault(require("groq-sdk"));
+/**
+ * Fetch available models from Groq API
+ */
+async function fetchGroqModels(apiKey) {
+    try {
+        const groq = new groq_sdk_1.default({ apiKey });
+        const response = await groq.models.list();
+        // Filter and sort models
+        const models = response.data
+            .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);
+        return [];
+    }
+}
+/**
+ * Group models by provider/owner
+ */
+function groupModelsByOwner(models) {
+    const groups = new Map();
+    for (const model of models) {
+        const owner = model.owned_by || 'Other';
+        if (!groups.has(owner)) {
+            groups.set(owner, []);
+        }
+        groups.get(owner).push(model);
+    }
+    return groups;
+}
+/**
+ * Format context window size
+ */
+function formatContextWindow(tokens) {
+    if (tokens >= 1000000) {
+        return `${(tokens / 1000000).toFixed(0)}M`;
+    }
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(0)}K`;
+    }
+    return `${tokens}`;
+}

package/dist/lib/groq.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamChat = exports.initGroq = void 0;
+const groq_1 = require("@langchain/groq");
+const messages_1 = require("@langchain/core/messages");
+const config_1 = require("./config");
+let model = null;
+const initGroq = () => {
+    const apiKey = (0, config_1.getApiKey)();
+    if (!apiKey) {
+        throw new Error('API Key not found');
+    }
+    model = new groq_1.ChatGroq({
+        apiKey,
+        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')
+            return new messages_1.SystemMessage(m.content);
+        if (m.role === 'user')
+            return new messages_1.HumanMessage(m.content);
+        return new messages_1.AIMessage(m.content);
+    });
+    const stream = await model.stream(langChainMessages);
+    return stream;
+};
+exports.streamChat = streamChat;

package/dist/lib/models/groq-provider.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroqProvider = void 0;
+const groq_1 = require("@langchain/groq");
+const provider_1 = require("./provider");
+/**
+ * Groq model provider implementation
+ * Supports multiple Groq models with function calling
+ */
+class GroqProvider extends provider_1.ModelProvider {
+    constructor(modelId = 'llama-3.3-70b-versatile', temperature = 0.7) {
+        super();
+        this.name = 'groq';
+        this.supportsFunctionCalling = true;
+        this.model = null;
+        this.apiKey = '';
+        this.temperature = 0.7;
+        this.modelId = modelId;
+        this.temperature = temperature;
+    }
+    /**
+     * Initialize the Groq model
+     */
+    initialize(apiKey, modelId) {
+        this.apiKey = apiKey;
+        if (modelId) {
+            this.modelId = modelId;
+        }
+        this.model = new groq_1.ChatGroq({
+            apiKey: this.apiKey,
+            model: this.modelId,
+            temperature: this.temperature
+        });
+    }
+    /**
+     * Stream chat with optional tool support
+     */
+    async *streamChat(messages, tools) {
+        if (!this.model) {
+            throw new Error('Model not initialized. Call initialize() first.');
+        }
+        // Bind tools if provided
+        const modelToUse = tools && tools.length > 0
+            ? this.model.bindTools(tools)
+            : this.model;
+        // Stream the response
+        const stream = await modelToUse.stream(messages);
+        for await (const chunk of stream) {
+            yield chunk;
+        }
+    }
+    /**
+     * Get model information
+     */
+    getInfo() {
+        return {
+            id: this.modelId,
+            provider: 'groq',
+            capabilities: ['chat', 'streaming', 'function_calling'],
+            description: `Groq model: ${this.modelId}`
+        };
+    }
+    /**
+     * Update model configuration
+     */
+    setModel(modelId) {
+        this.modelId = modelId;
+        if (this.apiKey) {
+            this.initialize(this.apiKey, modelId);
+        }
+    }
+    /**
+     * Update temperature
+     */
+    setTemperature(temperature) {
+        this.temperature = temperature;
+        if (this.apiKey) {
+            this.initialize(this.apiKey, this.modelId);
+        }
+    }
+}
+exports.GroqProvider = GroqProvider;

package/dist/lib/models/provider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelProvider = void 0;
+/**
+ * Abstract base class for model providers
+ * Implementations handle specific AI service integrations
+ */
+class ModelProvider {
+}
+exports.ModelProvider = ModelProvider;