@demirarch/recode 0.1.0

package/dist/lib/commands.js

@@ -0,0 +1,79 @@
+import { MODELS } from './models.js';
+export const HELP_TEXT = `
+Recode — AI Coding Agent  (github.com/demirgitbuh/recode)
+
+SLASH COMMANDS
+  /help              Show this help
+  /model             Change AI model
+  /models            List all available models
+  /clear             Clear conversation history
+  /exit  /quit       Exit Recode
+  /cd <path>         Change working directory
+  /ls [path]         List directory contents
+  /read <path>       Read file and show contents
+  /tools             List available AI tools
+  /cwd               Show current working directory
+  /version           Show Recode version
+
+KEYBINDINGS
+  Enter              Send message
+  Ctrl+C             Exit
+  Ctrl+L             Clear screen
+`.trim();
+const TOOLS_TEXT = `
+AI TOOLS (called automatically by the AI)
+  read_file <path>            Read file contents
+  write_file <path> <content> Create or overwrite a file
+  list_directory [path]       List directory entries
+  create_directory <path>     Create directory (recursive)
+  delete_file <path>          Delete a file
+  execute_command <cmd>       Run shell command in cwd
+  search_files <pattern>      Search files for pattern
+`.trim();
+export function parseCommand(input, cwd) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return { type: 'none' };
+    const [cmd, ...rest] = trimmed.slice(1).split(' ');
+    const arg = rest.join(' ').trim();
+    switch (cmd.toLowerCase()) {
+        case 'help':
+            return { type: 'system', content: HELP_TEXT };
+        case 'model':
+            return { type: 'open_model_select' };
+        case 'models': {
+            const list = MODELS.map((m) => `  ${m.provider.padEnd(11)} ${m.label.padEnd(22)} ${m.id}`).join('\n');
+            return { type: 'system', content: `Available models:\n\n${list}` };
+        }
+        case 'clear':
+            return { type: 'clear' };
+        case 'exit':
+        case 'quit':
+        case 'q':
+            return { type: 'exit' };
+        case 'cd':
+            if (!arg)
+                return { type: 'system', content: `Usage: /cd <path>` };
+            return { type: 'cd', path: arg };
+        case 'ls': {
+            const p = arg || cwd;
+            return { type: 'send_to_ai', content: `List the directory: ${p}` };
+        }
+        case 'read': {
+            if (!arg)
+                return { type: 'system', content: `Usage: /read <path>` };
+            return { type: 'send_to_ai', content: `Read and show the file: ${arg}` };
+        }
+        case 'tools':
+            return { type: 'system', content: TOOLS_TEXT };
+        case 'cwd':
+            return { type: 'system', content: `Working directory: ${cwd}` };
+        case 'version':
+            return { type: 'system', content: 'Recode v0.1.0 — by DemirArch' };
+        default:
+            return {
+                type: 'system',
+                content: `Unknown command: /${cmd}\nType /help for available commands.`,
+            };
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,22 @@
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+const CONFIG_DIR = path.join(os.homedir(), 'recode-data');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+export async function loadConfig() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.apiKey && parsed.model) {
+            return { apiKey: parsed.apiKey, model: parsed.model };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveConfig(config) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}

package/dist/lib/models.js

