camo-cli 2.0.1

package/dist/components/HITLConfirmation.js

@@ -0,0 +1,89 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export const HITLConfirmation = ({ request, onResolve }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const options = ['Accept', 'Accept for Session', 'Deny'];
+    useInput((input, key) => {
+        if (key.leftArrow || key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+        }
+        if (key.rightArrow || key.downArrow) {
+            setSelectedIndex(prev => Math.min(options.length - 1, prev + 1));
+        }
+        // Number shortcuts
+        if (input === '1')
+            handleSelect(0);
+        if (input === '2')
+            handleSelect(1);
+        if (input === '3')
+            handleSelect(2);
+        if (key.return) {
+            handleSelect(selectedIndex);
+        }
+    });
+    const handleSelect = (index) => {
+        if (index === 0)
+            onResolve(true, 'once');
+        if (index === 1)
+            onResolve(true, 'session');
+        if (index === 2)
+            onResolve(false, 'once');
+    };
+    const renderDiff = (diff) => {
+        const lines = diff.split('\n');
+        // Find hunks (lines starting with @@)
+        const hunkIndices = [];
+        lines.forEach((line, idx) => {
+            if (line.startsWith('@@'))
+                hunkIndices.push(idx);
+        });
+        // Limit to first 2 hunks
+        const maxHunks = 2;
+        const showTruncated = hunkIndices.length > maxHunks;
+        let endLineIdx = lines.length;
+        if (showTruncated && hunkIndices.length > maxHunks) {
+            // Find where 3rd hunk starts
+            endLineIdx = hunkIndices[maxHunks];
+        }
+        const displayLines = lines.slice(0, endLineIdx);
+        return (React.createElement(React.Fragment, null,
+            displayLines.map((line, i) => {
+                if (line.startsWith('+++') || line.startsWith('---')) {
+                    return React.createElement(Text, { key: i, color: "cyan", dimColor: true }, line);
+                }
+                if (line.startsWith('@@')) {
+                    return React.createElement(Text, { key: i, color: "blue", bold: true }, line);
+                }
+                if (line.startsWith('+')) {
+                    return React.createElement(Text, { key: i, color: "green" }, line);
+                }
+                if (line.startsWith('-')) {
+                    return React.createElement(Text, { key: i, color: "red" }, line);
+                }
+                // Context lines (no prefix or space prefix)
+                return React.createElement(Text, { key: i, color: "gray", dimColor: true }, line);
+            }),
+            showTruncated && (React.createElement(Text, { color: "yellow", italic: true },
+                "... (",
+                hunkIndices.length - maxHunks,
+                " more hunk",
+                hunkIndices.length - maxHunks > 1 ? 's' : '',
+                ")"))));
+    };
+    return (React.createElement(Box, { borderStyle: "double", borderColor: "white", flexDirection: "column", paddingX: 1, marginBottom: 1 },
+        React.createElement(Text, { bold: true, backgroundColor: "white", color: "black" }, " CRITICAL OPERATION REQUIRED "),
+        React.createElement(Text, { color: "white" },
+            "Action: ",
+            React.createElement(Text, { bold: true }, request.type)),
+        React.createElement(Text, null, request.command ? `Command: ${request.command}` : `File: ${request.path}`),
+        React.createElement(Text, { italic: true, color: "gray" },
+            "Reason: ",
+            request.reason),
+        request.diff && (React.createElement(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1 },
+            React.createElement(Text, { bold: true }, "Changes:"),
+            renderDiff(request.diff))),
+        React.createElement(Box, { marginTop: 1, gap: 2 }, options.map((opt, i) => (React.createElement(Text, { key: opt, color: i === selectedIndex ? "black" : "white", backgroundColor: i === selectedIndex ? "white" : undefined },
+            i + 1,
+            ". ",
+            opt))))));
+};

package/dist/components/ModelSelector.js

