clarity-ai 3.1.0 → 3.3.0

package/CHANGELOG.md

@@ -0,0 +1,71 @@
+# Change Log
+
+---
+
+## 3.1.0 (2026-06-05)
+
+### UI Rewrite — OpenCode Style
+- **User messages**: Light purple background (`#2D1B4E`), `#C39BD3` text, `❯ YOU` header bar
+- **AI responses**: Left border only (`│`), no box, no background, `◆ CLARITY` header
+- **File edits**: OpenCode diff format — `✎ filename` bar + `+`/`-` lines with line numbers
+- **File writes**: `+ filename` header with line count written
+- **Tool calls**: Inline `⚙ toolname · input` with preview output (max 8 lines)
+- **Info/Error/Success/Warning**: Clean single-line renders with icons
+
+### System Prompt — Anti-Hallucination
+- Strict rules: NEVER fabricate content, NEVER confirm before acting
+- Always ground responses in actual tool output
+- Read files before editing, never overwrite unread files
+- Short, direct responses — no filler
+
+### Agent Loop — Inline Diff Display
+- `executeToolCall()` handles write_file, edit_file, bash, read_file natively
+- edit_file computes unified diff using `diff` package (`diffLines`)
+- `filterContextHunks()` shows ±2 context lines around changes
+- Dynamic fallback for other tools via `import()` from `tools/` directory
+
+---
+
+## 3.0.2 (2026-06-05)
+
+- Complete rebuild per CLARITY_V3_PROMPT.md spec
+- Removed all Ink+React code (15 files) — replaced with readline-based TUI
+- 25 tool modules in `src/tools/`, 20 command modules in `src/commands/`
+- 6 provider modules with streaming SSE parsing
+- ReAct agent loop with JSON-only tool call parsing
+- Figlet+gradient animated banner, first-run setup wizard
+
+---
+
+## 3.0.1 (2026-06-05)
+
+- Fixed JSX → createElement conversion in all Ink components
+- Fixed import errors and TTY check
+- Fixed Termux bin wrapper (symlink → bash script)
+
+---
+
+## 3.0.0 (2026-06-05)
+
+- Complete Ink+React TUI rewrite
+- 11 React components, global state with reducer
+- Parallel subagent spawning
+- 15 tools, 17 commands
+
+---
+
+## 2.0.0 (2026-06-04)
+
+- Figlet+gradient banner, 12 block types with timestamps
+- 22-token color palette
+- ReAct agent loop with JSON parsing and 3 retry attempts
+- 20 tools, first-run wizard, split commands
+
+---
+
+## 1.3.0 (2026-06-04)
+
+- Provider model lists updated to 2026
+- Interactive `/model` selector, `/provider` command
+- Grey-fill + purple-outline prompt bar
+- Tab completer on readline