@@ -0,0 +1,56 @@
+export const MODELS = [
+    // Anthropic
+    { id: 'anthropic/claude-opus-4-5', label: 'Claude Opus 4.5', provider: 'Anthropic' },
+    { id: 'anthropic/claude-sonnet-4-5', label: 'Claude Sonnet 4.5 ★', provider: 'Anthropic' },
+    { id: 'anthropic/claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', provider: 'Anthropic' },
+    { id: 'anthropic/claude-3-5-sonnet', label: 'Claude 3.5 Sonnet', provider: 'Anthropic' },
+    { id: 'anthropic/claude-3-5-haiku', label: 'Claude 3.5 Haiku', provider: 'Anthropic' },
+    { id: 'anthropic/claude-3-opus', label: 'Claude 3 Opus', provider: 'Anthropic' },
+    // OpenAI
+    { id: 'openai/gpt-4o', label: 'GPT-4o', provider: 'OpenAI' },
+    { id: 'openai/gpt-4o-mini', label: 'GPT-4o Mini', provider: 'OpenAI' },
+    { id: 'openai/o1', label: 'o1', provider: 'OpenAI' },
+    { id: 'openai/o1-mini', label: 'o1 Mini', provider: 'OpenAI' },
+    { id: 'openai/o3-mini', label: 'o3 Mini', provider: 'OpenAI' },
+    { id: 'openai/o4-mini', label: 'o4 Mini', provider: 'OpenAI' },
+    { id: 'openai/gpt-4-turbo', label: 'GPT-4 Turbo', provider: 'OpenAI' },
+    // Google
+    { id: 'google/gemini-2.5-pro', label: 'Gemini 2.5 Pro', provider: 'Google' },
+    { id: 'google/gemini-2.5-flash', label: 'Gemini 2.5 Flash', provider: 'Google' },
+    { id: 'google/gemini-flash-1.5', label: 'Gemini Flash 1.5', provider: 'Google' },
+    { id: 'google/gemini-pro-1.5', label: 'Gemini Pro 1.5', provider: 'Google' },
+    // Meta
+    { id: 'meta-llama/llama-4-maverick', label: 'Llama 4 Maverick', provider: 'Meta' },
+    { id: 'meta-llama/llama-4-scout', label: 'Llama 4 Scout', provider: 'Meta' },
+    { id: 'meta-llama/llama-3.3-70b-instruct', label: 'Llama 3.3 70B', provider: 'Meta' },
+    { id: 'meta-llama/llama-3.1-405b-instruct', label: 'Llama 3.1 405B', provider: 'Meta' },
+    // DeepSeek
+    { id: 'deepseek/deepseek-chat', label: 'DeepSeek Chat V3', provider: 'DeepSeek' },
+    { id: 'deepseek/deepseek-r1', label: 'DeepSeek R1', provider: 'DeepSeek' },
+    { id: 'deepseek/deepseek-r1-distill-llama-70b', label: 'DeepSeek R1 Distill 70B', provider: 'DeepSeek' },
+    // Mistral
+    { id: 'mistralai/mistral-large', label: 'Mistral Large', provider: 'Mistral' },
+    { id: 'mistralai/mistral-small', label: 'Mistral Small', provider: 'Mistral' },
+    { id: 'mistralai/codestral-latest', label: 'Codestral', provider: 'Mistral' },
+    { id: 'mistralai/mixtral-8x22b-instruct', label: 'Mixtral 8x22B', provider: 'Mistral' },
+    // Qwen
+    { id: 'qwen/qwen3-235b-a22b', label: 'Qwen3 235B', provider: 'Qwen' },
+    { id: 'qwen/qwen-2.5-72b-instruct', label: 'Qwen 2.5 72B', provider: 'Qwen' },
+    { id: 'qwen/qwen-2.5-coder-32b-instruct', label: 'Qwen 2.5 Coder 32B', provider: 'Qwen' },
+    // Cohere
+    { id: 'cohere/command-r-plus', label: 'Command R+', provider: 'Cohere' },
+    { id: 'cohere/command-r', label: 'Command R', provider: 'Cohere' },
+    // xAI
+    { id: 'x-ai/grok-3', label: 'Grok 3', provider: 'xAI' },
+    { id: 'x-ai/grok-3-mini', label: 'Grok 3 Mini', provider: 'xAI' },
+    // Microsoft
+    { id: 'microsoft/phi-4', label: 'Phi-4', provider: 'Microsoft' },
+    { id: 'microsoft/wizardlm-2-8x22b', label: 'WizardLM 2 8x22B', provider: 'Microsoft' },
+];
+export const MODEL_SELECT_ITEMS = MODELS.map((m) => ({
+    label: `${m.provider.padEnd(11)} ${m.label}`,
+    value: m.id,
+}));
+export function getModelLabel(id) {
+    return MODELS.find((m) => m.id === id)?.label ?? id.split('/')[1] ?? id;
+}