@@ -0,0 +1,100 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { config } from './App.js';
+const PROVIDERS = [
+    { id: 'google', name: 'Google', keyName: 'googleApiKey' },
+    { id: 'anthropic', name: 'Anthropic', keyName: 'anthropicApiKey' },
+    { id: 'openai', name: 'OpenAI', keyName: 'openaiApiKey' },
+    { id: 'openrouter', name: 'OpenRouter', keyName: 'openrouterApiKey' },
+    { id: 'custom', name: 'Custom', keyName: 'customApiKey' }, // Custom needs URL too, handled specially
+];
+export const ModelSelector = ({ onClose }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [isEditing, setIsEditing] = useState(false);
+    const [editValue, setEditValue] = useState('');
+    // Custom specific
+    const [isEditingUrl, setIsEditingUrl] = useState(false);
+    const [customUrl, setCustomUrl] = useState(config.get('customBaseUrl') || '');
+    // Effect to load current key when selection changes
+    useEffect(() => {
+        // optional logic
+    }, [selectedIndex]);
+    useInput((input, key) => {
+        if (isEditing) {
+            // Handled by TextInput, but we need to catch Escape to cancel
+            if (key.escape) {
+                setIsEditing(false);
+                setIsEditingUrl(false);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+        }
+        if (key.downArrow) {
+            setSelectedIndex(prev => Math.min(PROVIDERS.length - 1, prev + 1));
+        }
+        if (key.return) {
+            startEditing();
+        }
+        if (key.escape) {
+            onClose();
+        }
+    });
+    const startEditing = () => {
+        const provider = PROVIDERS[selectedIndex];
+        const currentKey = config.get(provider.keyName) || '';
+        setEditValue(currentKey);
+        setIsEditing(true);
+        // For custom, we might want to edit URL first or Key?
+        // Let's Keep it simple: Enter -> Edit Key. 
+        // If Custom, maybe cycle Key -> URL? Or show both inputs.
+        // For simplicity: Custom just edits Key now. URL is advanced. 
+        // Wait, requirement: "Bei 'Custom' kann man eine Basis-URL und einen API-Key hinterlegen."
+        // I'll handle Custom differently if selected.
+    };
+    const saveKey = (value) => {
+        const provider = PROVIDERS[selectedIndex];
+        if (provider.id === 'custom' && isEditingUrl) {
+            config.set('customBaseUrl', value);
+            setIsEditingUrl(false);
+            // Then edit key
+            setEditValue(config.get('customApiKey') || '');
+            setIsEditing(true); // Stay editing, but now for key
+            return;
+        }
+        if (value.trim()) {
+            config.set(provider.keyName, value.trim());
+        }
+        else {
+            config.delete(provider.keyName);
+        }
+        setIsEditing(false);
+    };
+    const renderProvider = (p, index) => {
+        const isSelected = index === selectedIndex;
+        const hasKey = config.has(p.keyName);
+        // Visuals: "Provider mit hinterlegtem Key sind hellgrau, ohne Key dunkelgrau."
+        // Ink colors: 'white', 'gray', 'bgWhite', etc.
+        // Selected: Invert or Highlight.
+        let color = hasKey ? 'whiteBright' : 'gray';
+        let label = ` ${p.name} `;
+        if (isSelected) {
+            label = `> ${p.name} <`;
+            color = 'white'; // Highlight
+        }
+        return (React.createElement(Box, { key: p.id, flexDirection: "row", justifyContent: "space-between" },
+            React.createElement(Text, { color: color, bold: isSelected }, label),
+            React.createElement(Text, { color: "gray" }, hasKey ? '[*]' : '')));
+    };
+    return (React.createElement(Box, { borderStyle: "single", flexDirection: "column", paddingX: 1, borderColor: "white", marginBottom: 1 },
+        React.createElement(Text, { bold: true }, "Select Model Provider"),
+        React.createElement(Box, { flexDirection: "column", marginTop: 1 }, PROVIDERS.map((p, i) => renderProvider(p, i))),
+        isEditing && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, null,
+                "API Key for ",
+                PROVIDERS[selectedIndex].name,
+                ":"),
+            React.createElement(TextInput, { value: editValue, onChange: setEditValue, onSubmit: saveKey, mask: PROVIDERS[selectedIndex].id === 'custom' ? undefined : '*', focus: true })))));
+};

package/dist/components/SetupScreen.js

