xibecode 0.0.1

package/README.md

@@ -0,0 +1,434 @@
+# XibeCode - AI Coding Assistant
+
+> **Production-ready autonomous coding agent powered by Claude AI**
+
+XibeCode is a professional CLI tool that brings autonomous AI coding capabilities to your terminal. Like Claude Code, but open-source, customizable, and with advanced context management.
+
+## 🎯 Key Features
+
+### Core Capabilities
+- ✅ **Autonomous Agent Loop** - AI iteratively works on tasks until completion
+- ✅ **Smart Context Management** - Automatically loads related files (imports, tests, configs)
+- ✅ **Advanced File Editing** - Search/replace, line-range edits, automatic backups
+- ✅ **Cross-Platform** - Works on Windows, macOS, and Linux
+- ✅ **Beautiful TUI** - Real-time progress, colored output, clear visualization
+- ✅ **Loop Detection** - Prevents infinite loops and runaway executions
+- ✅ **Multiple Edit Methods** - Smart edit, line-range edit, insert, revert
+
+### File Operations
+- 📖 Read files (whole or partial for large files)
+- 📝 Write files (create or overwrite)
+- ✏️  Edit files (search/replace with automatic backups)
+- ✂️  Edit specific line ranges
+- ↩️  Revert to previous versions
+- 🔍 Search files with glob patterns
+- 📁 List directories
+- 🧠 Get intelligent context (related files)
+
+### Command Execution
+- ⚡ Run shell commands
+- 🔧 Cross-platform command support
+- 📊 Capture stdout/stderr
+- ✅ Exit code handling
+
+## 📦 Installation
+
+### From npm (Recommended)
+
+```bash
+npm install -g xibecode
+```
+
+### From Source
+
+```bash
+git clone https://github.com/yourusername/xibecode
+cd xibecode
+npm install
+npm run build
+npm link
+```
+
+## 🚀 Quick Start
+
+### 1. Set up API Key
+
+```bash
+# Interactive setup
+xibecode config
+
+# Or set directly
+xibecode config --set-key YOUR_ANTHROPIC_API_KEY
+
+# Or use environment variable
+export ANTHROPIC_API_KEY=your_key_here
+```
+
+### 2. Run Your First Task
+
+```bash
+xibecode run "Create a Python script that prints hello world"
+```
+
+### 3. Try Interactive Chat
+
+```bash
+xibecode chat
+```
+
+## 💡 Usage
+
+### Run Command (Autonomous Mode)
+
+The main command for autonomous coding tasks:
+
+```bash
+xibecode run [prompt] [options]
+```
+
+**Options:**
+- `-f, --file <path>` - Read prompt from a file
+- `-m, --model <model>` - AI model to use (default: claude-sonnet-4-5-20250929)
+- `-b, --base-url <url>` - Custom API base URL
+- `-k, --api-key <key>` - API key (overrides config)
+- `-d, --max-iterations <number>` - Maximum iterations (default: 50)
+- `-v, --verbose` - Show detailed logs
+
+**Examples:**
+
+```bash
+# Simple task
+xibecode run "Create a REST API with Express"
+
+# From file
+xibecode run --file task.txt
+
+# With verbose logging
+xibecode run "Fix the bug in app.js" --verbose
+
+# Using specific model
+xibecode run "Optimize this code" --model claude-opus-4-5-20251101
+
+# Custom API endpoint
+xibecode run "task" --base-url https://custom-api.com
+```
+
+### Chat Command (Interactive Mode)
+
+For quick questions and iterative development:
+
+```bash
+xibecode chat [options]
+```
+
+**Options:**
+- `-m, --model <model>` - AI model to use
+- `-b, --base-url <url>` - Custom API base URL
+- `-k, --api-key <key>` - API key
+
+**Commands in chat:**
+- `tools on/off` - Toggle tool execution
+- `clear` - Clear screen
+- `exit` or `quit` - Exit chat
+
+**Example:**
+
+```bash
+$ xibecode chat
+
+You: How do I implement JWT authentication?
+Assistant: [explains JWT auth]
+
+You: Write the code for it
+Assistant: [writes code using tools]
+
+You: Add it to my Express app
+Assistant: [modifies app.js]
+```
+
+### Config Command
+
+Manage your configuration:
+
+```bash
+# Interactive setup
+xibecode config
+
+# Quick operations
+xibecode config --set-key YOUR_KEY
+xibecode config --set-url https://custom-api.com
+xibecode config --set-model claude-opus-4-5-20251101
+xibecode config --show
+xibecode config --reset
+```
+
+## 🎨 What Makes XibeCode Different
+
+### 1. **Smart Context Management**
+
+XibeCode automatically understands your project:
+
+```bash
+xibecode run "Add error handling to userController.js"
+```
+
+The AI will:
+- Read `userController.js`
+- Find and read imported files
+- Check for related test files
+- Look at config files (package.json, tsconfig.json)
+- Make informed edits with full context
+
+### 2. **Advanced File Editing**
+
+Three ways to edit files:
+
+#### Search/Replace (Most Reliable)
+```javascript
+{
+  tool: "edit_file",
+  path: "app.js",
+  search: "const port = 3000;",
+  replace: "const port = process.env.PORT || 3000;"
+}
+```
+
+#### Line Range (For Large Files)
+```javascript
+{
+  tool: "edit_lines",
+  path: "app.js",
+  start_line: 10,
+  end_line: 15,
+  new_content: "// Updated code here"
+}
+```
+
+#### Insert (Add New Code)
+```javascript
+{
+  tool: "insert_at_line",
+  path: "app.js",
+  line: 5,
+  content: "const express = require('express');"
+}
+```
+
+### 3. **Automatic Backups & Revert**
+
+Every edit creates a backup. Made a mistake?
+
+```bash
+xibecode run "Revert app.js to previous version"
+```
+
+### 4. **Cross-Platform**
+
+Works identically on:
+- ✅ Windows (PowerShell)
+- ✅ macOS (bash/zsh)
+- ✅ Linux (bash)
+
+The AI automatically uses the right commands for your OS.
+
+### 5. **Beautiful Real-Time UI**
+
+```
+╔════════════════════════════════════════════════════════════╗
+║                 XibeCode AI Agent                        ║
+║              Autonomous Coding Assistant v1.0.0          ║
+╚════════════════════════════════════════════════════════════╝
+
+📋 Task:
+  Create a REST API with Express
+
+⚙️  Configuration:
+   Model: claude-sonnet-4-5-20250929
+   Max Iterations: 50
+
+────────────────────────────────────────────────────────────
+
+Iteration 1/50 (2%) - 0.5s
+██░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+
+📖 read_file
+  → package.json
+✓ Success
+  ← 25 lines
+
+📝 write_file
+  → src/server.js
+✓ Success
+  ← File created (45 lines)
+
+💬 Assistant:
+  I've created an Express server with the following endpoints...
+```
+
+## 🛠️ Advanced Features
+
+### Custom API Endpoints
+
+Use with Azure, AWS Bedrock, or custom Claude deployments:
+
+```bash
+# Via config
+xibecode config --set-url https://your-custom-endpoint.com
+
+# Via command
+xibecode run "task" --base-url https://your-custom-endpoint.com
+```
+
+### Working with Large Files
+
+For files >1000 lines, read in chunks:
+
+```bash
+xibecode run "Fix the bug around line 500 in large-file.js"
+```
+
+The AI will:
+1. Read lines 450-550 (context around the area)
+2. Make targeted edit using line numbers
+3. Verify the change
+
+### Project Context Understanding
+
+```bash
+xibecode run "Understand this project structure and suggest improvements"
+```
+
+The AI will use `get_context` to:
+- Map import relationships
+- Find test files
+- Read configs
+- Build a mental model
+
+### Error Recovery
+
+If something fails, the AI will:
+1. Read the error message
+2. Analyze what went wrong
+3. Try a different approach
+4. Can revert changes if needed
+
+## 📊 Usage Examples
+
+### Build a Feature
+
+```bash
+xibecode run "Add user authentication to the Express API:
+- POST /auth/register
+- POST /auth/login  
+- JWT token generation
+- Middleware to protect routes
+- Hash passwords with bcrypt"
+```
+
+### Fix a Bug
+
+```bash
+xibecode run "The tests in test/user.test.js are failing. 
+Debug and fix the issues." --verbose
+```
+
+### Refactor Code
+
+```bash
+xibecode run "Refactor src/ to use TypeScript:
+- Convert all .js files to .ts
+- Add type annotations
+- Create types.ts for shared types
+- Update tsconfig.json"
+```
+
+### Generate Tests
+
+```bash
+xibecode run "Write comprehensive tests for userController.js:
+- Test all endpoints
+- Test error cases
+- Use Jest
+- Achieve >80% coverage"
+```
+
+## ⚙️ Configuration
+
+XibeCode stores config in `~/.xibecode/`
+
+### Available Settings
+
+```javascript
+{
+  "apiKey": "sk-ant-...",           // Your Anthropic API key
+  "baseUrl": "https://...",         // Custom API endpoint (optional)
+  "model": "claude-sonnet-4-5-...", // Default model
+  "maxIterations": 50,              // Default max iterations
+  "defaultVerbose": false           // Default verbose mode
+}
+```
+
+### Environment Variables
+
+```bash
+ANTHROPIC_API_KEY=your_key        # API key
+ANTHROPIC_BASE_URL=https://...    # Custom endpoint
+XIBECODE_MODEL=claude-opus-4-...  # Default model
+```
+
+Config priority: CLI flags > Environment > Config file
+
+## 🔒 Safety Features
+
+- **Loop Detection** - Stops if AI repeats the same action 3+ times
+- **Max Iterations** - Hard limit on iterations (default: 50)
+- **Automatic Backups** - Every edit is backed up
+- **Revert Capability** - Can undo changes
+- **Error Recovery** - Handles failures gracefully
+- **Read-Before-Edit** - AI reads files before modifying
+
+## 🚀 Performance
+
+- **Startup**: <1 second
+- **First response**: 2-5 seconds (API latency)
+- **Tool execution**: Instant to seconds
+- **Memory**: ~50MB typical
+- **Context window**: 100k tokens (smart management)
+
+## 📈 Comparison
+
+| Feature | XibeCode | Claude Code | Aider |
+|---------|----------|-------------|-------|
+| Open Source | ✅ | ❌ | ✅ |
+| Custom API URL | ✅ | ❌ | ✅ |
+| Smart Context | ✅ | ✅ | ⚠️ |
+| File Editing | ✅ Advanced | ✅ | ✅ |
+| Cross-Platform | ✅ | ✅ | ✅ |
+| Loop Detection | ✅ | ✅ | ❌ |
+| Auto Backups | ✅ | ⚠️ | ❌ |
+| Beautiful TUI | ✅ | ✅ | ⚠️ |
+| Price | Free (your API) | $20/mo | Free |
+
+## 🤝 Contributing
+
+Contributions welcome! Please see CONTRIBUTING.md
+
+## 📝 License
+
+MIT
+
+## 🙏 Credits
+
+Built with:
+- [@anthropic-ai/sdk](https://www.npmjs.com/package/@anthropic-ai/sdk)
+- [Commander.js](https://github.com/tj/commander.js/)
+- [Inquirer.js](https://github.com/SBoudrias/Inquirer.js/)
+- [Chalk](https://github.com/chalk/chalk)
+- [fast-glob](https://github.com/mrmlnc/fast-glob)
+
+Inspired by [Claude Code](https://www.anthropic.com/news/claude-code) and [Aider](https://github.com/paul-gauthier/aider)
+
+---
+
+**Made with ❤️ for developers who love AI-assisted coding**
+# XibeCode

package/dist/commands/chat.d.ts

@@ -0,0 +1,8 @@
+interface ChatOptions {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+export declare function chatCommand(options: ChatOptions): Promise<void>;
+export {};
+//# sourceMappingURL=chat.d.ts.map

package/dist/commands/chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/commands/chat.ts"],"names":[],"mappings":"AASA,UAAU,WAAW;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,iBAgSrD"}

package/dist/commands/chat.js

@@ -0,0 +1,259 @@
+import inquirer from 'inquirer';
+import { EnhancedAgent } from '../core/agent.js';
+import { CodingToolExecutor } from '../core/tools.js';
+import { EnhancedUI } from '../ui/enhanced-tui.js';
+import { ConfigManager } from '../utils/config.js';
+import chalk from 'chalk';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export async function chatCommand(options) {
+    const ui = new EnhancedUI(false);
+    const config = new ConfigManager();
+    ui.clear();
+    ui.header('1.0.0');
+    // Get API key
+    const apiKey = options.apiKey || config.getApiKey();
+    if (!apiKey) {
+        ui.error('No API key found!');
+        console.log(chalk.white('  Set your API key:\n'));
+        console.log(chalk.cyan('    xibecode config --set-key YOUR_KEY\n'));
+        process.exit(1);
+    }
+    const model = options.model || config.getModel();
+    const baseUrl = options.baseUrl || config.getBaseUrl();
+    // Gemini‑style intro screen
+    ui.chatBanner(process.cwd(), model, baseUrl);
+    let enableTools = true;
+    const toolExecutor = new CodingToolExecutor(process.cwd());
+    // ── Create ONE agent for the entire chat session ──
+    // This keeps conversation history (messages) across all turns,
+    // so the AI remembers everything you talked about.
+    const agent = new EnhancedAgent({
+        apiKey,
+        baseUrl,
+        model,
+        maxIterations: 150,
+        verbose: false,
+    });
+    let hasResponse = false;
+    // Set up event handlers ONCE (agent is reused across turns)
+    agent.on('event', (event) => {
+        switch (event.type) {
+            case 'thinking':
+                if (!hasResponse) {
+                    ui.thinking(event.data.message || 'Analyzing your request...');
+                }
+                break;
+            // ── Streaming ──
+            case 'stream_start':
+                ui.startAssistantResponse();
+                hasResponse = true;
+                break;
+            case 'stream_text':
+                ui.streamText(event.data.text);
+                break;
+            case 'stream_end':
+                ui.endAssistantResponse();
+                break;
+            // ── Non-streaming fallback ──
+            case 'response':
+                if (!hasResponse) {
+                    ui.response(event.data.text);
+                    hasResponse = true;
+                }
+                break;
+            // ── Tools ──
+            case 'tool_call':
+                if (enableTools) {
+                    ui.toolCall(event.data.name, event.data.input);
+                }
+                break;
+            case 'tool_result':
+                if (enableTools) {
+                    ui.toolResult(event.data.name, event.data.result, event.data.success);
+                    const r = event.data.result;
+                    if (r?.success && event.data.name === 'write_file') {
+                        ui.fileChanged('created', r.path, r.lines ? `${r.lines} lines` : undefined);
+                    }
+                    else if (r?.success && event.data.name === 'edit_file') {
+                        ui.fileChanged('modified', r.path || '', r.linesChanged ? `${r.linesChanged} lines` : undefined);
+                    }
+                    else if (r?.success && event.data.name === 'edit_lines') {
+                        ui.fileChanged('modified', r.path || '', r.linesChanged ? `${r.linesChanged} lines` : undefined);
+                    }
+                }
+                break;
+            // ── Iteration ──
+            case 'iteration':
+                if (!hasResponse && event.data?.current) {
+                    ui.updateThinking(`Thinking... step ${event.data.current}`);
+                }
+                hasResponse = false;
+                break;
+            // ── Errors / Warnings ──
+            case 'error':
+                ui.error(event.data.message || event.data.error);
+                break;
+            case 'warning':
+                ui.warning(event.data.message);
+                break;
+        }
+    });
+    async function showPathSuggestions(raw) {
+        const input = raw.trim().slice(1).trim(); // drop leading '@'
+        const target = input ? path.resolve(process.cwd(), input) : process.cwd();
+        try {
+            const stats = await fs.stat(target);
+            const dir = stats.isDirectory() ? target : path.dirname(target);
+            const base = stats.isDirectory() ? '' : path.basename(target);
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const filtered = base
+                ? entries.filter(e => e.name.toLowerCase().startsWith(base.toLowerCase()))
+                : entries;
+            if (!filtered.length) {
+                ui.info(`No matches under ${dir}`);
+                return;
+            }
+            console.log('');
+            console.log('  ' + chalk.bold('Files & folders:'));
+            for (const entry of filtered.slice(0, 50)) {
+                const isDir = entry.isDirectory();
+                const name = entry.name + (isDir ? '/' : '');
+                const rel = path.relative(process.cwd(), path.join(dir, entry.name)) || '.';
+                console.log('  ' +
+                    (isDir ? chalk.hex('#40C4FF')('📁') : chalk.hex('#CE93D8')('📄')) +
+                    ' ' +
+                    chalk.white(name) +
+                    chalk.hex('#6B6B7B')(`  ·  ${rel}`));
+            }
+            if (filtered.length > 50) {
+                console.log('  ' + chalk.hex('#6B6B7B')(`… and ${filtered.length - 50} more`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            ui.error('Failed to list files for @ path', error);
+        }
+    }
+    function showSlashHelp() {
+        console.log('');
+        console.log(chalk.bold('  XibeCode chat commands'));
+        console.log('  ' + chalk.hex('#6B6B7B')('────────────────────────────'));
+        console.log('  ' + chalk.hex('#00D4FF')('/help') + chalk.hex('#6B6B7B')('      show this help, not an AI reply'));
+        console.log('  ' + chalk.hex('#00D4FF')('@path') + chalk.hex('#6B6B7B')('      list files/folders under path (or cwd if just "@")'));
+        console.log('  ' + chalk.hex('#00D4FF')('clear') + chalk.hex('#6B6B7B')('     clear screen and redraw header'));
+        console.log('  ' + chalk.hex('#00D4FF')('tools on') + chalk.hex('#6B6B7B')('  enable editor & filesystem tools'));
+        console.log('  ' + chalk.hex('#00D4FF')('tools off') + chalk.hex('#6B6B7B')(' disable tools (chat only)'));
+        console.log('  ' + chalk.hex('#00D4FF')('exit / quit') + chalk.hex('#6B6B7B')(' end the chat session'));
+        console.log('');
+    }
+    // ── Chat loop ──
+    while (true) {
+        let { message } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'message',
+                message: chalk.hex('#00E676').bold('❯ You '),
+                prefix: '',
+            },
+        ]);
+        // Special interactive flow when user types just "@"
+        if (message.trim() === '@') {
+            try {
+                const dir = process.cwd();
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                if (!entries.length) {
+                    ui.info('No files or folders in current directory');
+                    continue;
+                }
+                const choices = entries.slice(0, 100).map(entry => {
+                    const isDir = entry.isDirectory();
+                    const label = (isDir ? '📁 ' : '📄 ') +
+                        entry.name +
+                        (isDir ? '/' : '');
+                    return {
+                        name: label,
+                        value: entry.name + (isDir ? '/' : ''),
+                    };
+                });
+                const { picked } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'picked',
+                        message: 'Select file or folder',
+                        choices,
+                    },
+                ]);
+                const followUp = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'message',
+                        message: chalk.hex('#00E676').bold('❯ You '),
+                        prefix: '',
+                        default: '@' + picked,
+                    },
+                ]);
+                message = followUp.message;
+            }
+            catch (error) {
+                ui.error('Failed to list files for selection', error);
+                continue;
+            }
+        }
+        if (!message.trim())
+            continue;
+        const trimmed = message.trim();
+        const lowerMessage = trimmed.toLowerCase();
+        if (lowerMessage === '/help') {
+            showSlashHelp();
+            continue;
+        }
+        if (trimmed.startsWith('@')) {
+            await showPathSuggestions(trimmed);
+            continue;
+        }
+        if (lowerMessage === 'exit' || lowerMessage === 'quit') {
+            const stats = agent.getStats();
+            console.log('');
+            if (stats.toolCalls > 0 || stats.iterations > 0) {
+                console.log(chalk.hex('#6B6B7B')(`  session: ${stats.iterations} turns · ${stats.toolCalls} tool calls · ${stats.filesChanged} files changed`));
+                console.log('');
+            }
+            console.log(chalk.hex('#3A3A4A')('  ╭──────────────────────────────────╮'));
+            console.log(chalk.hex('#3A3A4A')('  │') + chalk.hex('#00D4FF')('  👋 See you next time!             ') + chalk.hex('#3A3A4A')('│'));
+            console.log(chalk.hex('#3A3A4A')('  ╰──────────────────────────────────╯'));
+            console.log('');
+            break;
+        }
+        if (lowerMessage === 'clear') {
+            ui.clear();
+            ui.header('1.0.0');
+            ui.chatBanner(process.cwd(), model, baseUrl);
+            continue;
+        }
+        if (lowerMessage === 'tools on') {
+            enableTools = true;
+            ui.success('Tools enabled');
+            continue;
+        }
+        if (lowerMessage === 'tools off') {
+            enableTools = false;
+            ui.success('Tools disabled');
+            continue;
+        }
+        // Reset per-message display flag
+        hasResponse = false;
+        try {
+            const tools = enableTools ? toolExecutor.getTools() : [];
+            // agent.run() resets its iteration/tool counters but KEEPS
+            // the conversation history (this.messages), so the AI has
+            // full context of everything discussed in this session.
+            await agent.run(message, tools, toolExecutor);
+        }
+        catch (error) {
+            ui.error('Failed to process message', error);
+        }
+        console.log('');
+    }
+}
+//# sourceMappingURL=chat.js.map