package/dist/lib/openrouter.js

@@ -0,0 +1,94 @@
+import { TOOL_DEFINITIONS } from './tools.js';
+// ── System Prompt ─────────────────────────────────────────────
+export const SYSTEM_PROMPT = `You are Recode — an autonomous AI coding agent built by DemirArch.
+You run inside a terminal and have direct access to the filesystem and shell through your tools.
+
+━━━ IDENTITY ━━━
+Name:      Recode
+Author:    DemirArch  (github.com/demirgitbuh/recode)
+Interface: Terminal TUI (Ink + React + TypeScript)
+Mission:   Autonomous software development — from idea to working code
+
+━━━ CAPABILITIES ━━━
+You can read, write, and create any file; execute shell commands; explore
+directories; search codebases. You are capable of building entire projects
+from scratch, debugging production bugs, refactoring legacy code, setting up
+CI/CD, writing tests, managing git, installing packages, and more.
+
+━━━ CORE RULES ━━━
+1. Always complete tasks fully. Never stub, never "TODO" without implementing.
+2. Read before edit — use read_file before modifying any existing file.
+3. Explore before assuming — use list_directory on unfamiliar codebases.
+4. Verify your work — run the code, test it, check for errors with execute_command.
+5. Chain as many tools as needed to finish the job completely.
+6. Never truncate code in write_file — write the complete file every time.
+7. If ambiguous, make a reasonable assumption, state it once, and proceed.
+8. Ask at most ONE clarifying question per turn, only when truly needed.
+9. When creating multi-file projects, create ALL files before reporting done.
+10. Always create parent directories before writing files.
+
+━━━ OUTPUT STYLE ━━━
+- Terminal display — keep lines under 80 characters when possible.
+- Use fenced code blocks with language tags in explanations.
+- No filler: skip "Certainly!", "Great question!", "Of course!", "Sure!".
+- File operations: one line per file, brief and clear.
+- Errors: show the error → root cause → fix. In that order, no padding.
+- When done with a multi-step task, give a concise summary of what was built.
+
+━━━ CODE STANDARDS ━━━
+- Write production-quality, runnable code. No placeholder logic.
+- Match existing style when editing projects (indentation, naming, imports).
+- Comments only for non-obvious logic. No docstring spam.
+- Handle errors at system boundaries (user input, network, filesystem).
+- Use the language's modern idioms and standard library features.
+- Prefer explicit over clever. Prefer simple over abstract.
+- Never add features the user didn't ask for.
+
+━━━ TOOL DISCIPLINE ━━━
+read_file        — call before any edit to understand current content
+write_file       — complete file content only; never partial or truncated
+execute_command  — builds, tests, git, npm, pip, cargo, go, linters, etc.
+list_directory   — first action when exploring an unfamiliar codebase
+create_directory — call before write_file when parent dir may not exist
+delete_file      — only when explicitly requested or clearly needed
+search_files     — find definitions, usages, or patterns before assuming
+
+━━━ LANGUAGE EXPERTISE ━━━
+You are expert-level in: TypeScript, JavaScript, Python, Rust, Go, C, C++,
+C#, Java, Ruby, Swift, Kotlin, PHP, Bash, SQL, HTML, CSS, SCSS, React,
+Vue, Svelte, Next.js, Express, FastAPI, Django, Axum, and more.
+You know package managers: npm, pnpm, yarn, pip, cargo, go mod, apt, brew.
+You know tools: git, docker, docker-compose, make, cmake, webpack, vite, esbuild.`;
+// ── API Client ────────────────────────────────────────────────
+export async function callOpenRouter(messages, model, apiKey) {
+    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'HTTP-Referer': 'https://github.com/demirgitbuh/recode',
+            'X-Title': 'Recode',
+        },
+        body: JSON.stringify({
+            model,
+            messages: [{ role: 'system', content: SYSTEM_PROMPT }, ...messages],
+            tools: TOOL_DEFINITIONS,
+            tool_choice: 'auto',
+            stream: false,
+        }),
+    });
+    if (!response.ok) {
+        const err = await response.text();
+        throw new Error(`OpenRouter ${response.status}: ${err}`);
+    }
+    const data = (await response.json());
+    if (data.error)
+        throw new Error(data.error.message);
+    const msg = data.choices?.[0]?.message;
+    if (!msg)
+        throw new Error('Empty response from OpenRouter');
+    return {
+        content: msg.content ?? null,
+        tool_calls: msg.tool_calls?.length ? msg.tool_calls : null,
+    };
+}