@@ -0,0 +1,43 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { config } from '../config/store.js';
+export const SetupScreen = ({ onComplete }) => {
+    const [apiKey, setApiKey] = useState('');
+    const [error, setError] = useState('');
+    useInput((_, key) => {
+        if (key.return) {
+            handleSubmit();
+        }
+    });
+    const handleSubmit = () => {
+        const key = apiKey.trim();
+        if (!key) {
+            setError('API Key is required');
+            return;
+        }
+        if (!key.startsWith('AIza')) {
+            setError('Invalid Google API Key (must start with AIza)');
+            return;
+        }
+        config.set('googleApiKey', key);
+        // Clear others to ensure clean state
+        config.delete('anthropicApiKey');
+        config.delete('openaiApiKey');
+        onComplete();
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1, borderStyle: "round", borderColor: "green" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\uD83E\uDD8E CAMO Setup")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null, "Welcome to CAMO. To get started, please connect your Google Gemini API Key.")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "gray" }, "Get your key at: https://aistudio.google.com/app/apikey")),
+        React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Google API Key:"),
+            React.createElement(Box, { borderStyle: "single", borderColor: error ? "red" : "gray" },
+                React.createElement(TextInput, { value: apiKey, onChange: setApiKey, onSubmit: handleSubmit, mask: "*", placeholder: "Paste your AIza... key here" })),
+            error && React.createElement(Text, { color: "red" }, error)),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, "Press Enter to save and start"))));
+};

package/dist/config/constants.js

@@ -0,0 +1,58 @@
+/**
+ * Configuration constants for CAMO agent
+ */
+// Timeouts
+export const SHELL_TIMEOUT_MS = 30000; // 30 seconds
+export const MAX_LOOPS = 15;
+// Limits
+export const MAX_FILE_SIZE = 8000; // Characters for readFile
+export const MAX_SHELL_OUTPUT = 2000; // Characters for shell output
+export const MAX_GREP_RESULTS = 20; // Lines for grep
+export const MAX_FILE_LIST = 10; // Files shown in listFiles
+// Excluded directories
+export const EXCLUDED_DIRS = ['node_modules', '.git', '.DS_Store', 'dist', 'build', '.next'];
+// Security: Blocked shell commands (never allowed, even with HITL)
+export const BLOCKED_COMMANDS = [
+    /^sudo\s+rm\s+-rf\s+\/$/,
+    /^rm\s+-rf\s+\/$/,
+    /^rm\s+-rf\s+~$/,
+    /^chmod\s+777\s+\/$/,
+    /^:(){ :|:& };:/, // Fork bomb
+    /^dd\s+if=.*of=\/dev\//,
+    /^mkfs\./,
+    /^format\s/
+];
+// Safe shell patterns (auto-approved)
+export const SAFE_SHELL_PATTERNS = [
+    // Read operations
+    /^(ls|cat|head|tail|less|more|grep|find|which|pwd|echo|date)\s/,
+    /^git\s+(status|log|diff|branch|show)/,
+    // Package managers (read-only)
+    /^(npm|yarn|pnpm)\s+(list|ls|outdated|view|info)/,
+    // Test runners
+    /^(jest|vitest|mocha|ava)\s/,
+    // Build tools (read-only check)
+    /^(tsc|eslint|prettier)\s+--noEmit/,
+    // Other safe commands
+    /^(date|echo|printf|which|type|command\s+-v)/
+];
+// Critical shell patterns (require HITL)
+export const CRITICAL_SHELL_PATTERNS = [
+    /^(rm|mv|cp)\s/,
+    /^git\s+(push|commit|add|reset|rebase|merge|cherry-pick|pull)/,
+    /^(npm|yarn|pnpm)\s+(install|i|add|remove|uninstall|publish|run\s+(?!test))/,
+    /^(curl|wget|fetch)\s/,
+    /^chmod\s/,
+    /^sudo\s/,
+    />/, // Output redirection
+    />>/ // Append redirection
+];
+// Safe tools (auto-approved without HITL)
+export const SAFE_TOOLS = new Set([
+    'readFile',
+    'listFiles',
+    'grep',
+    'webFetch',
+    'internal_thought',
+    'ToDoWrite'
+]);

package/dist/config/prompts.js

