lumina-code-agent 1.0.0

package/README.md

@@ -0,0 +1,87 @@
+# Lumina Code - AI Coding Agent
+
+The most powerful AI coding agent. Runs locally on your machine. Full filesystem access. Multi-model intelligence. Beautiful TUI.
+
+## Install
+
+### macOS / Linux
+```bash
+curl -fsSL https://luminaai.co.in/install.sh | bash
+```
+
+### Windows (PowerShell)
+```powershell
+irm https://luminaai.co.in/install.ps1 | iex
+```
+
+### npm (any platform)
+```bash
+npm install -g lumina-agent
+```
+
+### bun (any platform)
+```bash
+bun install -g lumina-agent
+```
+
+## Quick Start
+
+```bash
+# 1. Set your OpenRouter API key
+lumina config set openrouter-key YOUR_KEY
+
+# 2. Start building
+lumina code "Build me a React app with Tailwind"
+
+# 3. Or start interactive mode
+lumina code
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `lumina code [prompt]` | Start Lumina Code agent |
+| `lumina code -y [prompt]` | Auto-approve all actions |
+| `lumina code -m <model> [prompt]` | Use specific model |
+| `lumina config` | Show configuration |
+| `lumina config set <key> <value>` | Set config value |
+
+## Models
+
+| Model | Use Case |
+|-------|----------|
+| `openrouter/owl-alpha` | Planning & reasoning (default) |
+| `moonshotai/kimi-k2.6` | Code generation |
+| `openai/gpt-oss-20b:free` | Fast tasks |
+
+## Agent Tools
+
+- **bash** - Run any shell command
+- **read_file** - Read file contents
+- **write_file** - Create or overwrite files
+- **edit_file** - Make precise edits
+- **list_dir** - List directory contents
+- **search_files** - Find files by pattern
+- **grep** - Search file contents
+- **git** - Git operations
+- **npm** - Package management
+- **deploy** - Deploy to Vercel
+- **ask** - Ask user for input
+
+## Configuration
+
+Config stored at `~/.lumina/config.json`:
+
+```json
+{
+  "openrouterKey": "sk-or-...",
+  "defaultModel": "openrouter/owl-alpha",
+  "codingModel": "moonshotai/kimi-k2.6",
+  "fastModel": "openai/gpt-oss-20b:free"
+}
+```
+
+## Get API Key
+
+Get your OpenRouter API key at: https://openrouter.ai/keys

package/dist/agent.d.ts

@@ -0,0 +1,37 @@
+import { LuminaConfig } from '../utils/config';
+import { EventEmitter } from 'events';
+export type AgentEvent = {
+    type: 'thinking';
+} | {
+    type: 'text';
+    content: string;
+} | {
+    type: 'tool_start';
+    tool: string;
+    args: string;
+} | {
+    type: 'tool_end';
+    tool: string;
+    output: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'done';
+    summary: string;
+} | {
+    type: 'ask';
+    question: string;
+    resolve: (answer: string) => void;
+};
+export declare class Agent extends EventEmitter {
+    private messages;
+    private config;
+    private model;
+    private cwd;
+    private autoApprove;
+    private totalTokens;
+    constructor(config: LuminaConfig, model: string, cwd: string, autoApprove: boolean);
+    run(prompt: string): Promise<string>;
+    private executeTool;
+}

package/dist/agent.js

@@ -0,0 +1,311 @@
+// @ts-nocheck
+import { callModel } from '../models/openrouter.js';
+import * as tools from '../tools/index.js';
+import { EventEmitter } from 'events';
+const SYSTEM_PROMPT = `You are LUMINA CODE — an elite AI coding agent running locally on the user's machine. You have full access to the filesystem, terminal, git, npm, and deployment tools.
+
+## YOUR CAPABILITIES
+- Read, write, edit any file
+- Run any shell command
+- Install packages, run builds
+- Git operations (commit, push, branch)
+- Deploy to Vercel
+- Search files and code
+- Spawn sub-agents for parallel work
+
+## HOW YOU WORK
+1. **PLAN**: Analyze the task. Create a step-by-step plan. Think about file structure, dependencies, edge cases.
+2. **ACT**: Execute tools one at a time. Read files before editing. Check if packages exist before installing.
+3. **VALIDATE**: After each step, verify it worked. Run builds. Check for errors.
+4. **ITERATE**: If something fails, debug and fix. Don't give up after one attempt.
+5. **COMPLETE**: When done, summarize what was built and how to use it.
+
+## RULES
+- Always read a file before editing it
+- Run \`npm install\` before importing packages
+- Test builds after making changes
+- Use \`git status\` before committing
+- Ask before destructive operations (rm -rf, git push --force, deploy)
+- Create beautiful, production-quality code
+- Use modern best practices (TypeScript, ES modules, etc.)
+- Write clean, well-commented code
+- Handle errors gracefully
+
+## OUTPUT FORMAT
+When you need to use a tool, output ONLY the tool call in this format:
+\`\`\`
+TOOL: <tool_name>
+PARAMS: <json_params>
+\`\`\`
+
+Example:
+\`\`\`
+TOOL: write_file
+PARAMS: {"path": "src/App.tsx", "content": "..."}
+\`\`\`
+
+After the tool executes, you'll see the result. Then continue with the next step.
+
+## QUALITY STANDARDS
+- Every file you create should be production-ready
+- Use proper TypeScript types
+- Handle edge cases
+- Write accessible, responsive UI
+- Follow the project's existing code style
+- Use the project's existing dependencies when possible
+
+Now let's build something amazing.`;
+const TOOL_DEFINITIONS = [
+    {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: 'Run a shell command. Use for any terminal operation.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The command to run' },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the contents of a file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to read' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Write content to a file. Creates the file if it doesn\'t exist, overwrites if it does.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path to write' },
+                    content: { type: 'string', description: 'File content' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description: 'Edit a file by replacing exact text.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path' },
+                    old_string: { type: 'string', description: 'Exact text to find' },
+                    new_string: { type: 'string', description: 'Replacement text' },
+                },
+                required: ['path', 'old_string', 'new_string'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_dir',
+            description: 'List files and directories.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Search for files by name pattern.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Glob pattern (e.g. "**/*.ts")' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: 'Search for text within files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Search pattern (regex)' },
+                    path: { type: 'string', description: 'File or directory to search' },
+                },
+                required: ['pattern', 'path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'git',
+            description: 'Run git commands.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    args: { type: 'string', description: 'Git command arguments (e.g. "status", "add .")' },
+                },
+                required: ['args'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'npm',
+            description: 'Run npm commands.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    args: { type: 'string', description: 'Npm command arguments (e.g. "install", "run build")' },
+                },
+                required: ['args'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'deploy',
+            description: 'Deploy to Vercel.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    target: { type: 'string', description: 'Deployment target (default: "vercel")' },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'ask',
+            description: 'Ask the user for permission or input.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    question: { type: 'string', description: 'Question to ask' },
+                },
+                required: ['question'],
+            },
+        },
+    },
+];
+export class Agent extends EventEmitter {
+    messages = [];
+    config;
+    model;
+    cwd;
+    autoApprove;
+    totalTokens = 0;
+    constructor(config, model, cwd, autoApprove) {
+        super();
+        this.config = config;
+        this.model = model;
+        this.cwd = cwd;
+        this.autoApprove = autoApprove;
+        this.messages = [{ role: 'system', content: SYSTEM_PROMPT }];
+    }
+    async run(prompt) {
+        this.messages.push({ role: 'user', content: prompt });
+        this.emit('event', { type: 'thinking' });
+        let iterations = 0;
+        const maxIterations = 50;
+        while (iterations < maxIterations) {
+            iterations++;
+            const { content, toolCalls, tokens } = await callModel(this.config.openrouterKey, this.model, this.messages, TOOL_DEFINITIONS, (chunk) => this.emit('event', { type: 'text', content: chunk }));
+            this.totalTokens += tokens;
+            this.messages.push({ role: 'assistant', content });
+            if (toolCalls.length === 0) {
+                // No more tools to call, we're done
+                this.emit('event', { type: 'done', summary: content });
+                return content;
+            }
+            // Execute each tool call
+            for (const tc of toolCalls) {
+                const args = JSON.parse(tc.function.arguments || '{}');
+                this.emit('event', { type: 'tool_start', tool: tc.function.name, args: JSON.stringify(args) });
+                try {
+                    const output = await this.executeTool(tc.function.name, args);
+                    this.emit('event', { type: 'tool_end', tool: tc.function.name, output });
+                    this.messages.push({
+                        role: 'tool',
+                        content: output,
+                        tool_call_id: tc.id,
+                    });
+                }
+                catch (e) {
+                    const errMsg = e.message || String(e);
+                    this.emit('event', { type: 'error', message: errMsg });
+                    this.messages.push({
+                        role: 'tool',
+                        content: `Error: ${errMsg}`,
+                        tool_call_id: tc.id,
+                    });
+                }
+            }
+        }
+        const summary = `Reached max iterations (${maxIterations}). Total tokens: ${this.totalTokens}`;
+        this.emit('event', { type: 'done', summary });
+        return summary;
+    }
+    async executeTool(name, args) {
+        switch (name) {
+            case 'bash':
+                return tools.runCommand(args.command, this.cwd).stdout;
+            case 'read_file':
+                return tools.readFile(args.path);
+            case 'write_file':
+                tools.writeFile(args.path, args.content);
+                return `Wrote ${args.content?.toString().length || 0} chars to ${args.path}`;
+            case 'edit_file':
+                tools.editFile(args.path, args.old_string, args.new_string);
+                return `Edited ${args.path}`;
+            case 'list_dir':
+                const entries = tools.listDir(args.path);
+                return entries.map(e => `${e.isDir ? '📁' : '📄'} ${e.name}${e.isDir ? '' : ` (${e.size}B)`}`).join('\n');
+            case 'search_files':
+                return tools.searchFiles(args.pattern, this.cwd).join('\n') || 'No files found';
+            case 'grep':
+                return tools.grep(args.pattern, args.path).join('\n') || 'No matches';
+            case 'git':
+                return tools.git(args.args, this.cwd);
+            case 'npm':
+                return tools.npm(args.args, this.cwd);
+            case 'deploy':
+                return tools.deployVercel(this.cwd);
+            case 'ask':
+                if (this.autoApprove)
+                    return 'yes';
+                return new Promise((resolve) => {
+                    this.emit('event', { type: 'ask', question: args.question, resolve });
+                });
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONFIG_DIR = join(homedir(), '.lumina');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+async function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_FILE))
+            return null;
+        return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureConfig() {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    const existing = await loadConfig();
+    if (existing)
+        return existing;
+    const defaults = {
+        openrouterKey: '',
+        defaultModel: 'openrouter/owl-alpha',
+        codingModel: 'moonshotai/kimi-k2.6',
+        fastModel: 'openai/gpt-oss-20b:free',
+    };
+    writeFileSync(CONFIG_FILE, JSON.stringify(defaults, null, 2));
+    return defaults;
+}
+const program = new Command();
+program.name('lumina').description('Lumina Code - AI coding agent').version('1.0.0');
+program.command('code')
+    .description('Start Lumina Code agent')
+    .argument('[prompt]', 'What you want to build')
+    .option('-m, --model <model>', 'Model to use')
+    .option('-y, --yes', 'Auto-approve all actions')
+    .option('--cwd <dir>', 'Working directory', process.cwd())
+    .action(async (prompt, opts) => {
+    const config = await ensureConfig();
+    if (!config.openrouterKey) {
+        console.error('\n  ERROR: OpenRouter API key not set.\n');
+        console.error('  Set it with: lumina config set openrouter-key YOUR_KEY');
+        console.error('  Get a key at: https://openrouter.ai/keys\n');
+        process.exit(1);
+    }
+    // Dynamic require to avoid ESM issues
+    const { TUIApp } = require('./tui/index');
+    const { render } = require('ink');
+    const React = require('react');
+    render(React.createElement(TUIApp, {
+        prompt,
+        config,
+        model: opts.model || config.defaultModel || 'openrouter/owl-alpha',
+        autoApprove: opts.yes || false,
+        cwd: opts.cwd,
+    }));
+});
+program.command('config').description('Show configuration').action(async () => {
+    const config = await ensureConfig();
+    console.log('\n  Lumina Code Configuration\n');
+    console.log('  Config:', CONFIG_FILE);
+    console.log('  API Key:', config.openrouterKey ? 'Set (' + config.openrouterKey.slice(0, 8) + '...)' : 'NOT SET');
+    console.log('  Default:', config.defaultModel || 'openrouter/owl-alpha');
+    console.log('  Coding:', config.codingModel || 'moonshotai/kimi-k2.6');
+    console.log('  Fast:', config.fastModel || 'openai/gpt-oss-20b:free\n');
+});
+program.command('config set <key> <value>').description('Set config value').action(async (key, value) => {
+    const config = await ensureConfig();
+    const map = { 'openrouter-key': 'openrouterKey', 'default-model': 'defaultModel', 'coding-model': 'codingModel', 'fast-model': 'fastModel' };
+    config[map[key] || key] = value;
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    console.log('  Set', key, '=', value);
+});
+program.parse();

package/dist/models/openrouter.d.ts

@@ -0,0 +1,40 @@
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    tool_call_id?: string;
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ModelResponse {
+    choices: Array<{
+        delta?: {
+            content?: string;
+            tool_calls?: Array<{
+                id?: string;
+                type?: 'function';
+                function?: {
+                    name?: string;
+                    arguments?: string;
+                };
+            }>;
+        };
+        message?: {
+            content?: string;
+            tool_calls?: ToolCall[];
+        };
+    }>;
+    usage?: {
+        total_tokens: number;
+    };
+}
+export declare function callModel(apiKey: string, model: string, messages: Message[], tools?: object[], onChunk?: (text: string) => void): Promise<{
+    content: string;
+    toolCalls: ToolCall[];
+    tokens: number;
+}>;

package/dist/models/openrouter.js

@@ -0,0 +1,93 @@
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions';
+export async function callModel(apiKey, model, messages, tools, onChunk) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+        'HTTP-Referer': 'https://luminaai.co.in',
+        'X-Title': 'Lumina Code',
+    };
+    // Try primary key, fall back to env
+    const keys = [apiKey, ...(process.env.OPENROUTER_API_KEY ? [process.env.OPENROUTER_API_KEY] : [])].filter(Boolean);
+    for (const key of keys) {
+        try {
+            const res = await fetch(OPENROUTER_URL, {
+                method: 'POST',
+                headers: { ...headers, Authorization: `Bearer ${key}` },
+                body: JSON.stringify({
+                    model,
+                    messages: messages.map(m => {
+                        if (m.role === 'tool') {
+                            return { role: 'tool', content: m.content, tool_call_id: m.tool_call_id };
+                        }
+                        return { role: m.role, content: m.content };
+                    }),
+                    tools: tools || undefined,
+                    stream: true,
+                    max_tokens: 32000,
+                    temperature: 0.3,
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.text().catch(() => '');
+                console.error(`Model ${model} error ${res.status}: ${err.slice(0, 200)}`);
+                continue;
+            }
+            const reader = res.body?.getReader();
+            if (!reader)
+                continue;
+            const decoder = new TextDecoder();
+            let buf = '';
+            let content = '';
+            let toolCalls = [];
+            let tokens = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let nl;
+                while ((nl = buf.indexOf('\n')) !== -1) {
+                    let line = buf.slice(0, nl);
+                    buf = buf.slice(nl + 1);
+                    if (line.endsWith('\r'))
+                        line = line.slice(0, -1);
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const json = line.slice(6).trim();
+                    if (json === '[DONE]')
+                        continue;
+                    try {
+                        const parsed = JSON.parse(json);
+                        const delta = parsed.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            content += delta.content;
+                            onChunk?.(delta.content);
+                        }
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const idx = toolCalls.length;
+                                if (!toolCalls[idx]) {
+                                    toolCalls[idx] = { id: tc.id || '', type: 'function', function: { name: tc.function?.name || '', arguments: '' } };
+                                }
+                                if (tc.function?.arguments) {
+                                    toolCalls[idx].function.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        if (parsed.usage?.total_tokens)
+                            tokens = parsed.usage.total_tokens;
+                    }
+                    catch { /* skip malformed */ }
+                }
+            }
+            if (content || toolCalls.length > 0) {
+                return { content, toolCalls, tokens };
+            }
+        }
+        catch (e) {
+            console.error(`Model ${model} failed:`, e);
+            continue;
+        }
+    }
+    throw new Error('All models failed');
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,22 @@
+export declare function getShell(): {
+    cmd: string;
+    args: string[];
+};
+export declare function runCommand(command: string, cwd: string): {
+    stdout: string;
+    stderr: string;
+    code: number;
+};
+export declare function readFile(path: string): string;
+export declare function writeFile(path: string, content: string): void;
+export declare function editFile(path: string, oldString: string, newString: string): void;
+export declare function listDir(path: string): {
+    name: string;
+    isDir: boolean;
+    size: number;
+}[];
+export declare function searchFiles(pattern: string, cwd: string): string[];
+export declare function grep(pattern: string, path: string): string[];
+export declare function git(args: string, cwd: string): string;
+export declare function npm(args: string, cwd: string): string;
+export declare function deployVercel(cwd: string): string;

package/dist/tools/index.js

@@ -0,0 +1,293 @@
+// @ts-nocheck
+/**
+ * LUMINA CODE — The Ultimate AI Coding Agent
+ *
+ * Better than Claude Code. Better than Codex. Better than Cursor.
+ *
+ * Architecture:
+ * - Single model: openrouter/owl-alpha (best reasoning, 1M+ context)
+ * - Effort levels: quick, normal, beast
+ * - Full filesystem access
+ * - Multi-file operations
+ * - Self-healing code
+ * - Automatic deployment
+ */
+import { execSync, spawn } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, readdirSync, unlinkSync, renameSync, copyFileSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+// ── Shell Detection ─────────────────────────────────────────────────
+export function getShell() {
+    if (process.platform === 'win32')
+        return process.env.COMSPEC || 'cmd.exe';
+    return process.env.SHELL || '/bin/bash';
+}
+export function detectOS() {
+    const os = process.platform === 'win32' ? 'windows' : process.platform === 'darwin' ? 'mac' : 'linux';
+    return { os, arch: process.arch };
+}
+// ── Command Execution ───────────────────────────────────────────────
+export function runCommand(command, cwd, timeout = 120_000) {
+    try {
+        const result = execSync(command, {
+            cwd, encoding: 'utf-8', maxBuffer: 50 * 1024 * 1024, timeout,
+            stdio: ['pipe', 'pipe', 'pipe'], shell: getShell(),
+            env: { ...process.env, PYTHONUNBUFFERED: '1', FORCE_COLOR: '0' },
+        });
+        return { stdout: result, stderr: '', code: 0 };
+    }
+    catch (e) {
+        return { stdout: e.stdout?.toString() || '', stderr: e.stderr?.toString() || e.message || '', code: e.status || 1 };
+    }
+}
+export function runCommandStreaming(command, cwd, onOutput) {
+    return new Promise((resolve) => {
+        const shell = getShell();
+        const child = spawn(command, { cwd, shell, stdio: ['pipe', 'pipe', 'pipe'], env: process.env });
+        child.stdout?.on('data', (d) => onOutput(d.toString()));
+        child.stderr?.on('data', (d) => onOutput(d.toString()));
+        child.on('close', (code) => resolve(code || 0));
+        child.on('error', () => resolve(1));
+    });
+}
+// ── File Operations ─────────────────────────────────────────────────
+export function readFile(path) {
+    if (!existsSync(path))
+        throw new Error('File not found: ' + path);
+    return readFileSync(path, 'utf-8');
+}
+export function writeFile(path, content) {
+    const dir = dirname(resolve(path));
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(path, content, 'utf-8');
+}
+export function editFile(path, replacements) {
+    let content = readFile(path);
+    for (const { search, replace } of replacements) {
+        if (!content.includes(search))
+            throw new Error('String not found in ' + path + ': "' + search.slice(0, 80) + '"');
+        content = content.replace(search, replace);
+    }
+    writeFile(path, content);
+}
+export function deleteFile(path) {
+    if (existsSync(path))
+        unlinkSync(path);
+}
+export function moveFile(from, to) {
+    const dir = dirname(resolve(to));
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    renameSync(from, to);
+}
+export function copyFile(from, to) {
+    const dir = dirname(resolve(to));
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    copyFileSync(from, to);
+}
+export function listDir(path) {
+    if (!existsSync(path))
+        throw new Error('Directory not found: ' + path);
+    return readdirSync(path, { withFileTypes: true }).map(e => {
+        const p = join(path, e.name);
+        const stat = statSync(p);
+        return { name: e.name, isDir: e.isDirectory(), size: stat.size, modified: stat.mtimeMs };
+    });
+}
+export function searchFiles(pattern, cwd) {
+    try {
+        return require('glob').sync(pattern, { cwd, nodir: true, ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**'] });
+    }
+    catch {
+        return [];
+    }
+}
+export function grep(pattern, path, context = 2) {
+    try {
+        const content = readFile(path);
+        const lines = content.split('\n');
+        const regex = new RegExp(pattern, 'gi');
+        const results = [];
+        lines.forEach((line, i) => {
+            if (regex.test(line)) {
+                const start = Math.max(0, i - context);
+                const end = Math.min(lines.length, i + context + 1);
+                results.push(lines.slice(start, end).map((l, j) => `${start + j + 1}: ${l}`).join('\n'));
+            }
+        });
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+export function getFileTree(path, depth = 3, prefix = '') {
+    if (depth === 0)
+        return '';
+    const entries = listDir(path).filter(e => !e.name.startsWith('.') && e.name !== 'node_modules' && e.name !== 'dist');
+    return entries.map((e, i) => {
+        const isLast = i === entries.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const childPrefix = isLast ? '    ' : '│   ';
+        let line = prefix + connector + e.name + (e.isDir ? '/' : ` (${formatSize(e.size)})`);
+        if (e.isDir)
+            line += '\n' + getFileTree(join(path, e.name), depth - 1, prefix + childPrefix);
+        return line;
+    }).join('\n');
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return bytes + 'B';
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + 'KB';
+    return (bytes / (1024 * 1024)).toFixed(1) + 'MB';
+}
+// ── Git Operations ──────────────────────────────────────────────────
+export function git(args, cwd) {
+    const { stdout, stderr, code } = runCommand('git ' + args, cwd);
+    if (code !== 0)
+        throw new Error(stderr || ('git ' + args + ' failed'));
+    return stdout.trim();
+}
+export function gitStatus(cwd) { return git('status --short', cwd); }
+export function gitDiff(cwd) { return git('diff', cwd); }
+export function gitLog(cwd, n = 10) { return git('log --oneline -' + n, cwd); }
+export function gitCommit(message, cwd) { return git('add -A && git commit -m "' + message.replace(/"/g, '\\"') + '"', cwd); }
+export function gitPush(cwd) { return git('push', cwd); }
+export function gitBranch(cwd) { return git('branch --show-current', cwd); }
+export function gitCreateBranch(name, cwd) { return git('checkout -b ' + name, cwd); }
+// ── Package Manager ─────────────────────────────────────────────────
+export function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock')))
+        return 'bun';
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+export function pkgInstall(packages, cwd, dev = false) {
+    const pm = detectPackageManager(cwd);
+    const cmd = pm === 'bun' ? 'bun add' : pm === 'yarn' ? 'yarn add' : pm === 'pnpm' ? 'pnpm add' : 'npm install';
+    const flag = dev ? (pm === 'yarn' ? ' -D' : ' --save-dev') : '';
+    return runCommand(`${cmd}${flag} ${packages.join(' ')}`, cwd).stdout;
+}
+export function pkgRun(script, cwd) {
+    const pm = detectPackageManager(cwd);
+    const cmd = pm === 'bun' ? 'bun run' : pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm' : 'npm run';
+    return runCommand(`${cmd} ${script}`, cwd).stdout;
+}
+// ── Deployment ──────────────────────────────────────────────────────
+export function deployVercel(cwd) {
+    const { stdout, stderr, code } = runCommand('npx vercel deploy --prod --yes', cwd, 300_000);
+    if (code !== 0)
+        throw new Error(stderr || 'Vercel deploy failed');
+    const urlMatch = stdout.match(/https:\/\/[a-z0-9-]+\.vercel\.app/);
+    return urlMatch ? urlMatch[0] : stdout.trim();
+}
+export function deployNetlify(cwd) {
+    const { stdout, stderr, code } = runCommand('npx netlify deploy --prod --dir=dist', cwd, 300_000);
+    if (code !== 0)
+        throw new Error(stderr || 'Netlify deploy failed');
+    return stdout.trim();
+}
+// ── Project Detection ───────────────────────────────────────────────
+export function detectProjectType(cwd) {
+    return {
+        react: existsSync(join(cwd, 'package.json')) && (readFileSync(join(cwd, 'package.json'), 'utf-8').includes('"react"') || existsSync(join(cwd, 'src/App.tsx')) || existsSync(join(cwd, 'src/App.jsx'))),
+        nextjs: existsSync(join(cwd, 'next.config.js')) || existsSync(join(cwd, 'next.config.ts')) || existsSync(join(cwd, 'next.config.mjs')),
+        vite: existsSync(join(cwd, 'vite.config.ts')) || existsSync(join(cwd, 'vite.config.js')),
+        typescript: existsSync(join(cwd, 'tsconfig.json')),
+        tailwind: existsSync(join(cwd, 'tailwind.config.ts')) || existsSync(join(cwd, 'tailwind.config.js')),
+        node: existsSync(join(cwd, 'package.json')),
+        python: existsSync(join(cwd, 'requirements.txt')) || existsSync(join(cwd, 'pyproject.toml')) || existsSync(join(cwd, 'setup.py')),
+        rust: existsSync(join(cwd, 'Cargo.toml')),
+        go: existsSync(join(cwd, 'go.mod')),
+        docker: existsSync(join(cwd, 'Dockerfile')),
+    };
+}
+// ── LLM API ─────────────────────────────────────────────────────────
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions';
+export async function callLLM(apiKey, messages, tools, onChunk, model = 'openrouter/owl-alpha') {
+    const keys = [apiKey, ...(process.env.OPENROUTER_API_KEY ? [process.env.OPENROUTER_API_KEY] : [])].filter(Boolean);
+    for (const key of keys) {
+        try {
+            const res = await fetch(OPENROUTER_URL, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${key}`,
+                    'HTTP-Referer': 'https://luminaai.co.in',
+                    'X-Title': 'Lumina Code',
+                },
+                body: JSON.stringify({
+                    model,
+                    messages: messages.map(m => m.role === 'tool' ? { role: 'tool', content: m.content, tool_call_id: m.tool_call_id } : { role: m.role, content: m.content }),
+                    tools: tools || undefined,
+                    stream: true,
+                    max_tokens: 32000,
+                    temperature: 0.1,
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.text().catch(() => '');
+                console.error(`Model error ${res.status}: ${err.slice(0, 200)}`);
+                continue;
+            }
+            const reader = res.body?.getReader();
+            if (!reader)
+                continue;
+            const decoder = new TextDecoder();
+            let buf = '', content = '', toolCalls = [], tokens = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                let nl;
+                while ((nl = buf.indexOf('\n')) !== -1) {
+                    let line = buf.slice(0, nl);
+                    buf = buf.slice(nl + 1);
+                    if (line.endsWith('\r'))
+                        line = line.slice(0, -1);
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const json = line.slice(6).trim();
+                    if (json === '[DONE]')
+                        continue;
+                    try {
+                        const parsed = JSON.parse(json);
+                        const delta = parsed?.choices?.[0]?.delta;
+                        if (delta?.content) {
+                            content += delta.content;
+                            onChunk?.(delta.content);
+                        }
+                        if (delta?.tool_calls) {
+                            for (const tc of delta.tool_calls) {
+                                const idx = toolCalls.length;
+                                if (!toolCalls[idx])
+                                    toolCalls[idx] = { id: tc.id || '', type: 'function', function: { name: tc.function?.name || '', arguments: '' } };
+                                if (tc.function?.arguments)
+                                    toolCalls[idx].function.arguments += tc.function.arguments;
+                            }
+                        }
+                        if (parsed.usage?.total_tokens)
+                            tokens = parsed.usage.total_tokens;
+                    }
+                    catch {
+                        buf = line + '\n' + buf;
+                        break;
+                    }
+                }
+            }
+            if (content || toolCalls.length > 0)
+                return { content, toolCalls, tokens };
+        }
+        catch (e) {
+            console.error('LLM call failed:', e);
+            continue;
+        }
+    }
+    throw new Error('All LLM calls failed');
+}

package/dist/tui/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import React from 'react';
+import { LuminaConfig } from '../utils/config.js';
+interface Props {
+    prompt?: string;
+    config: LuminaConfig;
+    model: string;
+    autoApprove: boolean;
+    cwd: string;
+}
+export declare function TUIApp({ prompt, config, model, autoApprove, cwd }: Props): React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;
+export {};

package/dist/tui/index.js

@@ -0,0 +1,115 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { Agent } from '../agent.js';
+import { basename } from 'path';
+const C = {
+    brand: '#7C5CFC',
+    teal: '#2DD4BF',
+    amber: '#F59E0B',
+    red: '#F87171',
+    green: '#34D399',
+    text: '#E4E4E7',
+    muted: '#52525B',
+    dim: '#3F3F46',
+};
+export function TUIApp({ prompt, config, model, autoApprove, cwd }) {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [status, setStatus] = useState('Initializing...');
+    const [thinking, setThinking] = useState(false);
+    const [toolCount, setToolCount] = useState(0);
+    const [inputMode, setInputMode] = useState(false);
+    const [inputBuffer, setInputBuffer] = useState('');
+    const [pendingResolve, setPendingResolve] = useState(null);
+    const [startTime] = useState(Date.now());
+    const msgId = React.useRef(0);
+    const addMsg = useCallback((role, content, tool) => {
+        setMessages(prev => [...prev.slice(-200), { id: msgId.current++, role, content, tool, ts: Date.now() }]);
+    }, []);
+    useEffect(() => {
+        const a = new Agent(config, model, cwd, autoApprove);
+        a.on('event', (e) => {
+            switch (e.type) {
+                case 'thinking':
+                    setThinking(true);
+                    setStatus('Thinking...');
+                    break;
+                case 'text':
+                    setThinking(false);
+                    setStatus('Streaming...');
+                    setMessages(prev => {
+                        const last = prev[prev.length - 1];
+                        if (last && last.role === 'assistant' && last.id === msgId.current - 1) {
+                            return [...prev.slice(0, -1), { ...last, content: last.content + e.content }];
+                        }
+                        return [...prev.slice(-200), { id: msgId.current++, role: 'assistant', content: e.content, ts: Date.now() }];
+                    });
+                    break;
+                case 'tool_start':
+                    setToolCount(c => c + 1);
+                    addMsg('tool', e.tool + '(' + e.args.slice(0, 60) + ')', e.tool);
+                    setStatus('Running: ' + e.tool);
+                    break;
+                case 'tool_end':
+                    addMsg('tool', e.output.slice(0, 150) || '(ok)');
+                    setStatus('Tool complete');
+                    break;
+                case 'error':
+                    addMsg('system', 'ERR: ' + e.message);
+                    setStatus('Error');
+                    break;
+                case 'ask':
+                    setInputMode(true);
+                    setStatus('Waiting...');
+                    addMsg('system', '? ' + e.question);
+                    setPendingResolve(() => e.resolve);
+                    break;
+                case 'done':
+                    setThinking(false);
+                    addMsg('system', 'DONE: ' + e.summary);
+                    setStatus('Finished');
+                    break;
+            }
+        });
+        const run = async () => {
+            try {
+                const p = prompt || 'Hello! I am Lumina Code. What would you like to build?';
+                addMsg('user', p);
+                await a.run(p);
+            }
+            catch (err) {
+                addMsg('system', 'FATAL: ' + err.message);
+                setStatus('Failed');
+            }
+        };
+        run();
+    }, []);
+    useInput((input, key) => {
+        if (inputMode) {
+            if (key.return) {
+                if (pendingResolve) {
+                    addMsg('user', inputBuffer);
+                    pendingResolve(inputBuffer);
+                    setPendingResolve(null);
+                }
+                setInputBuffer('');
+                setInputMode(false);
+            }
+            else if (key.backspace || key.delete) {
+                setInputBuffer(prev => prev.slice(0, -1));
+            }
+            else {
+                setInputBuffer(prev => prev + input);
+            }
+        }
+        else {
+            if (key.ctrl && input === 'c')
+                exit();
+        }
+    });
+    const visible = messages.slice(-30);
+    const modelShort = (model.split('/').pop() || model);
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const timeStr = Math.floor(elapsed / 60) + ':' + (elapsed % 60).toString().padStart(2, '0');
+    return React.createElement(Box, { flexDirection: 'column', height: '100%' }, React.createElement(Box, { borderStyle: 'round', borderColor: C.brand, paddingX: 2, paddingY: 1 }, React.createElement(Text, { bold: true, color: C.brand }, ' LUMINA CODE '), React.createElement(Text, { color: C.muted }, ' | '), React.createElement(Text, { color: C.text }, basename(cwd)), React.createElement(Text, { color: C.muted }, ' | '), React.createElement(Text, { color: C.teal }, modelShort), thinking ? React.createElement(Text, { color: C.amber }, ' *') : null, React.createElement(Text, { color: C.dim }, ' | '), React.createElement(Text, { color: C.dim }, timeStr)), React.createElement(Box, { flexDirection: 'column', flexGrow: 1, paddingX: 2, paddingY: 1 }, visible.map(m => React.createElement(Box, { key: m.id }, React.createElement(Text, { color: C.muted }, m.role === 'user' ? '> ' : '  '), React.createElement(Text, { color: m.role === 'user' ? C.brand : m.role === 'tool' ? C.dim : m.role === 'system' ? C.amber : C.text }, m.content.slice(0, 600)))), thinking ? React.createElement(Text, { color: C.amber }, '  ...') : null), inputMode ? React.createElement(Box, { borderStyle: 'single', borderColor: C.brand, paddingX: 1 }, React.createElement(Text, { color: C.brand }, '> '), React.createElement(Text, null, inputBuffer), React.createElement(Text, { color: C.muted }, '_')) : null, React.createElement(Box, { paddingX: 2, paddingY: 1, borderStyle: 'single', borderColor: C.dim }, React.createElement(Text, { color: C.muted }, ' ' + status), React.createElement(Text, { color: C.dim }, ' | tools: ' + toolCount), React.createElement(Text, { color: C.dim }, ' | ' + timeStr), React.createElement(Text, { color: C.dim }, ' | Ctrl+C exit')));
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,10 @@
+export interface LuminaConfig {
+    openrouterKey: string;
+    defaultModel: string;
+    codingModel: string;
+    fastModel: string;
+}
+export declare function loadConfig(): Promise<LuminaConfig | null>;
+export declare function ensureConfig(): Promise<LuminaConfig>;
+export declare function saveSession(id: string, data: unknown): void;
+export declare function loadSession(id: string): unknown | null;

package/dist/utils/config.js

@@ -0,0 +1,44 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONFIG_DIR = join(homedir(), '.lumina');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const SESSIONS_DIR = join(CONFIG_DIR, 'sessions');
+export async function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_FILE))
+            return null;
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function ensureConfig() {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!existsSync(SESSIONS_DIR))
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+    const existing = await loadConfig();
+    if (existing)
+        return existing;
+    const defaults = {
+        openrouterKey: '',
+        defaultModel: 'openrouter/owl-alpha',
+        codingModel: 'moonshotai/kimi-k2.6',
+        fastModel: 'openai/gpt-oss-20b:free',
+    };
+    writeFileSync(CONFIG_FILE, JSON.stringify(defaults, null, 2));
+    return defaults;
+}
+export function saveSession(id, data) {
+    const file = join(SESSIONS_DIR, `${id}.json`);
+    writeFileSync(file, JSON.stringify(data, null, 2));
+}
+export function loadSession(id) {
+    const file = join(SESSIONS_DIR, `${id}.json`);
+    if (!existsSync(file))
+        return null;
+    return JSON.parse(readFileSync(file, 'utf-8'));
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "lumina-code-agent",
+  "version": "1.0.0",
+  "description": "Lumina Code - AI coding agent",
+  "license": "MIT",
+  "type": "module",
+  "bin": { "lumina": "dist/index.js" },
+  "main": "dist/index.js",
+  "files": ["dist/", "README.md"],
+  "engines": { "node": ">=18.0.0" },
+  "scripts": { "build": "tsc --noEmit false", "prepublishOnly": "npm run build" },
+  "dependencies": {
+    "commander": "^12.1.0", "ink": "^5.1.0", "react": "^18.3.1",
+    "chalk": "^5.3.0", "cross-spawn": "^7.0.3", "glob": "^11.0.0", "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0", "@types/cross-spawn": "^6.0.6", "typescript": "^5.7.2"
+  }
+}