camo-cli 2.0.1

package/dist/hooks/useKeyboard.js

@@ -0,0 +1,73 @@
+import { useState, useCallback } from 'react';
+export const useKeyboard = () => {
+    const [input, setInput] = useState('');
+    const [cursorPos, setCursorPos] = useState(0);
+    const [history, setHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const handleKey = useCallback((str, key) => {
+        // Submit
+        if (key.return) {
+            if (input.trim()) {
+                setHistory(prev => [...prev, input]);
+                // Process command here
+                setInput('');
+                setCursorPos(0);
+                setHistoryIndex(-1);
+            }
+            return { shouldSubmit: true, value: input };
+        }
+        // History navigation
+        if (key.upArrow && history.length > 0) {
+            const newIndex = Math.min(historyIndex + 1, history.length - 1);
+            setHistoryIndex(newIndex);
+            const historyValue = history[history.length - 1 - newIndex];
+            setInput(historyValue);
+            setCursorPos(historyValue.length);
+            return { shouldSubmit: false };
+        }
+        if (key.downArrow && historyIndex >= 0) {
+            const newIndex = historyIndex - 1;
+            if (newIndex < 0) {
+                setHistoryIndex(-1);
+                setInput('');
+                setCursorPos(0);
+            }
+            else {
+                setHistoryIndex(newIndex);
+                const historyValue = history[history.length - 1 - newIndex];
+                setInput(historyValue);
+                setCursorPos(historyValue.length);
+            }
+            return { shouldSubmit: false };
+        }
+        // Cursor movement
+        if (key.leftArrow) {
+            setCursorPos(Math.max(0, cursorPos - 1));
+            return { shouldSubmit: false };
+        }
+        if (key.rightArrow) {
+            setCursorPos(Math.min(input.length, cursorPos + 1));
+            return { shouldSubmit: false };
+        }
+        // Backspace
+        if (key.backspace && cursorPos > 0) {
+            const newInput = input.slice(0, cursorPos - 1) + input.slice(cursorPos);
+            setInput(newInput);
+            setCursorPos(cursorPos - 1);
+            return { shouldSubmit: false };
+        }
+        // Tab for autocomplete
+        if (key.tab) {
+            return { shouldSubmit: false, shouldAutocomplete: true };
+        }
+        // Regular input
+        if (str && !key.ctrl && !key.meta) {
+            const newInput = input.slice(0, cursorPos) + str + input.slice(cursorPos);
+            setInput(newInput);
+            setCursorPos(cursorPos + str.length);
+            return { shouldSubmit: false };
+        }
+        return { shouldSubmit: false };
+    }, [input, cursorPos, history, historyIndex]);
+    return { input, cursorPos, handleKey, setInput, setCursorPos };
+};

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import React from 'react';
+import { render } from 'ink';
+import { App } from './components/App.js';
+// Setup CLI program
+const program = new Command();
+program
+    .name('camo')
+    .description('🦎 CAMO - Elite Autonomous CLI Agent')
+    .version('2.0.0')
+    .option('-v, --verbose', 'Enable verbose output')
+    .argument('[initialInput]', 'Initial prompt to start with')
+    .action(async (initialInput, options) => {
+    // If we have an initial input, we can pass it to the App.
+    // Ideally, if it's a one-shot command, we might run headless, but user said "Start-Flow... Man landet direkt im Chat-Interface".
+    // So even with args, we might open the UI and fill the input?
+    // User didn't specify headless behavior in refactor. I'll focus on interactive UI.
+    // Start Ink with custom exit handling
+    const app = React.createElement(App, {
+        initialInput: initialInput,
+        verbose: options.verbose
+    });
+    // Render with exitOnCtrlC disabled (we handle it ourselves)
+    const { unmount, waitUntilExit } = render(app, {
+        exitOnCtrlC: false
+    });
+    // Wait for app to exit gracefully
+    await waitUntilExit();
+});
+program.parse();

package/dist/mcp.js

@@ -0,0 +1,95 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { z } from "zod";
+import * as clack from '@clack/prompts';
+import chalk from 'chalk';
+export class McpManager {
+    constructor() {
+        this.clients = new Map();
+        this.activeTools = new Map();
+    }
+    async connect(configs) {
+        for (const config of configs) {
+            try {
+                const transport = new StdioClientTransport({
+                    command: config.command,
+                    args: config.args,
+                });
+                const client = new Client({
+                    name: "camo-client",
+                    version: "1.0.0",
+                }, {
+                    capabilities: {},
+                });
+                await client.connect(transport);
+                this.clients.set(config.name, client);
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to connect to MCP server '${config.name}': ${error.message}`));
+            }
+        }
+    }
+    getActiveServerCount() {
+        return this.clients.size;
+    }
+    async getTools() {
+        const aiSdkTools = {};
+        this.activeTools.clear();
+        for (const [serverName, client] of this.clients.entries()) {
+            try {
+                const result = await client.listTools();
+                for (const tool of result.tools) {
+                    // Prefix tool name to avoid collisions
+                    const uniqueToolName = `${serverName}_${tool.name}`;
+                    this.activeTools.set(uniqueToolName, { serverName, toolName: tool.name });
+                    // We wrap the execution to include a security check
+                    aiSdkTools[uniqueToolName] = {
+                        description: `${tool.description || ''} (Provided by MCP Server: ${serverName}) \nArguments Schema: ${JSON.stringify(tool.inputSchema)}`,
+                        // We use z.any() here but the description contains the schema for the LLM to follow.
+                        // This prevents complex runtime Zod conversion issues.
+                        inputSchema: z.object({}).passthrough().describe("JSON arguments matching the schema provided in description"),
+                        execute: async (args) => {
+                            return await this.executeToolWithSecurity(uniqueToolName, args);
+                        },
+                    };
+                }
+            }
+            catch (error) {
+                console.error(chalk.yellow(`Failed to fetch tools from '${serverName}': ${error.message}`));
+            }
+        }
+        return aiSdkTools;
+    }
+    async executeToolWithSecurity(uniqueToolName, args) {
+        const info = this.activeTools.get(uniqueToolName);
+        if (!info) {
+            return { error: `Tool ${uniqueToolName} not found` };
+        }
+        const { serverName, toolName } = info;
+        console.log(chalk.yellow(`\n[MCP SECURITY] Server '${serverName}' wants to execute tool '${toolName}'`));
+        console.log(chalk.white(`Arguments: ${JSON.stringify(args, null, 2)}`));
+        const approved = await clack.confirm({
+            message: 'Allow execution?',
+        });
+        if (!approved || clack.isCancel(approved)) {
+            return { error: 'User denied execution' };
+        }
+        const client = this.clients.get(serverName);
+        if (!client)
+            return { error: 'Client disconnected' };
+        try {
+            const result = await client.callTool({
+                name: toolName,
+                arguments: args,
+            });
+            // Convert MCP result to simple text/json for AI SDK
+            const toolResult = result;
+            return {
+                result: toolResult.content.map((c) => c.type === 'text' ? c.text : '[Binary/Image]').join('\n')
+            };
+        }
+        catch (error) {
+            return { error: `MCP Execution Error: ${error.message}` };
+        }
+    }
+}

package/dist/memory/MemoryManager.js

@@ -0,0 +1,228 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * MemoryManager - Handles persistent working memory in .camo directory
+ */
+export class MemoryManager {
+    constructor(projectRoot) {
+        this.camoDir = path.join(projectRoot, '.camo');
+        this.planPath = path.join(this.camoDir, 'plan.md');
+        this.contextPath = path.join(this.camoDir, 'context.md');
+        this.sessionPath = path.join(this.camoDir, 'session.json');
+    }
+    static getInstance(projectRoot = process.cwd()) {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager(projectRoot);
+        }
+        return MemoryManager.instance;
+    }
+    /**
+     * Initialize .camo directory and files if they don't exist
+     */
+    async initialize() {
+        try {
+            // Create .camo directory
+            await fs.mkdir(this.camoDir, { recursive: true });
+            // Initialize plan.md if not exists
+            try {
+                await fs.access(this.planPath);
+            }
+            catch {
+                await fs.writeFile(this.planPath, this.getDefaultPlan(), 'utf-8');
+            }
+            // Initialize context.md if not exists
+            try {
+                await fs.access(this.contextPath);
+            }
+            catch {
+                await fs.writeFile(this.contextPath, this.getDefaultContext(), 'utf-8');
+            }
+            // Initialize session.json if not exists
+            try {
+                await fs.access(this.sessionPath);
+            }
+            catch {
+                const defaultSession = {
+                    totalTokens: 0,
+                    lastCheckpoint: new Date().toISOString(),
+                    sessionCount: 0
+                };
+                await fs.writeFile(this.sessionPath, JSON.stringify(defaultSession, null, 2), 'utf-8');
+            }
+            // Add .camo to .gitignore if .gitignore exists
+            await this.addToGitignore();
+        }
+        catch (e) {
+            console.error('Failed to initialize .camo directory:', e.message);
+        }
+    }
+    /**
+     * Add .camo/ to .gitignore if not already present
+     */
+    async addToGitignore() {
+        const gitignorePath = path.join(path.dirname(this.camoDir), '.gitignore');
+        try {
+            let gitignoreContent = '';
+            try {
+                gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+            }
+            catch {
+                // .gitignore doesn't exist, create it
+            }
+            if (!gitignoreContent.includes('.camo')) {
+                const newContent = gitignoreContent + (gitignoreContent.endsWith('\n') ? '' : '\n') + '.camo/\n';
+                await fs.writeFile(gitignorePath, newContent, 'utf-8');
+            }
+        }
+        catch (e) {
+            // Ignore errors - .gitignore is optional
+        }
+    }
+    /**
+     * Load plan.md content
+     */
+    async loadPlan() {
+        try {
+            return await fs.readFile(this.planPath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Save plan.md content
+     */
+    async savePlan(content) {
+        await fs.writeFile(this.planPath, content, 'utf-8');
+    }
+    /**
+     * Update task status in plan.md
+     */
+    async updateTaskStatus(taskId, status) {
+        const plan = await this.loadPlan();
+        const statusChar = status === 'complete' ? 'x' : status === 'in_progress' ? '/' : ' ';
+        // Replace task status (simple regex-based approach)
+        const updatedPlan = plan.replace(new RegExp(`- \\[.\\] (.*)<!-- id: ${taskId} -->`, 'g'), `- [${statusChar}] $1<!-- id: ${taskId} -->`);
+        await this.savePlan(updatedPlan);
+    }
+    /**
+     * Load context.md content
+     */
+    async loadContext() {
+        try {
+            return await fs.readFile(this.contextPath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Add or update a fact in context.md
+     */
+    async updateContext(category, content) {
+        let context = await this.loadContext();
+        // Check if category already exists
+        const categoryHeader = `## ${category}`;
+        if (context.includes(categoryHeader)) {
+            // Append to existing category
+            const lines = context.split('\n');
+            const categoryIndex = lines.findIndex(l => l.startsWith(categoryHeader));
+            // Find next category or end
+            let nextCategoryIndex = lines.length;
+            for (let i = categoryIndex + 1; i < lines.length; i++) {
+                if (lines[i].startsWith('## ')) {
+                    nextCategoryIndex = i;
+                    break;
+                }
+            }
+            // Insert before next category
+            lines.splice(nextCategoryIndex, 0, `- ${content}`);
+            context = lines.join('\n');
+        }
+        else {
+            // Add new category
+            context += `\n${categoryHeader}\n- ${content}\n`;
+        }
+        await fs.writeFile(this.contextPath, context, 'utf-8');
+    }
+    /**
+     * Load session.json data
+     */
+    async loadSession() {
+        try {
+            const content = await fs.readFile(this.sessionPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return {
+                totalTokens: 0,
+                lastCheckpoint: new Date().toISOString(),
+                sessionCount: 0
+            };
+        }
+    }
+    /**
+     * Save session.json data
+     */
+    async saveSession(data) {
+        const current = await this.loadSession();
+        const updated = { ...current, ...data };
+        await fs.writeFile(this.sessionPath, JSON.stringify(updated, null, 2), 'utf-8');
+    }
+    /**
+     * Increment session count
+     */
+    async incrementSession() {
+        const session = await this.loadSession();
+        await this.saveSession({
+            sessionCount: session.sessionCount + 1,
+            lastCheckpoint: new Date().toISOString()
+        });
+    }
+    /**
+     * Get pending tasks from plan.md
+     */
+    async getPendingTasks() {
+        const plan = await this.loadPlan();
+        const lines = plan.split('\n');
+        const pending = [];
+        for (const line of lines) {
+            if (line.match(/- \[ \]/)) {
+                // Extract task text (remove checkbox)
+                const task = line.replace(/- \[ \]/, '').trim();
+                pending.push(task);
+            }
+        }
+        return pending;
+    }
+    /**
+     * Default plan.md template
+     */
+    getDefaultPlan() {
+        return `# Current Plan
+
+## Active Tasks
+<!-- Add tasks here using: - [ ] Task description -->
+
+## Completed
+<!-- Completed tasks will be moved here -->
+`;
+    }
+    /**
+     * Default context.md template
+     */
+    getDefaultContext() {
+        return `# Project Context
+
+## Architecture
+<!-- Learned architectural decisions go here -->
+
+## Key Files
+<!-- Important file locations -->
+
+## Decisions
+<!-- Technical decisions and rationale -->
+`;
+    }
+}
+export default MemoryManager;

package/dist/providers/index.js

@@ -0,0 +1,85 @@
+/**
+ * Provider Manager
+ * Central management for AI providers
+ */
+import { DEFAULT_PROVIDERS } from './registry.js';
+export class ProviderManager {
+    constructor(config) {
+        this.config = config;
+    }
+    getProviders() {
+        const providers = this.config.get('providers', {});
+        const merged = {};
+        // Merge defaults
+        Object.entries(DEFAULT_PROVIDERS).forEach(([key, defaultProvider]) => {
+            // Get API key from root config if it existed there (legacy) or provider config
+            // We'll primarily look in the provider config object now, or mapped keys in App.tsx logic used config.get('googleApiKey').
+            // To align with App.tsx which uses `googleApiKey` etc at root:
+            let apiKey = '';
+            if (key === 'google')
+                apiKey = this.config.get('googleApiKey');
+            if (key === 'anthropic')
+                apiKey = this.config.get('anthropicApiKey');
+            if (key === 'openai')
+                apiKey = this.config.get('openaiApiKey');
+            if (key === 'openrouter')
+                apiKey = this.config.get('openrouterApiKey');
+            if (key === 'custom')
+                apiKey = this.config.get('customApiKey');
+            merged[key] = {
+                ...defaultProvider,
+                apiKey: apiKey || '',
+                isActive: !!apiKey
+            };
+        });
+        // Custom Base URL handling
+        if (merged['custom']) {
+            merged['custom'].baseURL = this.config.get('customBaseUrl') || '';
+        }
+        return merged;
+    }
+    getActiveSelection() {
+        const activeProvider = this.config.get('activeProvider'); // defaults?
+        const activeModel = this.config.get('activeModel');
+        // If explicitly set and valid, use it
+        if (activeProvider && activeModel) {
+            const providers = this.getProviders();
+            if (providers[activeProvider]) {
+                const model = providers[activeProvider].models.find(m => m.id === activeModel);
+                if (model)
+                    return { provider: activeProvider, model };
+            }
+        }
+        return this.getDefaultSelection();
+    }
+    getDefaultSelection() {
+        const providers = this.getProviders();
+        // Priority: Google first (as requested)
+        const priorityOrder = ['google', 'anthropic', 'openai', 'openrouter', 'custom'];
+        for (const key of priorityOrder) {
+            const p = providers[key];
+            if (p?.isActive && p.models.length > 0) {
+                return { provider: key, model: p.models[0] };
+            }
+        }
+        return null; // No active provider with key
+    }
+    async createModel(selection) {
+        const { createGoogleGenerativeAI } = await import('@ai-sdk/google');
+        const activeSelection = selection || this.getActiveSelection();
+        if (!activeSelection)
+            throw new Error('No active provider configured.');
+        const providers = this.getProviders();
+        const provider = providers[activeSelection.provider];
+        if (!provider.apiKey)
+            throw new Error(`Missing API Key for ${provider.name}`);
+        const modelId = activeSelection.model.id;
+        // Only Google is supported
+        if (provider.type === 'google') {
+            return createGoogleGenerativeAI({ apiKey: provider.apiKey })(modelId);
+        }
+        throw new Error(`Only Google provider is supported. Got: ${provider.type}`);
+    }
+}
+export * from './types.js';
+export * from './registry.js';

package/dist/providers/registry.js

@@ -0,0 +1,121 @@
+/**
+ * Provider Registry
+ * Pre-configured providers and their available models
+ */
+// Anthropic Models
+const anthropicModels = [
+    {
+        id: 'claude-3-5-sonnet-latest',
+        name: 'Claude 3.5 Sonnet',
+        contextWindow: 200000,
+        supportsTools: true,
+        description: 'Most capable model for coding tasks'
+    },
+    {
+        id: 'claude-3-5-haiku-latest',
+        name: 'Claude 3.5 Haiku',
+        contextWindow: 200000,
+        supportsTools: true,
+        description: 'Fast and efficient for quick tasks'
+    }
+];
+// OpenAI Models
+const openaiModels = [
+    {
+        id: 'gpt-4o',
+        name: 'GPT-4o',
+        contextWindow: 128000,
+        supportsTools: true,
+        description: 'Most capable GPT-4 model'
+    },
+    {
+        id: 'gpt-4o-mini',
+        name: 'GPT-4o Mini',
+        contextWindow: 128000,
+        supportsTools: true,
+        description: 'Faster and more affordable'
+    },
+    {
+        id: 'o1',
+        name: 'O1',
+        contextWindow: 200000,
+        supportsTools: false,
+        description: 'Advanced reasoning model'
+    }
+];
+// Google Models
+const googleModels = [
+    {
+        id: 'gemini-2.0-flash',
+        name: 'Gemini 2.0 Flash',
+        contextWindow: 1000000,
+        supportsTools: true,
+        description: 'Fast with massive context window (Default)'
+    }
+];
+// OpenRouter Models (Example)
+const openRouterModels = [
+    {
+        id: 'google/gemini-2.0-flash-exp:free',
+        name: 'Gemini 2.0 Flash (Free)',
+        contextWindow: 1000000,
+        supportsTools: true,
+        description: 'Free tier via OpenRouter'
+    },
+    {
+        id: 'anthropic/claude-3.5-sonnet',
+        name: 'Claude 3.5 Sonnet (OR)',
+        contextWindow: 200000,
+        supportsTools: true,
+        description: 'Via OpenRouter'
+    }
+];
+// Custom/Self-hosted Models
+const customModels = [
+    {
+        id: 'custom',
+        name: 'Custom Model',
+        contextWindow: 4000,
+        supportsTools: true,
+        description: 'Custom API endpoint'
+    }
+];
+/**
+ * Default provider configurations
+ */
+export const DEFAULT_PROVIDERS = {
+    google: {
+        name: 'Google',
+        type: 'google',
+        models: googleModels
+    },
+    anthropic: {
+        name: 'Anthropic',
+        type: 'anthropic',
+        models: anthropicModels
+    },
+    openai: {
+        name: 'OpenAI',
+        type: 'openai',
+        models: openaiModels
+    },
+    openrouter: {
+        name: 'OpenRouter',
+        type: 'openrouter',
+        models: openRouterModels
+    },
+    custom: {
+        name: 'Custom',
+        type: 'custom',
+        models: customModels
+    }
+};
+export function findModel(modelId) {
+    for (const [providerKey, provider] of Object.entries(DEFAULT_PROVIDERS)) {
+        const model = provider.models.find(m => m.id === modelId);
+        if (model) {
+            return { provider: providerKey, model };
+        }
+    }
+    return null;
+}

package/dist/providers/types.js

@@ -0,0 +1,5 @@
+/**
+ * Provider System Types
+ * Defines the structure for AI providers and models
+ */
+export {};

package/dist/theme.js

@@ -0,0 +1,45 @@
+/**
+ * Minimalist Design System
+ * Black/White/Gray color palette with high contrast
+ */
+export const theme = {
+    colors: {
+        white: '#FFFFFF',
+        lightGray: '#D3D3D3',
+        mediumGray: '#808080',
+        darkGray: '#333333',
+        black: '#000000',
+        accent: '#FFFFFF', // For selection/active elements
+        success: '#00FF00',
+        error: '#FF0000',
+        warning: '#FFFF00',
+    },
+    textColors: {
+        primary: 'white',
+        secondary: 'lightGray',
+        muted: 'mediumGray',
+        inverse: 'black',
+    },
+    backgrounds: {
+        default: 'black',
+        selected: 'white',
+        muted: 'darkGray',
+    },
+    spacing: {
+        xs: 1,
+        sm: 2,
+        md: 4,
+        lg: 8,
+    },
+    borders: {
+        light: '─',
+        heavy: '━',
+        corner: '┬',
+    },
+};
+// Prefix symbols for messages
+export const messagePrefixes = {
+    user: '> ',
+    assistant: '- ',
+    system: '~ ',
+};