@@ -0,0 +1,98 @@
+/**
+ * System prompts for CAMO agent
+ * Based on OpenAI Codex CLI + Claude Code best practices
+ */
+export const ELITE_SYSTEM_PROMPT = `You are CAMO, an autonomous coding agent running in a terminal environment.
+
+# CONSTITUTION
+
+## Your Role
+You are an AI coding assistant integrated into the user's development workflow. You can:
+- Read and write files
+- Execute terminal commands  
+- Search codebases
+- Apply code patches
+- Navigate directory structures
+
+You communicate through streaming text responses and emit function calls to interact with the system.
+
+## Tone & Communication
+- **Concise**: Brief, direct answers. No preambles or disclaimers.
+- **Action-First**: Execute immediately. Never ask "Soll ich...?" or "Should I...?"
+- **Clear**: State what you're doing, not what you could do.
+- **Adaptive**: Respond in the user's language (detect from input).
+
+## Core Behaviors
+
+### 1. Autonomous Execution
+✓ Persist until task is fully resolved before yielding
+✓ Handle errors autonomously - retry, adapt, or escalate
+✓ Break complex requests into sub-problems automatically
+✗ Never stop mid-task to ask for permission
+✗ Don't suggest solutions - implement them
+
+### 2. Automatic Error Recovery (NON-NEGOTIABLE)
+You MUST autonomously recover from errors without stopping.
+
+- **IF \`readFile\` -> EISDIR**: usage error! DO NOT apologize. IMMEDIATELY call \`listFiles\` on that path in the SAME turn if possible, or the very next.
+- **IF \`readFile\` -> ENOENT**: wrong path! Search parent dir with \`listFiles\` or \`find\`.
+- **IF tool fails**: Ask yourself "Can I fix this?" If yes, EXECUTE the fix. Do not ask the user "Should I try...?"
+
+### 3. Tool Usage Protocol
+When executing tools:
+1. State your action briefly (one line)
+2. Call the tool ONCE
+3. [System provides result]
+4. Summarize outcome clearly and STOP
+
+### 4. Path Resolution (CRITICAL)
+**ALWAYS prefer paths relative to the current working directory:**
+- ✓ Use \`.\`, \`./subdir/file.txt\`, \`src/component.tsx\`
+- ✓ When user says "camo test dir", interpret as \`./camo-test/\` (local)
+- ✗ Do NOT use absolute paths like \`/sessions/\`, \`/Users/...\` unless explicitly given
+- The working directory is the user's project root - ALL paths are relative to it
+
+CRITICAL: After calling a tool and receiving its result, ALWAYS:
+- Provide a brief summary of what was found/done
+- Mark task as complete
+- DO NOT call the same tool multiple times
+- DO NOT continue exploring unless explicitly asked
+
+IMPORTANT: When the task is done, ALWAYS provide a final natural language response summarizing the findings or actions (e.g. "I found the issue in file X..."). Do not just stop after a tool output.
+
+Example:
+User: "list files in src/"
+You: "Listing source files"
+[listFiles called, result returned]
+You: "Found 12 TypeScript files: index.ts, agent.ts, utils.ts, and 9 others"
+[STOP - task complete]
+
+### 3. Communication Standards
+DO:
+- ✓ "Creating test.txt" → [calls writeFile]
+- ✓ "Running tests" → [calls executeShellCommand]  
+- ✓ "Found 3 errors in app.ts" (specific, actionable)
+
+DON'T:
+- ✗ "I can list the files for you" (just do it)
+- ✗ "Would you like me to..." (never ask permission)
+- ✗ Long explanations before acting (act first, explain after if needed)
+
+### 4. Safety & Verification
+- Verify critical changes by reading back modified files
+- For destructive operations (rm, git push), acknowledge action clearly
+- If unsure about scope, ask clarifying questions BEFORE acting, not during
+
+## Available Tools
+
+\`writeFile(path, content)\` - Create or overwrite file
+\`readFile(path)\` - Read file content (returns full content)
+\`editFile(path, unifiedDiff)\` - Apply unified diff patch
+\`executeShellCommand(command)\` - Run terminal command
+\`listFiles(path)\` - List directory contents  
+\`grep(pattern, path)\` - Search in files
+
+## Important Context
+{{PROJECT_CONTEXT}}
+{{TASK_STATE}}
+`;

package/dist/config/store.js

@@ -0,0 +1,5 @@
+import Conf from 'conf';
+export const config = new Conf({
+    projectName: 'camo-cli',
+    projectSuffix: '',
+});

package/dist/core/AgentLoop.js

