clarity-ai 2.0.1 → 3.0.1

package/AGENTS.md

@@ -45,3 +45,7 @@ SSE parsing pattern: read `data: ` lines, parse JSON, yield `choices[0].delta.co
 - **No test framework**: none configured. No lint/typecheck scripts.
 - **Keypress events**: `process.stdin.on('keypress', ...)` works because `readline.createInterface({ terminal: true })` internally calls `emitKeypressEvents`. Set raw mode BEFORE creating readline if needed.
 - **Prompt bar**: `renderPromptBar()` draws grey-filled purple box. Call after every output cycle so the bar stays at bottom. `showPrompt()` writes ` ◆ `. Always pair: render bar, then show prompt.
+- **No build step (v3)**: All Ink+React components use `React.createElement()` directly — NO JSX. Node.js cannot parse JSX without a transpiler.
+- **TTY check**: `src/index.js` checks `process.stdin.isTTY` before rendering Ink — prevents `Raw mode not supported` error in non-TTY environments.
+- **Global state**: `src/store.js` uses `useReducer` with a reducer function — dispatches `THOUGHT_START`, `TOOL_CALL`, `ADD_MESSAGE`, `SET_TODOS`, etc.
+- **Parallel subagents**: `src/agent/subagent.js` — `shouldParallelize()` detects multi-step tasks, `planSubagents()` calls model for JSON array, `runSubagents()` runs `Promise.all` with AGENT_REGISTER/TOOLCALL dispatches.

package/bin/clarity.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../src/main.js';
+import '../src/index.js';

package/package.json

@@ -1,39 +1,25 @@
 {
   "name": "clarity-ai",
-  "version": "2.0.1",
-  "description": "Autonomous AI Agent CLI for Termux",
+  "version": "3.0.1",
+  "description": "Autonomous AI Agent Terminal — OpenCode-style TUI for Termux",
   "type": "module",
-  "bin": {
-    "clarity": "bin/clarity.js"
-  },
+  "bin": { "clarity": "./bin/clarity.js" },
   "scripts": {
     "start": "node bin/clarity.js",
     "dev": "node --watch bin/clarity.js"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
   "dependencies": {
+    "ink": "^4.4.1",
+    "react": "^18.2.0",
     "chalk": "^5.3.0",
-    "figlet": "^1.7.0",
-    "gradient-string": "^2.0.2",
-    "ora": "^8.1.0",
-    "inquirer": "^9.2.12",
-    "conf": "^12.0.0",
-    "marked": "^12.0.0",
-    "marked-terminal": "^7.1.0",
-    "cli-table3": "^0.6.5",
-    "wrap-ansi": "^9.0.1",
-    "semver": "^7.6.0",
-    "glob": "^10.3.12"
+    "figures": "^6.1.0",
+    "ora": "^8.0.1",
+    "dotenv": "^16.4.5",
+    "node-fetch": "^3.3.2",
+    "strip-ansi": "^7.1.0",
+    "wrap-ansi": "^9.0.0",
+    "cli-truncate": "^4.0.0",
+    "ink-text-input": "^5.0.1"
   },
-  "keywords": [
-    "ai",
-    "cli",
-    "termux",
-    "agent",
-    "autonomous",
-    "clarity"
-  ],
-  "license": "MIT"
+  "engines": { "node": ">=18.0.0" }
 }

package/src/agent/intent.js

@@ -1,15 +1,9 @@
-const HIGH_WEIGHT = ['create','build','write','make','generate','fix','debug','patch','run','execute','install','setup','search and','find and','look up and'];
-
-const LOW_WEIGHT = ['can you','please','help me'];
-
 export function detectIntent(message) {
   const msg = message.toLowerCase();
+  const HIGH = ['create','build','write','make','generate','fix','debug','patch','run','execute','install','setup','search and','find and','look up and'];
+  const LOW = ['can you','please','help me'];
   let score = 0;
-  for (const w of HIGH_WEIGHT) {
-    if (msg.includes(w)) { score += 2; break; }
-  }
-  for (const w of LOW_WEIGHT) {
-    if (msg.includes(w)) { score += 1; }
-  }
+  for (const w of HIGH) { if (msg.includes(w)) { score += 2; break; } }
+  for (const w of LOW) { if (msg.includes(w)) score += 1; }
   return score >= 2 ? 'agent' : 'chat';
 }

package/src/agent/runner.js

@@ -0,0 +1,143 @@
+export async function callProvider({ provider, model, apiKey, system, messages, temperature }) {
+  const urls = {
+    groq: 'https://api.groq.com/openai/v1/chat/completions',
+    openrouter: 'https://openrouter.ai/api/v1/chat/completions',
+    openai: 'https://api.openai.com/v1/chat/completions',
+  };
+  const url = urls[provider];
+  if (!url) throw new Error(`Unknown provider: ${provider}`);
+
+  const body = { model, messages: [{ role: 'system', content: system }, ...messages], temperature: temperature || 0.3, stream: false };
+  const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
+
+  const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+  if (!res.ok) throw new Error(`API ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+import { TOOLS, executeTool } from './tools.js';
+
+const AGENT_SYSTEM = `You are CLARITY, an autonomous terminal AI agent.
+Respond ONLY with JSON. Never plain text. Never markdown.
+
+For each step:
+{
+  "thought": "what I'm doing and why (1-2 sentences)",
+  "todos": ["task 1", "task 2", ...],  // only on first step
+  "tool": "tool_name",
+  "args": {},
+  "done": false
+}
+
+When complete:
+{ "thought": "...", "tool": null, "args": {}, "done": true, "summary": "..." }
+
+Tools: file_read, file_write, file_append, file_delete, file_list, file_exists,
+       shell_run, code_run, npm_install, pkg_install,
+       web_search, web_fetch, sys_info, git_status, git_commit
+
+Rules:
+- Write files with file_write, not shell echo
+- Run code with code_run, not shell_run  
+- If a tool errors, try a different approach
+- Max 30 steps
+- Stay focused on the original task`;
+
+export async function runAgent(userMessage, config, dispatch) {
+  const history = [];
+  let step = 0;
+  const MAX = 30;
+
+  // Show thought starting
+  dispatch({ type: 'THOUGHT_START' });
+
+  while (step < MAX) {
+    step++;
+    const thinkStart = Date.now();
+
+    // Call model
+    const raw = await callProvider({
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      system: AGENT_SYSTEM,
+      messages: [
+        ...history,
+        { role: 'user', content: step === 1 ? userMessage : 'Next step.' }
+      ],
+      temperature: 0.3,
+    });
+
+    const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
+
+    // Parse JSON
+    let action;
+    try {
+      const cleaned = raw.replace(/```json|```/g, '').trim();
+      action = JSON.parse(cleaned);
+    } catch {
+      // Retry with explicit reminder
+      history.push({ role: 'assistant', content: raw });
+      history.push({ role: 'user', content: 'ERROR: respond only with valid JSON, no other text.' });
+      continue;
+    }
+
+    // Emit thought
+    dispatch({ type: 'THOUGHT_DONE', payload: { text: action.thought, elapsed } });
+
+    // Emit todos on first step
+    if (action.todos?.length) {
+      dispatch({ type: 'SET_TODOS', payload: action.todos.map((t, i) => ({
+        id: i, text: t, status: 'pending'
+      }))});
+    }
+
+    // Done?
+    if (action.done) {
+      dispatch({ type: 'AGENT_DONE', payload: action.summary });
+      return;
+    }
+
+    // Execute tool
+    if (action.tool) {
+      dispatch({ type: 'TOOL_START', payload: { name: action.tool, args: action.args } });
+      dispatch({ type: 'TODO_SET_RUNNING', payload: step - 1 });
+      
+      const toolStart = Date.now();
+      let result, status;
+      
+      try {
+        result = await executeTool(action.tool, action.args);
+        status = 'done';
+        dispatch({ type: 'TODO_SET_DONE', payload: step - 1 });
+      } catch (err) {
+        result = err.message;
+        status = 'error';
+        dispatch({ type: 'TODO_SET_FAIL', payload: step - 1 });
+      }
+
+      const toolMs = Date.now() - toolStart;
+      dispatch({ type: 'TOOL_DONE', payload: { result, status, elapsed: toolMs } });
+
+      // Feed back to model
+      history.push({ role: 'assistant', content: JSON.stringify(action) });
+      history.push({ role: 'user', content: `Tool ${action.tool} result (${toolMs}ms):\n${String(result).slice(0, 3000)}` });
+
+      // Emit agent step message
+      dispatch({ type: 'ADD_MESSAGE', payload: {
+        type: 'tool',
+        tool: action.tool,
+        args: action.args,
+        result,
+        status,
+        elapsed: toolMs,
+      }});
+
+      // Think again
+      dispatch({ type: 'THOUGHT_START' });
+    }
+  }
+
+  dispatch({ type: 'AGENT_DONE', payload: `Completed ${step} steps.` });
+}