package/dist/lib/tools.js

@@ -0,0 +1,211 @@
+import { promises as fs } from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+const execAsync = promisify(exec);
+// ── OpenRouter tool definitions ──────────────────────────────
+export const TOOL_DEFINITIONS = [
+    {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description: 'Read the contents of a file at the given path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file (absolute or relative to cwd)' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description: 'Write or overwrite a file with the given content. Always write complete file content.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file' },
+                    content: { type: 'string', description: 'Full file content to write' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List files and directories at the given path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path to list (default: cwd)' },
+                },
+                required: [],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'create_directory',
+            description: 'Create a directory (and all parent directories) at the given path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path to create' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file at the given path.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to the file to delete' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'execute_command',
+            description: 'Execute a shell command in the current working directory. Use for builds, tests, git, npm, etc.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Shell command to execute' },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds (default 30000)' },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'search_files',
+            description: 'Search for a text pattern in files under a directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Text or regex pattern to search for' },
+                    directory: { type: 'string', description: 'Directory to search in (default: cwd)' },
+                    extension: { type: 'string', description: 'File extension filter e.g. ".ts"' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+];
+export async function executeTool(name, args, cwd) {
+    const resolve = (p) => path.isAbsolute(p) ? p : path.resolve(cwd, p);
+    switch (name) {
+        case 'read_file': {
+            const { path: p } = args;
+            const content = await fs.readFile(resolve(p), 'utf-8');
+            const lines = content.split('\n');
+            const numbered = lines
+                .map((l, i) => `${String(i + 1).padStart(4, ' ')}  ${l}`)
+                .join('\n');
+            return `File: ${p} (${lines.length} lines)\n\n${numbered}`;
+        }
+        case 'write_file': {
+            const { path: p, content } = args;
+            const full = resolve(p);
+            await fs.mkdir(path.dirname(full), { recursive: true });
+            await fs.writeFile(full, content, 'utf-8');
+            const lines = content.split('\n').length;
+            return `Written: ${p} (${lines} lines)`;
+        }
+        case 'list_directory': {
+            const { path: p = '.' } = args;
+            const entries = await fs.readdir(resolve(p), { withFileTypes: true });
+            const lines = entries.map((e) => {
+                const type = e.isDirectory() ? '/' : e.isSymbolicLink() ? '@' : ' ';
+                return `${type} ${e.name}`;
+            });
+            return `${resolve(p)}\n${lines.join('\n')}`;
+        }
+        case 'create_directory': {
+            const { path: p } = args;
+            await fs.mkdir(resolve(p), { recursive: true });
+            return `Created: ${p}`;
+        }
+        case 'delete_file': {
+            const { path: p } = args;
+            await fs.unlink(resolve(p));
+            return `Deleted: ${p}`;
+        }
+        case 'execute_command': {
+            const { command, timeout = 30000 } = args;
+            try {
+                const { stdout, stderr } = await execAsync(command, { cwd, timeout });
+                const out = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+                return out || '(no output)';
+            }
+            catch (err) {
+                const e = err;
+                const out = [e.stdout?.trim(), e.stderr?.trim(), e.message]
+                    .filter(Boolean)
+                    .join('\n');
+                return `Exit error:\n${out}`;
+            }
+        }
+        case 'search_files': {
+            const { pattern, directory = '.', extension } = args;
+            const results = [];
+            async function walk(dir) {
+                let entries;
+                try {
+                    entries = await fs.readdir(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                        continue;
+                    const full = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        await walk(full);
+                    }
+                    else {
+                        if (extension && !entry.name.endsWith(extension))
+                            continue;
+                        try {
+                            const content = await fs.readFile(full, 'utf-8');
+                            const lines = content.split('\n');
+                            const re = new RegExp(pattern, 'i');
+                            lines.forEach((line, idx) => {
+                                if (re.test(line)) {
+                                    const rel = path.relative(cwd, full);
+                                    results.push(`${rel}:${idx + 1}: ${line.trim()}`);
+                                }
+                            });
+                        }
+                        catch {
+                            // skip binary files
+                        }
+                    }
+                }
+            }
+            await walk(resolve(directory));
+            if (results.length === 0)
+                return `No matches for "${pattern}"`;
+            return results.slice(0, 100).join('\n');
+        }
+        default:
+            return `Unknown tool: ${name}`;
+    }
+}

