@demirarch/recode 0.1.0

package/src/lib/models.ts

@@ -0,0 +1,64 @@
+export interface Model {
+  id: string;
+  label: string;
+  provider: string;
+}
+
+export const MODELS: Model[] = [
+  // 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: string): string {
+  return MODELS.find((m) => m.id === id)?.label ?? id.split('/')[1] ?? id;
+}

package/src/lib/openrouter.ts

@@ -0,0 +1,131 @@
+import { TOOL_DEFINITIONS } from './tools.js';
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string | null;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+export interface OpenRouterResponse {
+  content: string | null;
+  tool_calls: ToolCall[] | null;
+}
+
+// ── 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: Message[],
+  model: string,
+  apiKey: string
+): Promise<OpenRouterResponse> {
+  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()) as {
+    choices?: {
+      message?: {
+        content?: string | null;
+        tool_calls?: ToolCall[];
+      };
+    }[];
+    error?: { message: string };
+  };
+
+  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/src/lib/tools.ts

@@ -0,0 +1,235 @@
+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' as const,
+    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' as const,
+    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' as const,
+    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' as const,
+    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' as const,
+    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' as const,
+    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' as const,
+    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'],
+      },
+    },
+  },
+];
+
+// ── Tool execution ────────────────────────────────────────────
+
+export interface ToolArgs {
+  read_file:        { path: string };
+  write_file:       { path: string; content: string };
+  list_directory:   { path?: string };
+  create_directory: { path: string };
+  delete_file:      { path: string };
+  execute_command:  { command: string; timeout?: number };
+  search_files:     { pattern: string; directory?: string; extension?: string };
+}
+
+export async function executeTool(
+  name: string,
+  args: Record<string, unknown>,
+  cwd: string
+): Promise<string> {
+  const resolve = (p: string) =>
+    path.isAbsolute(p) ? p : path.resolve(cwd, p);
+
+  switch (name) {
+    case 'read_file': {
+      const { path: p } = args as ToolArgs['read_file'];
+      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 as ToolArgs['write_file'];
+      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 as ToolArgs['list_directory'];
+      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 as ToolArgs['create_directory'];
+      await fs.mkdir(resolve(p), { recursive: true });
+      return `Created: ${p}`;
+    }
+
+    case 'delete_file': {
+      const { path: p } = args as ToolArgs['delete_file'];
+      await fs.unlink(resolve(p));
+      return `Deleted: ${p}`;
+    }
+
+    case 'execute_command': {
+      const { command, timeout = 30000 } = args as ToolArgs['execute_command'];
+      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: unknown) {
+        const e = err as { stdout?: string; stderr?: string; message?: string };
+        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 as ToolArgs['search_files'];
+      const results: string[] = [];
+
+      async function walk(dir: string) {
+        let entries: import('fs').Dirent[];
+        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/src/main.tsx

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import { App } from './App.js';
+
+const initialCwd = process.cwd();
+
+render(<App initialCwd={initialCwd} />);

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "jsx": "react-jsx",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  }
+}