@@ -0,0 +1,159 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { config } from '../config/store.js';
+import { ELITE_SYSTEM_PROMPT } from '../config/prompts.js';
+import { TaskState } from '../utils/TaskState.js';
+import { ToolRegistry } from '../tools/ToolRegistry.js';
+import { formatToolCall, formatToolOutput } from '../utils/uiFormatter.js';
+import { MAX_LOOPS } from '../config/constants.js';
+import { MemoryManager } from '../memory/MemoryManager.js';
+// Tool definitions for Google Native SDK (add memory tools)
+const googleToolDefinitions = [
+    { name: 'writeFile', description: 'Create or overwrite a file', parameters: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] } },
+    { name: 'readFile', description: 'Read file contents', parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] } },
+    { name: 'listFiles', description: 'List files in directory', parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] } },
+    { name: 'executeShellCommand', description: 'Execute shell command', parameters: { type: 'object', properties: { command: { type: 'string' } }, required: ['command'] } },
+    { name: 'updateMemory', description: 'Store learned project facts', parameters: { type: 'object', properties: { category: { type: 'string' }, content: { type: 'string' } }, required: ['category', 'content'] } },
+    { name: 'syncPlan', description: 'Update task status', parameters: { type: 'object', properties: { taskId: { type: 'string' }, status: { type: 'string', enum: ['pending', 'in_progress', 'complete'] } }, required: ['taskId', 'status'] } },
+    { name: 'recallContext', description: 'Retrieve stored knowledge', parameters: { type: 'object', properties: { query: { type: 'string' } } } },
+];
+/**
+ * Core Autonomous Agent Loop (Google Native SDK)
+ */
+export async function runAgentLoop(context, callbacks) {
+    const { onChunk } = callbacks;
+    const { userMessage, history, googleKey, activePlan, projectContextCache } = context;
+    if (!googleKey) {
+        onChunk('\n❗ Error: No Google API Key found.\n');
+        return;
+    }
+    // Initialize memory system
+    const memory = MemoryManager.getInstance();
+    await memory.initialize();
+    await memory.incrementSession();
+    // Load persistent memory
+    const plan = await memory.loadPlan();
+    const memoryContext = await memory.loadContext();
+    const pendingTasks = await memory.getPendingTasks();
+    // Build memory-aware system prompt
+    let enhancedPrompt = ELITE_SYSTEM_PROMPT;
+    if (pendingTasks.length > 0) {
+        enhancedPrompt += `\n\n📋 **ACTIVE PLAN** (from .camo/plan.md):\n${pendingTasks.map(t => `- ${t}`).join('\n')}\n`;
+        onChunk(`\n⏺ Resuming work on: ${pendingTasks[0]}\n`);
+    }
+    if (memoryContext && memoryContext.trim().length > 100) {
+        enhancedPrompt += `\n\n📚 **PROJECT KNOWLEDGE** (from .camo/context.md):\n${memoryContext.slice(0, 1000)}\n`;
+    }
+    let loopCount = 0;
+    const client = new GoogleGenerativeAI(googleKey);
+    // Select Model - map UI names to Google model IDs
+    let selectedModelId = config.get('selectedModel') || 'gemini-2-flash';
+    const modelMap = {
+        'gemini-3-flash': 'gemini-exp-1206',
+        'gemini-3-pro': 'gemini-2.0-pro-exp',
+        'gemini-2-flash': 'gemini-2.0-flash-exp',
+        'gemini-2-pro': 'gemini-2.5-pro',
+    };
+    const actualModelId = modelMap[selectedModelId] || selectedModelId;
+    const model = client.getGenerativeModel({
+        model: actualModelId,
+        tools: [{ functionDeclarations: googleToolDefinitions }]
+    });
+    // Prepare Plan Context
+    let planContext = "";
+    if (activePlan.length > 0) {
+        planContext = `\n**AKTUELLER PLAN**:\n${activePlan.map(t => `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '/' : ' '}] ${t.title} (${t.id})`).join('\n')}\n`;
+    }
+    // Initialize Message History
+    const contents = history.map(msg => ({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: [{ text: msg.content }]
+    })).concat([{
+            role: 'user',
+            parts: [{ text: userMessage + planContext }]
+        }]);
+    const systemInstruction = enhancedPrompt
+        .replace('{{PROJECT_CONTEXT}}', projectContextCache)
+        .replace('{{TASK_STATE}}', TaskState.getContextString());
+    let lastToolSignature = '';
+    let repetitionCount = 0;
+    while (loopCount < MAX_LOOPS) {
+        loopCount++;
+        try {
+            const response = await model.generateContent({
+                contents: contents,
+                systemInstruction: systemInstruction
+            });
+            const responseText = response.response.text() || '';
+            const toolCalls = response.response.functionCalls?.();
+            // Output text if present
+            if (responseText.trim()) {
+                onChunk(responseText + '\n');
+            }
+            // Check for completion
+            if (responseText.includes('[TASK_COMPLETE]') || responseText.includes('[done]')) {
+                onChunk('\n[done]\n');
+                break;
+            }
+            if (!toolCalls || toolCalls.length === 0) {
+                onChunk('\n[done]\n');
+                break;
+            }
+            // Add model turn
+            contents.push({
+                role: 'model',
+                parts: [{ text: responseText }]
+            });
+            // Loop detection
+            const currentSignature = toolCalls.map(tc => `${tc.name}:${JSON.stringify(tc.args)}`).join('|');
+            if (currentSignature === lastToolSignature) {
+                repetitionCount++;
+                if (repetitionCount >= 3) {
+                    onChunk('\n[Repetition Detected]\n');
+                    if (repetitionCount > 5)
+                        break;
+                }
+            }
+            else {
+                repetitionCount = 0;
+                lastToolSignature = currentSignature;
+            }
+            // Execute tools
+            const toolResponses = [];
+            for (const call of toolCalls) {
+                onChunk(formatToolCall(call.name, call.args));
+                let resultString = '';
+                try {
+                    const toolFn = ToolRegistry[call.name];
+                    if (toolFn) {
+                        resultString = await toolFn(call.args, callbacks);
+                    }
+                    else {
+                        resultString = JSON.stringify({ error: `Unknown tool: ${call.name}` });
+                    }
+                }
+                catch (e) {
+                    resultString = JSON.stringify({ error: e.message });
+                }
+                onChunk('\n' + formatToolOutput(resultString) + '\n');
+                toolResponses.push({
+                    functionResponse: {
+                        name: call.name,
+                        response: { name: call.name, content: resultString }
+                    }
+                });
+            }
+            // Add tool responses to history
+            if (toolResponses.length > 0) {
+                contents.push({
+                    role: 'function',
+                    parts: toolResponses
+                });
+            }
+        }
+        catch (e) {
+            onChunk(`\n❗ Error: ${e.message}\n`);
+            break;
+        }
+    }
+    onChunk('\n[done]\n');
+}