package/src/agent/subagent.js

@@ -0,0 +1,55 @@
+import { runAgent } from './runner.js';
+
+// Detect if task warrants parallel agents
+export function shouldParallelize(task) {
+  const BIG_TASK = [
+    /rewrite (the )?(whole|entire|all|full)/i,
+    /create (a )?full/i,
+    /build (a )?(complete|entire)/i,
+    /rebuild/i,
+  ];
+  return BIG_TASK.some(p => p.test(task));
+}
+
+// Split a large task into parallel sub-tasks
+export async function planSubagents(task, callModel) {
+  const plan = await callModel({
+    system: `Split this task into 3-5 parallel independent subtasks.
+Respond ONLY with JSON array: [{"name": "short name", "task": "full task description"}, ...]
+Each subtask must be fully independent — no subtask depends on another's output.`,
+    messages: [{ role: 'user', content: task }]
+  });
+  
+  try {
+    return JSON.parse(plan.replace(/```json|```/g, '').trim());
+  } catch {
+    return null; // fall back to single agent
+  }
+}
+
+// Run multiple agents in parallel
+export async function runSubagents(subtasks, config, dispatch) {
+  // Register all agents
+  const agentIds = subtasks.map((t, i) => {
+    const id = `agent_${i}`;
+    dispatch({ type: 'AGENT_REGISTER', payload: {
+      id, name: `General Task — ${t.name}`,
+      status: 'running', toolcalls: 0, startTime: Date.now()
+    }});
+    return id;
+  });
+
+  // Run all in parallel via Promise.all
+  await Promise.all(subtasks.map((subtask, i) => 
+    runAgent(subtask.task, config, (action) => {
+      // Intercept tool dispatches to update agent's toolcall count
+      if (action.type === 'TOOL_START') {
+        dispatch({ type: 'AGENT_TOOLCALL', payload: { id: agentIds[i] } });
+        dispatch({ type: 'AGENT_SET_TASK', payload: { id: agentIds[i], task: action.payload.name } });
+      }
+      dispatch(action);
+    })
+    .then(() => dispatch({ type: 'AGENT_DONE_ID', payload: agentIds[i] }))
+    .catch(e => dispatch({ type: 'AGENT_FAIL_ID', payload: { id: agentIds[i], error: e.message } }))
+  ));
+}