package/dist/main.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './App.js';
+const initialCwd = process.cwd();
+render(_jsx(App, { initialCwd: initialCwd }));

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@demirarch/recode",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "A minimal TUI code editor with AI assistant powered by OpenRouter",
+  "author": "DemirArch",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://github.com/demirgitbuh/recode",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/demirgitbuh/recode.git"
+  },
+  "bin": { "recode": "./dist/main.js" },
+  "scripts": {
+    "dev": "tsx src/main.tsx",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "ink": "^4.4.1",
+    "ink-text-input": "^5.0.1",
+    "ink-select-input": "^5.0.0",
+    "ink-spinner": "^5.0.0",
+    "react": "^18.2.0",
+    "cli-highlight": "^2.1.11",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0"
+  }
+}

package/src/App.tsx

@@ -0,0 +1,54 @@
+import React, { useState, useEffect } from 'react';
+import { Text } from 'ink';
+import { loadConfig, type RecodeConfig } from './lib/config.js';
+import { SetupScreen } from './components/SetupScreen.js';
+import { ChatScreen } from './components/ChatScreen.js';
+
+type AppState =
+  | { screen: 'loading' }
+  | { screen: 'setup' }
+  | { screen: 'chat'; config: RecodeConfig };
+
+interface AppProps {
+  initialCwd: string;
+}
+
+export function App({ initialCwd }: AppProps) {
+  const [state, setState] = useState<AppState>({ screen: 'loading' });
+  const [model, setModel] = useState('');
+
+  useEffect(() => {
+    loadConfig().then((cfg) => {
+      if (cfg) {
+        setModel(cfg.model);
+        setState({ screen: 'chat', config: cfg });
+      } else {
+        setState({ screen: 'setup' });
+      }
+    });
+  }, []);
+
+  if (state.screen === 'loading') {
+    return <Text color="#F26207">Loading...</Text>;
+  }
+
+  if (state.screen === 'setup') {
+    return (
+      <SetupScreen
+        onComplete={(cfg) => {
+          setModel(cfg.model);
+          setState({ screen: 'chat', config: cfg });
+        }}
+      />
+    );
+  }
+
+  return (
+    <ChatScreen
+      model={model || state.config.model}
+      apiKey={state.config.apiKey}
+      initialCwd={initialCwd}
+      onModelChange={setModel}
+    />
+  );
+}