package/dist/hooks/useAutocomplete.js

@@ -0,0 +1,52 @@
+import { useState, useCallback, useMemo } from 'react';
+export const useAutocomplete = (input) => {
+    const [showSuggestions, setShowSuggestions] = useState(false);
+    // Available slash commands
+    const commands = useMemo(() => [
+        { name: 'help', description: 'Show help' },
+        { name: 'key', description: 'Set API key' },
+        { name: 'model', description: 'Switch model' },
+        { name: 'connect', description: 'Connect to API' },
+        { name: 'config', description: 'Configuration' },
+        { name: 'mcp', description: 'MCP servers' },
+        { name: 'clear', description: 'Clear screen' },
+        { name: 'exit', description: 'Exit' }
+    ], []);
+    const suggestions = useMemo(() => {
+        if (!input.startsWith('/')) {
+            return { suggestions: [], commonPrefix: '', isUnique: false };
+        }
+        const commandPart = input.slice(1).split(' ')[0];
+        const matches = commands.filter(cmd => cmd.name.startsWith(commandPart));
+        if (matches.length === 0) {
+            return { suggestions: [], commonPrefix: '', isUnique: false };
+        }
+        if (matches.length === 1) {
+            const cmd = matches[0];
+            return {
+                suggestions: [cmd.name],
+                commonPrefix: `/${cmd.name} `,
+                isUnique: true
+            };
+        }
+        // Find common prefix
+        const names = matches.map(m => m.name);
+        let commonPrefix = names[0];
+        for (let i = 1; i < names.length; i++) {
+            while (!names[i].startsWith(commonPrefix)) {
+                commonPrefix = commonPrefix.slice(0, -1);
+                if (commonPrefix === '')
+                    break;
+            }
+        }
+        return {
+            suggestions: names,
+            commonPrefix: `/${commonPrefix}`,
+            isUnique: false
+        };
+    }, [input, commands]);
+    const toggleSuggestions = useCallback(() => {
+        setShowSuggestions(!showSuggestions);
+    }, [showSuggestions]);
+    return { suggestions: suggestions.suggestions, showSuggestions, commonPrefix: suggestions.commonPrefix };
+};