package/src/agent/tools.js

@@ -1,254 +1,132 @@
+import fs from 'fs/promises';
 import { execSync } from 'child_process';
-import { readFileSync, writeFileSync, appendFileSync, unlinkSync, readdirSync, existsSync } from 'fs';
-import { cpus, totalmem } from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 
-const tools = [];
+const run = promisify(exec);
 
-tools.push({
-  name: 'file_read',
-  description: 'Read file contents',
-  args: [{ name: 'path', type: 'string', required: true, description: 'File path to read' }],
-  execute({ path }) {
-    return readFileSync(path, 'utf-8');
-  }
-});
-
-tools.push({
-  name: 'file_write',
-  description: 'Write or create a file',
-  args: [
-    { name: 'path', type: 'string', required: true, description: 'File path' },
-    { name: 'content', type: 'string', required: true, description: 'Content to write' }
-  ],
-  execute({ path, content }) {
-    writeFileSync(path, content, 'utf-8');
-    return `Written ${path}`;
-  }
-});
-
-tools.push({
-  name: 'file_append',
-  description: 'Append content to a file',
-  args: [
-    { name: 'path', type: 'string', required: true, description: 'File path' },
-    { name: 'content', type: 'string', required: true, description: 'Content to append' }
-  ],
-  execute({ path, content }) {
-    appendFileSync(path, content + '\n', 'utf-8');
-    return `Appended to ${path}`;
-  }
-});
-
-tools.push({
-  name: 'file_delete',
-  description: 'Delete a file',
-  args: [{ name: 'path', type: 'string', required: true, description: 'File path' }],
-  execute({ path }) {
-    unlinkSync(path);
-    return `Deleted ${path}`;
-  }
-});
-
-tools.push({
-  name: 'file_list',
-  description: 'List directory contents',
-  args: [{ name: 'dir', type: 'string', required: false, description: 'Directory path (default: current)' }],
-  execute({ dir }) {
-    return readdirSync(dir || '.').join('\n');
-  }
-});
-
-tools.push({
-  name: 'file_exists',
-  description: 'Check if a file exists',
-  args: [{ name: 'path', type: 'string', required: true, description: 'File path' }],
-  execute({ path }) {
-    return String(existsSync(path));
-  }
-});
-
-tools.push({
-  name: 'shell_run',
-  description: 'Run a bash command and capture stdout+stderr',
-  args: [{ name: 'command', type: 'string', required: true, description: 'Bash command to run' }],
-  execute({ command }) {
-    return execSync(command, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }) || '(no output)';
-  }
-});
-
-tools.push({
-  name: 'shell_run_silent',
-  description: 'Run a bash command with no output captured',
-  args: [{ name: 'command', type: 'string', required: true, description: 'Bash command to run' }],
-  execute({ command }) {
-    execSync(command, { encoding: 'utf-8', stdio: 'ignore' });
-    return 'done';
-  }
-});
-
-tools.push({
-  name: 'npm_install',
-  description: 'Install npm packages',
-  args: [{ name: 'packages', type: 'array', required: true, description: 'Package names to install' }],
-  execute({ packages }) {
-    const pkgs = Array.isArray(packages) ? packages.join(' ') : packages;
-    return execSync(`npm install ${pkgs}`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }) || 'done';
-  }
-});
-
-tools.push({
-  name: 'pkg_install',
-  description: 'Install Termux packages via pkg',
-  args: [{ name: 'packages', type: 'array', required: true, description: 'Package names to install' }],
-  execute({ packages }) {
-    const pkgs = Array.isArray(packages) ? packages.join(' ') : packages;
-    return execSync(`pkg install -y ${pkgs}`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }) || 'done';
-  }
-});
-
-tools.push({
-  name: 'web_search',
-  description: 'Search DuckDuckGo for instant answers',
-  args: [{ name: 'query', type: 'string', required: true, description: 'Search query' }],
-  async execute({ query }) {
-    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1`;
-    const res = await fetch(url);
-    const data = await res.json();
-    return data.AbstractText || (data.RelatedTopics || []).slice(0, 5).map(t => t.Text || t).join('\n') || 'No results found';
-  }
-});
-
-tools.push({
-  name: 'web_fetch',
-  description: 'Fetch a URL and return text content',
-  args: [{ name: 'url', type: 'string', required: true, description: 'URL to fetch' }],
-  async execute({ url }) {
-    const res = await fetch(url);
-    const html = await res.text();
-    return html.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim().slice(0, 10000);
-  }
-});
-
-tools.push({
-  name: 'code_run',
-  description: 'Write code to temp file and execute it',
-  args: [
-    { name: 'language', type: 'string', required: true, description: 'Programming language (js, py, sh, rb, go, rs)' },
-    { name: 'code', type: 'string', required: true, description: 'Source code to run' }
-  ],
-  execute({ language, code }) {
-    const extMap = { js: '.js', py: '.py', sh: '.sh', rb: '.rb', go: '.go', rs: '.rs' };
-    const ext = extMap[language] || '.tmp';
-    const tmp = `/tmp/clarity-code-${Date.now()}${ext}`;
-    writeFileSync(tmp, code, 'utf-8');
-    const runner = {
-      js: `node ${tmp}`, py: `python3 ${tmp}`, sh: `bash ${tmp}`,
-      rb: `ruby ${tmp}`, go: `go run ${tmp}`,
-      rs: `rustc ${tmp} -o /tmp/clarity-bin && /tmp/clarity-bin`
-    };
-    return execSync(runner[language] || `bash ${tmp}`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-  }
-});
-
-tools.push({
-  name: 'git_status',
-  description: 'Show current git repository status',
-  args: [],
-  execute() {
-    return execSync('git status', { encoding: 'utf-8' });
-  }
-});
-
-tools.push({
-  name: 'git_commit',
-  description: 'Stage all changes and commit',
-  args: [{ name: 'message', type: 'string', required: true, description: 'Commit message' }],
-  execute({ message }) {
-    execSync('git add -A', { encoding: 'utf-8' });
-    const safeMsg = message.replace(/'/g, "'\\''");
-    return execSync(`git commit -m '${safeMsg}'`, { encoding: 'utf-8' });
-  }
-});
-
-tools.push({
-  name: 'sys_info',
-  description: 'Get CPU, memory, Node version, platform info',
-  args: [],
-  execute() {
-    const info = {
-      platform: process.platform,
-      node: process.version,
-      cpu: cpus().length + ' cores',
-      memory: Math.round(totalmem() / 1024 / 1024 / 1024) + ' GB',
-      arch: process.arch,
-      cwd: process.cwd()
-    };
-    return Object.entries(info).map(([k, v]) => `${k}: ${v}`).join('\n');
-  }
-});
-
-tools.push({
-  name: 'env_get',
-  description: 'Get an environment variable',
-  args: [{ name: 'key', type: 'string', required: true, description: 'Variable name' }],
-  execute({ key }) {
-    return process.env[key] || '(not set)';
-  }
-});
-
-tools.push({
-  name: 'env_set',
-  description: 'Set an environment variable in .env file',
-  args: [
-    { name: 'key', type: 'string', required: true, description: 'Variable name' },
-    { name: 'value', type: 'string', required: true, description: 'Variable value' }
-  ],
-  execute({ key, value }) {
-    appendFileSync('.env', `${key}=${value}\n`, 'utf-8');
-    return `Set ${key}=${value}`;
-  }
-});
-
-tools.push({
-  name: 'ai_ask',
-  description: 'Ask another AI model a question',
-  args: [
-    { name: 'prompt', type: 'string', required: true, description: 'Prompt to send' },
-    { name: 'model', type: 'string', required: false, description: 'Model name (e.g. groq/llama-3.3-70b-versatile)' }
-  ],
-  async execute({ prompt, model }) {
-    const { sendMessage } = await import('../providers/index.js');
-    const m = model || 'groq/llama-3.3-70b-versatile';
-    const messages = [{ role: 'user', content: prompt }];
-    const gen = sendMessage(process.env.SECRET_API_KEY || '', messages, m, false);
-    let result = '';
-    for await (const chunk of gen) {
-      result += chunk;
-    }
-    return result;
-  }
-});
-
-tools.push({
-  name: 'summarize',
-  description: 'Summarize a long text using AI',
-  args: [{ name: 'text', type: 'string', required: true, description: 'Text to summarize' }],
-  async execute({ text }) {
-    const { sendMessage } = await import('../providers/index.js');
-    const messages = [{ role: 'user', content: `Summarize this text concisely:\n\n${text}` }];
-    const gen = sendMessage(process.env.SECRET_API_KEY || '', messages, 'groq/llama-3.3-70b-versatile', false);
-    let result = '';
-    for await (const chunk of gen) {
-      result += chunk;
-    }
-    return result;
+// ── File Tools ─────────────────────────────────────────────────
+export async function file_read({ path }) {
+  return (await fs.readFile(path, 'utf8')).slice(0, 8000);
+}
+
+export async function file_write({ path, content }) {
+  const dir = path.includes('/') ? path.split('/').slice(0,-1).join('/') : null;
+  if (dir) await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path, content, 'utf8');
+  return `Written ${path} (${content.length} bytes)`;
+}
+
+export async function file_append({ path, content }) {
+  await fs.appendFile(path, content, 'utf8');
+  return `Appended to ${path}`;
+}
+
+export async function file_delete({ path }) {
+  await fs.unlink(path);
+  return `Deleted ${path}`;
+}
+
+export async function file_list({ dir = '.' }) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  return entries.map(e => `${e.isDirectory() ? '📁' : '📄'} ${e.name}`).join('\n');
+}
+
+export async function file_exists({ path }) {
+  try { await fs.access(path); return 'exists'; } 
+  catch { return 'not found'; }
+}
+
+// ── Shell Tools ─────────────────────────────────────────────────
+export async function shell_run({ command, cwd, timeout = 30000 }) {
+  try {
+    const { stdout, stderr } = await run(command, { 
+      cwd: cwd || process.cwd(), 
+      timeout,
+      maxBuffer: 2 * 1024 * 1024
+    });
+    return ((stdout || '') + (stderr || '')).trim().slice(0, 5000);
+  } catch (e) {
+    return `EXIT ${e.code || 1}: ${e.message}`.slice(0, 2000);
   }
-});
+}
+
+export async function code_run({ language, code }) {
+  const exts = { python: 'py', javascript: 'js', node: 'js', bash: 'sh', python3: 'py' };
+  const cmds = { python: 'python3', javascript: 'node', node: 'node', bash: 'bash', python3: 'python3' };
+  const ext = exts[language] || 'sh';
+  const cmd = cmds[language] || 'bash';
+  const tmp = `/tmp/clarity_${Date.now()}.${ext}`;
+  await fs.writeFile(tmp, code);
+  const result = await shell_run({ command: `${cmd} ${tmp}`, timeout: 15000 });
+  try { await fs.unlink(tmp); } catch {}
+  return result;
+}
+
+export async function npm_install({ packages, cwd, flags = '' }) {
+  const pkgStr = Array.isArray(packages) ? packages.join(' ') : packages;
+  // Termux-safe: always use --no-bin-links
+  return await shell_run({ 
+    command: `npm install --no-bin-links ${flags} ${pkgStr}`,
+    cwd: cwd || process.cwd()
+  });
+}
 
-export { tools };
+export async function pkg_install({ packages }) {
+  const pkgStr = Array.isArray(packages) ? packages.join(' ') : packages;
+  return await shell_run({ command: `pkg install -y ${pkgStr}` });
+}
+
+// ── Web Tools ─────────────────────────────────────────────────
+export async function web_search({ query }) {
+  const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+  const r = await fetch(url, { headers: { 'User-Agent': 'clarity-ai/3.0' } });
+  const d = await r.json();
+  const results = [
+    d.AbstractText && `Summary: ${d.AbstractText}`,
+    ...(d.RelatedTopics||[]).slice(0,6).map(t => t.Text).filter(Boolean),
+  ].filter(Boolean).join('\n\n');
+  return results || `No results for: ${query}`;
+}
+
+export async function web_fetch({ url, selector }) {
+  const r = await fetch(url, { headers: { 'User-Agent': 'clarity-ai/3.0' } });
+  const html = await r.text();
+  // Strip tags + collapse whitespace
+  const text = html
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 6000);
+  return text;
+}
+
+// ── System Tools ─────────────────────────────────────────────
+export async function sys_info() {
+  return await shell_run({ command: 'uname -a && node -v && free -h 2>/dev/null | head -3 || true' });
+}
+
+export async function git_status() {
+  return await shell_run({ command: 'git status --short && git log --oneline -5' });
+}
+
+export async function git_commit({ message, add = '.' }) {
+  const r1 = await shell_run({ command: `git add ${add}` });
+  const r2 = await shell_run({ command: `git commit -m "${message.replace(/"/g, '\\"')}"` });
+  return r1 + '\n' + r2;
+}
 
-export async function executeTool(name, argsObj) {
-  const tool = tools.find(t => t.name === name);
-  if (!tool) throw new Error(`Unknown tool: ${name}`);
-  return await tool.execute(argsObj);
+// ── Registry ─────────────────────────────────────────────────
+export const TOOLS = {
+  file_read, file_write, file_append, file_delete, file_list, file_exists,
+  shell_run, code_run, npm_install, pkg_install,
+  web_search, web_fetch,
+  sys_info, git_status, git_commit,
+};
+
+export async function executeTool(name, args) {
+  if (!TOOLS[name]) throw new Error(`Unknown tool: ${name}. Available: ${Object.keys(TOOLS).join(', ')}`);
+  return await TOOLS[name](args);
 }