package/bin/clarity.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-// bin/clarity.js
 import { showBanner } from '../src/ui/banner.js';
 import { isFirstRun, loadConfig } from '../src/config/settings.js';
 import { runSetupWizard } from '../src/core/setup.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-ai",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "Autonomous AI Agent CLI for Termux",
   "type": "module",
   "bin": {

package/src/agents/loop.js

@@ -1,142 +1,117 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import chalk from 'chalk';
+import { Spinner } from '../ui/spinner.js';
+import { renderAI, renderWrite, renderEdit } from '../ui/blocks.js';
 import { callProvider } from '../providers/index.js';
-import { buildSystemPrompt } from '../core/context.js';
-import { addMessage } from '../core/history.js';
-import { renderEdit, renderWrite, renderTool } from '../ui/blocks.js';
+import { addMessage, saveHistory } from '../core/history.js';
 import { diffLines } from 'diff';
-import { execSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-
-export const SYSTEM_PROMPT = 'You are CLARITY, an autonomous AI agent CLI running in Termux on Android.\n\n' +
-'## CRITICAL RULES — NEVER VIOLATE\n\n' +
-'1. NEVER fabricate file contents, directory structures, or command outputs.\n' +
-'   - If you have not read a file, say "I have not read that file yet."\n' +
-'   - If a command has not run, say "I will run that now."\n' +
-'   - NEVER invent results.\n\n' +
-'2. NEVER hallucinate tool calls — only call tools you actually have.\n' +
-'   Available tools: bash, read_file, write_file, edit_file, delete_file,\n' +
-'   list_directory, search_files, grep, web_search, web_fetch, git,\n' +
-'   run_tests, memory, task_planner, code_runner, pkg_manager, env,\n' +
-'   diff, compress, screenshot, clipboard, notify, version_check,\n' +
-'   context, agent_spawn.\n\n' +
-'3. NEVER confirm an action before doing it — just do it.\n' +
-'   Bad: "I will create the workspace folder now." [then waits]\n' +
-'   Good: [calls bash tool: mkdir workspace] then "Created workspace/."\n\n' +
-'4. ALWAYS ground responses in actual tool output.\n' +
-'   If a tool returns an error, report the actual error. Do not pretend it succeeded.\n\n' +
-'5. SHORT responses. No filler. No "Certainly!" No "Great question!"\n' +
-'   Just: action -> result -> next step if needed.\n\n' +
-'6. When editing files, ALWAYS read the file first, then make targeted edits.\n' +
-'   Never overwrite a file you have not read.\n\n' +
-'7. For multi-step tasks, plan first with task_planner, then execute step by step.\n' +
-'   Show each step as you complete it.\n\n' +
-'## RESPONSE FORMAT\n\n' +
-'- Plain text for explanations. No markdown headers in chat.\n' +
-'- File edits shown as diffs automatically by the UI — do not describe edits in text.\n' +
-'- Code in responses: just write it plainly, no fences needed unless showing a standalone snippet.\n' +
-'- Errors: state the actual error and what you will try next.\n\n' +
-'## IDENTITY\n\n' +
-'You are CLARITY v3.0. You are running on ' + process.platform + '.\n' +
-'Current working directory: ' + process.cwd() + '\n' +
-'Agent mode: ON — you can and should use tools without asking permission.\n' +
-'\nAvailable tools with JSON schema:\n' +
-'- bash { command: string }\n' +
-'- read_file { path: string }\n' +
-'- write_file { path: string, content: string }\n' +
-'- edit_file { path: string, old_str: string, new_str: string }\n' +
-'- delete_file { path: string }\n' +
-'- list_directory { dir: string }\n' +
-'- search_files { pattern: string }\n' +
-'- grep { pattern: string, path: string }\n' +
-'- web_search { query: string }\n' +
-'- web_fetch { url: string }\n' +
-'- git { subcommand: string }\n' +
-'- memory { action: string, key?: string, value?: string }\n' +
-'- code_runner { language: string, code: string }\n' +
-'- pkg_manager { manager: string, action: string, packages: string }\n\n' +
-'Respond with JSON:\n' +
-'{"tool": "tool_name", "args": {"arg1": "val1"}}\n' +
-'or to respond to user:\n' +
-'{"response": "your final answer here"}';
-
-function filterContextHunks(hunks, ctx) {
-  const changedIdx = hunks
-    .map((h, i) => (h.type !== 'context' ? i : -1))
-    .filter((i) => i >= 0);
-  return hunks.filter((_, i) => {
-    if (hunks[i].type !== 'context') return true;
-    for (const c of changedIdx) {
-      if (Math.abs(i - c) <= ctx) return true;
-    }
-    return false;
-  });
+
+const SYSTEM_PROMPT = 'You are CLARITY, an autonomous AI agent CLI running in Termux on Android.\n\n' +
+'## CRITICAL RULES\n' +
+'1. NEVER fabricate file contents or command outputs.\n' +
+'2. NEVER confirm before acting \u2014 just do it.\n' +
+'3. ALWAYS ground responses in actual tool output.\n' +
+'4. SHORT responses. No filler.\n' +
+'5. When editing files, read first then edit.\n\n' +
+'## RESPONSE FORMAT\n' +
+'Respond with JSON ONLY:\n' +
+'To use a tool: {"tool": "tool_name", "args": {"key": "value"}}\n' +
+'To answer: {"response": "your message"}\n\n' +
+'Available tools: bash, read_file, write_file, edit_file, list_directory, search_files, grep, web_search, web_fetch, git, memory, code_runner, pkg_manager';
+
+function detectIntent(message) {
+  const lower = message.toLowerCase().trim();
+  const chatPatterns = [
+    /^(hi|hello|hey|sup|yo|what'?s up|howdy)/,
+    /^(how are you|how do you|what are you|who are you|what can you)/,
+    /^(thanks|thank you|ok|okay|cool|nice|great|good|sure|yes|no|yep|nope)/,
+    /^(what is|what's|explain|tell me about|describe|define)/,
+    /^(can you|could you|would you|will you)\s+(explain|tell|describe|help me understand)/,
+  ];
+  for (const p of chatPatterns) {
+    if (p.test(lower)) return 'chat';
+  }
+  const toolPatterns = [
+    { re: /(create|make|mkdir|new)\s+(a\s+)?(dir|directory|folder)/ },
+    { re: /(create|make|write|generate)\s+(a\s+)?(file|script|code|program)/ },
+    { re: /(run|execute|launch|start)\s+/ },
+    { re: /(edit|modify|change|update|fix)\s+(the\s+)?file/ },
+    { re: /(read|show|display|cat|open)\s+(the\s+)?file/ },
+    { re: /(list|ls|show)\s+(files|dir|directory|folders)/ },
+    { re: /(search|find|grep|look for)/ },
+    { re: /(install|npm|pip|pkg)\s+/ },
+    { re: /(git\s+)/ },
+    { re: /(cd\s+|navigate to|go to)/ },
+  ];
+  for (const { re } of toolPatterns) {
+    if (re.test(lower)) return 'agent';
+  }
+  return 'chat';
 }
 
-async function executeToolCall(toolName, toolInput) {
-  switch (toolName) {
+async function executeTool(name, args) {
+  switch (name) {
+    case 'bash': {
+      try {
+        const out = execSync(args.command, {
+          encoding: 'utf-8', timeout: 30000,
+          cwd: process.env.HOME || '/data/data/com.termux/files/home',
+        });
+        return out.trim() || '(no output)';
+      } catch (e) {
+        return 'ERROR: ' + (e.stderr || e.message || String(e));
+      }
+    }
+    case 'read_file': {
+      if (!existsSync(args.path)) return 'ERROR: File not found: ' + args.path;
+      return readFileSync(args.path, 'utf-8');
+    }
     case 'write_file': {
-      const { path, content } = toolInput;
-      const lines = content.split('\n').length;
-      writeFileSync(path, content, 'utf-8');
-      console.log(renderWrite(path, lines));
-      return 'Written ' + lines + ' lines to ' + path;
+      const dir = dirname(args.path);
+      if (dir !== '.') mkdirSync(dir, { recursive: true });
+      writeFileSync(args.path, args.content, 'utf-8');
+      const lines = args.content.split('\n').length;
+      return 'Written ' + lines + ' lines to ' + args.path;
     }
-
     case 'edit_file': {
-      const { path, old_str, new_str } = toolInput;
-      if (!existsSync(path)) return 'Error: File not found: ' + path;
-      const original = readFileSync(path, 'utf-8');
-      const updated = original.replace(old_str, new_str);
-
-      const changes = diffLines(original, updated);
-      const hunks = [];
-      let lineNum = 1;
-      for (const part of changes) {
-        for (const line of part.value.split('\n').slice(0, -1)) {
-          if (part.added) {
-            hunks.push({ type: 'add', line, lineNum });
-          } else if (part.removed) {
-            hunks.push({ type: 'remove', line, lineNum });
-          } else {
-            hunks.push({ type: 'context', line, lineNum });
-          }
-          lineNum++;
-        }
+      if (!existsSync(args.path)) return 'ERROR: File not found: ' + args.path;
+      const original = readFileSync(args.path, 'utf-8');
+      if (!original.includes(args.old_str)) return 'ERROR: String not found in ' + args.path;
+      const updated = original.replace(args.old_str, args.new_str);
+      writeFileSync(args.path, updated, 'utf-8');
+      return 'Edited ' + args.path;
+    }
+    case 'list_directory': {
+      try {
+        const out = execSync('ls -la "' + (args.path || '.') + '"', { encoding: 'utf-8' });
+        return out.trim();
+      } catch (e) {
+        return 'ERROR: ' + e.message;
       }
-
-      const filtered = filterContextHunks(hunks, 2);
-      writeFileSync(path, updated, 'utf-8');
-      console.log(renderEdit(path, filtered));
-      return 'Edited ' + path;
     }
-
-    case 'bash': {
-      const { command } = toolInput;
+    case 'search_files': {
       try {
-        const result = execSync(command, { encoding: 'utf-8', timeout: 30000 });
-        const out = result || '(no output)';
-        console.log(renderTool('bash', command, out));
-        return out;
-      } catch (err) {
-        const errMsg = err.stderr || err.message;
-        console.log(renderTool('bash', command, errMsg));
-        return 'Error: ' + errMsg;
+        const out = execSync('find "' + (args.path || '.') + '" -name "' + args.pattern + '" 2>/dev/null | head -20', { encoding: 'utf-8' });
+        return out.trim() || 'No files found';
+      } catch (e) {
+        return 'ERROR: ' + e.message;
       }
     }
-
-    case 'read_file': {
-      const { path } = toolInput;
-      if (!existsSync(path)) return 'Error: File not found: ' + path;
-      const content = readFileSync(path, 'utf-8');
-      console.log(renderTool('read_file', path, content.slice(0, 200)));
-      return content;
+    case 'grep': {
+      try {
+        const out = execSync('grep -rn "' + args.pattern + '" "' + args.path + '" 2>/dev/null | head -20', { encoding: 'utf-8' });
+        return out.trim() || 'No matches';
+      } catch (e) {
+        return 'No matches or error: ' + e.message;
+      }
     }
-
     default: {
       try {
-        const mod = await import('../tools/' + toolName + '.js');
+        const mod = await import('../tools/' + name + '.js');
         const toolFn = Object.values(mod)[0];
-        const result = await toolFn(toolInput);
-        console.log(renderTool(toolName, JSON.stringify(toolInput).slice(0, 60), result));
+        const result = await toolFn(args);
         return result;
       } catch (e) {
         return 'Tool error: ' + e.message;
@@ -145,61 +120,184 @@ async function executeToolCall(toolName, toolInput) {
   }
 }
 
-export async function agentLoop(userMessage, config, history) {
-  const messages = [
-    { role: 'system', content: buildSystemPrompt(SYSTEM_PROMPT) },
-    ...history.slice(-20).map((m) => ({
-      role: m.role === 'assistant' ? 'assistant' : 'user',
-      content: m.content,
-    })),
-    { role: 'user', content: userMessage },
-  ];
-
-  let finalResponse = '';
-  let toolCalls = 0;
-  const maxToolCalls = 20;
+function renderToolStep(name, args, result, elapsed) {
+  const argPreview = (() => {
+    if (args.command)  return String(args.command).slice(0, 50);
+    if (args.path)     return args.path;
+    if (args.pattern)  return args.pattern;
+    return JSON.stringify(args).slice(0, 50);
+  })();
 
-  while (toolCalls < maxToolCalls) {
-    let fullResponse = '';
-    const stream = callProvider(config, messages);
-    for await (const chunk of stream) {
-      fullResponse += chunk;
-    }
+  const header =
+    chalk.hex('#00FFFF')('\u2699 ') +
+    chalk.hex('#00FFFF').bold(name) +
+    chalk.dim(' \u00b7 ' + argPreview) +
+    chalk.dim('  (' + elapsed + 'ms)');
+  console.log(header);
 
-    const jsonMatch = fullResponse.match(/\{[^]*\}/);
-    if (!jsonMatch) {
-      finalResponse = fullResponse;
-      break;
-    }
+  if (name === 'write_file' && args.content) {
+    const lineCount = args.content.split('\n').length;
+    console.log(renderWrite(args.path, lineCount));
+    return;
+  }
 
-    let parsed;
+  if (name === 'edit_file' && existsSync(args.path)) {
     try {
-      parsed = JSON.parse(jsonMatch[0]);
-    } catch {
-      finalResponse = fullResponse;
-      break;
+      const original = readFileSync(args.path, 'utf-8');
+      const updated  = original.replace(args.old_str || '', args.new_str || '');
+      const changes  = diffLines(original, updated);
+      const hunks    = [];
+      let lineNum    = 1;
+      for (const part of changes) {
+        const partLines = part.value.split('\n');
+        if (partLines[partLines.length - 1] === '') partLines.pop();
+        for (const line of partLines) {
+          if (part.added)        hunks.push({ type: 'add',    line, lineNum });
+          else if (part.removed) hunks.push({ type: 'remove', line, lineNum });
+          else                   hunks.push({ type: 'context', line, lineNum });
+          lineNum++;
+        }
+      }
+      const changed = new Set(hunks.map((h, i) => h.type !== 'context' ? i : -1).filter(i => i >= 0));
+      const filtered = hunks.filter((_, i) => {
+        if (hunks[i].type !== 'context') return true;
+        for (const c of changed) if (Math.abs(i - c) <= 2) return true;
+        return false;
+      });
+      console.log(renderEdit(args.path, filtered));
+    } catch {}
+    return;
+  }
+
+  if (result && result !== '(no output)' && !result.startsWith('ERROR') && name !== 'read_file') {
+    const resultLines = String(result).split('\n').slice(0, 6);
+    for (const l of resultLines) {
+      console.log(chalk.dim('  \u2502 ') + chalk.hex('#AAAAAA')(l));
+    }
+    if (String(result).split('\n').length > 6) {
+      console.log(chalk.dim('  \u2502 ...'));
     }
+  }
 
-    if (parsed.response) {
-      finalResponse = parsed.response;
-      break;
+  if (result && String(result).startsWith('ERROR')) {
+    console.log(chalk.hex('#FF4757')('  \u2716 ') + chalk.hex('#FF4757')(result));
+  }
+}
+
+export async function agentLoop(userMessage, config, history) {
+  try {
+    const intent = detectIntent(userMessage);
+    const spinner = new Spinner();
+    const msgHistory = Array.isArray(history) ? history : (history.messages || []);
+
+    if (intent === 'chat') {
+      spinner.start('Thinking', 'think');
+      const t0 = Date.now();
+
+      const messages = [
+        { role: 'system', content: 'You are CLARITY-AI, a helpful assistant. Keep responses short.' },
+        ...msgHistory.slice(-10).map(m => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content })),
+        { role: 'user', content: userMessage },
+      ];
+
+      const result = await callProvider(config, messages);
+      const elapsed = Date.now() - t0;
+      spinner.stop('Thought ' + (elapsed < 1000 ? elapsed + 'ms' : (elapsed/1000).toFixed(1) + 's'), 'done');
+
+      addMessage(msgHistory, 'user', userMessage);
+      addMessage(msgHistory, 'assistant', result.content);
+      saveHistory(msgHistory);
+
+      console.log();
+      console.log(renderAI(result.content));
+      console.log();
+      return;
     }
 
-    if (parsed.tool) {
-      toolCalls++;
-      const toolName = parsed.tool;
-      const args = parsed.args || {};
+    let messages = [
+      { role: 'system', content: SYSTEM_PROMPT },
+      ...msgHistory.slice(-20).map(m => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content })),
+      { role: 'user', content: userMessage },
+    ];
+
+    let loopCount = 0;
+    const MAX_LOOPS = 15;
 
-      const result = await executeToolCall(toolName, args);
+    while (loopCount < MAX_LOOPS) {
+      loopCount++;
 
-      messages.push({ role: 'assistant', content: fullResponse });
-      messages.push({ role: 'user', content: 'Tool result: ' + result });
+      spinner.start('Thinking', 'think');
+      const t0 = Date.now();
+
+      const result = await callProvider(config, messages);
+      const fullResponse = result.content;
+
+      const thinkMs = Date.now() - t0;
+      spinner.stop('Thought ' + (thinkMs < 1000 ? thinkMs + 'ms' : (thinkMs/1000).toFixed(1) + 's'), 'done');
+
+      const jsonMatch = fullResponse.match(/\{[^]*\}/);
+      if (!jsonMatch) {
+        console.log();
+        console.log(renderAI(fullResponse));
+        console.log();
+        addMessage(msgHistory, 'user', userMessage);
+        addMessage(msgHistory, 'assistant', fullResponse);
+        saveHistory(msgHistory);
+        return;
+      }
+
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonMatch[0]);
+      } catch {
+        console.log();
+        console.log(renderAI(fullResponse));
+        console.log();
+        addMessage(msgHistory, 'user', userMessage);
+        addMessage(msgHistory, 'assistant', fullResponse);
+        saveHistory(msgHistory);
+        return;
+      }
+
+      if (parsed.response) {
+        const finalText = parsed.response;
+        console.log();
+        console.log(renderAI(finalText));
+        console.log();
+        addMessage(msgHistory, 'user', userMessage);
+        addMessage(msgHistory, 'assistant', finalText);
+        saveHistory(msgHistory);
+        return;
+      }
+
+      if (parsed.tool) {
+        const name = parsed.tool;
+        const args = parsed.args || {};
+        const argPreview = args.command || args.path || args.pattern || '';
+
+        spinner.start('Running ' + name, 'tool');
+        spinner.update('Running ' + name, argPreview.slice(0, 40));
+
+        const ts = Date.now();
+        const toolResult = await executeTool(name, args);
+        const te = Date.now() - ts;
+
+        spinner.stop(name + ' \u00b7 ' + argPreview.slice(0, 30), 'done');
+        renderToolStep(name, args, toolResult, te);
+
+        messages.push({ role: 'assistant', content: fullResponse });
+        messages.push({ role: 'user', content: 'Tool result: ' + toolResult });
+      }
     }
-  }
 
-  if (toolCalls >= maxToolCalls) {
-    finalResponse += '\n\n(Max tool calls reached)';
+    console.log(chalk.hex('#FFB800')('\u26a0 Max tool calls reached. Stopping.'));
+  } catch (err) {
+    console.log();
+    console.log(chalk.hex('#FF4757')('\u2716 Error: ') + chalk.white(err.message.split('\n')[0]));
+    const extra = err.message.split('\n').slice(1);
+    for (const line of extra) {
+      console.log(chalk.dim('  ' + line));
+    }
+    console.log();
   }
-
-  return finalResponse || 'No response generated';
 }