clarity-ai 3.1.0 → 3.2.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/package.json

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

package/src/agents/loop.js

@@ -1,142 +1,117 @@
-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 { diffLines } from 'diff';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 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;
-  });
+import { dirname } from 'path';
+import chalk from 'chalk';
+import { Spinner, CollapsibleStep } from '../ui/spinner.js';
+import { renderAI, renderWrite, renderEdit, renderTool } from '../ui/blocks.js';
+import { callProvider, streamProvider } from '../providers/index.js';
+import { addMessage, saveHistory } from '../core/history.js';
+import { diffLines } from 'diff';
+
+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 — 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)/, intent: 'bash' },
+    { re: /(create|make|write|generate)\s+(a\s+)?(file|script|code|program)/, intent: 'write_file' },
+    { re: /(run|execute|launch|start)\s+/, intent: 'bash' },
+    { re: /(edit|modify|change|update|fix)\s+(the\s+)?file/, intent: 'edit_file' },
+    { re: /(read|show|display|cat|open)\s+(the\s+)?file/, intent: 'read_file' },
+    { re: /(list|ls|show)\s+(files|dir|directory|folders)/, intent: 'list_directory' },
+    { re: /(search|find|grep|look for)/, intent: 'search' },
+    { re: /(install|npm|pip|pkg)\s+/, intent: 'bash' },
+    { re: /(git\s+)/, intent: 'git' },
+    { re: /(cd\s+|navigate to|go to)/, intent: 'bash' },
+  ];
+  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,177 @@ async function executeToolCall(toolName, toolInput) {
   }
 }
 
+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);
+  })();
+
+  const header =
+    chalk.hex('#00FFFF')('\u2699 ') +
+    chalk.hex('#00FFFF').bold(name) +
+    chalk.dim(' \u00b7 ' + argPreview) +
+    chalk.dim('  (' + elapsed + 'ms)');
+  console.log(header);
+
+  if (name === 'write_file' && args.content) {
+    const lineCount = args.content.split('\n').length;
+    console.log(renderWrite(args.path, lineCount));
+    return;
+  }
+
+  if (name === 'edit_file' && existsSync(args.path)) {
+    try {
+      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 (result && String(result).startsWith('ERROR')) {
+    console.log(chalk.hex('#FF4757')('  \u2716 ') + chalk.hex('#FF4757')(result));
+  }
+}
+
 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,
-    })),
+  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 response = 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', response);
+    saveHistory(msgHistory);
+
+    console.log();
+    console.log(renderAI(response));
+    console.log();
+    return;
+  }
+
+  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 finalResponse = '';
-  let toolCalls = 0;
-  const maxToolCalls = 20;
+  let loopCount = 0;
+  const MAX_LOOPS = 15;
+
+  while (loopCount < MAX_LOOPS) {
+    loopCount++;
+
+    spinner.start('Thinking', 'think');
+    const t0 = Date.now();
 
-  while (toolCalls < maxToolCalls) {
     let fullResponse = '';
-    const stream = callProvider(config, messages);
+    const stream = streamProvider(config, messages);
     for await (const chunk of stream) {
       fullResponse += chunk;
     }
 
+    const thinkMs = Date.now() - t0;
+    spinner.stop('Thought ' + (thinkMs < 1000 ? thinkMs + 'ms' : (thinkMs/1000).toFixed(1) + 's'), 'done');
+
     const jsonMatch = fullResponse.match(/\{[^]*\}/);
     if (!jsonMatch) {
-      finalResponse = fullResponse;
-      break;
+      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 {
-      finalResponse = fullResponse;
-      break;
+      console.log();
+      console.log(renderAI(fullResponse));
+      console.log();
+      addMessage(msgHistory, 'user', userMessage);
+      addMessage(msgHistory, 'assistant', fullResponse);
+      saveHistory(msgHistory);
+      return;
     }
 
     if (parsed.response) {
-      finalResponse = parsed.response;
-      break;
+      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) {
-      toolCalls++;
-      const toolName = parsed.tool;
+      const name = parsed.tool;
       const args = parsed.args || {};
+      const argPreview = args.command || args.path || args.pattern || '';
 
-      const result = await executeToolCall(toolName, args);
+      spinner.start('Running ' + name, 'tool');
+      spinner.update('Running ' + name, argPreview.slice(0, 40));
+
+      const ts = Date.now();
+      const result = await executeTool(name, args);
+      const te = Date.now() - ts;
+
+      spinner.stop(name + ' \u00b7 ' + argPreview.slice(0, 30), 'done');
+      renderToolStep(name, args, result, te);
 
       messages.push({ role: 'assistant', content: fullResponse });
       messages.push({ role: 'user', content: 'Tool result: ' + result });
     }
   }
 
-  if (toolCalls >= maxToolCalls) {
-    finalResponse += '\n\n(Max tool calls reached)';
-  }
-
-  return finalResponse || 'No response generated';
+  console.log(chalk.hex('#FFB800')('\u26a0 Max tool calls reached. Stopping.'));
 }

package/src/commands/index.js

@@ -1,61 +1,125 @@
-import { helpCommand } from './help.js';
-import { chatCommand } from './chat.js';
-import { agentCommand } from './agent.js';
-import { toolsCommand } from './tools.js';
-import { memoryCommand } from './memory.js';
-import { historyCommand } from './history.js';
-import { modelCommand } from './model.js';
-import { providerCommand } from './provider.js';
-import { configCommand } from './config.js';
-import { clearCommand } from './clear.js';
-import { runCommand } from './run.js';
-import { taskCommand } from './task.js';
-import { searchCommand } from './search.js';
-import { fetchCommand } from './fetch.js';
-import { gitCommand } from './git.js';
-import { diffCommand } from './diff.js';
-import { undoCommand } from './undo.js';
-import { exportCommand } from './export.js';
-import { keysCommand } from './keys.js';
-import { exitCommand } from './exit.js';
+export const ALL_COMMANDS = [
+  { name: '/help',     description: 'Show all commands' },
+  { name: '/agent',    description: 'Toggle agent mode on/off' },
+  { name: '/model',    description: 'Switch AI model' },
+  { name: '/provider', description: 'Switch AI provider' },
+  { name: '/tools',    description: 'List all tools + permissions' },
+  { name: '/memory',   description: 'View or clear memory' },
+  { name: '/history',  description: 'View conversation history' },
+  { name: '/chat',     description: 'Start new chat session' },
+  { name: '/clear',    description: 'Clear screen + redraw banner' },
+  { name: '/task',     description: 'Run a full autonomous task' },
+  { name: '/search',   description: 'Web search' },
+  { name: '/fetch',    description: 'Fetch a URL' },
+  { name: '/git',      description: 'Git operations' },
+  { name: '/diff',     description: 'Compare two files' },
+  { name: '/run',      description: 'Execute a script file' },
+  { name: '/keys',     description: 'Manage API keys' },
+  { name: '/config',   description: 'View or edit settings' },
+  { name: '/export',   description: 'Export chat to markdown' },
+  { name: '/compact',  description: 'Compress conversation history' },
+  { name: '/undo',     description: 'Revert last AI file change' },
+  { name: '/exit',     description: 'Exit CLARITY' },
+];
 
-const COMMANDS = {
-  '/help': helpCommand,
-  '/chat': chatCommand,
-  '/agent': agentCommand,
-  '/tools': toolsCommand,
-  '/memory': memoryCommand,
-  '/history': historyCommand,
-  '/model': modelCommand,
-  '/provider': providerCommand,
-  '/config': configCommand,
-  '/clear': clearCommand,
-  '/run': runCommand,
-  '/task': taskCommand,
-  '/search': searchCommand,
-  '/fetch': fetchCommand,
-  '/git': gitCommand,
-  '/diff': diffCommand,
-  '/undo': undoCommand,
-  '/export': exportCommand,
-  '/keys': keysCommand,
-  '/exit': exitCommand,
-};
+export async function dispatchCommand(input, config, history) {
+  const parts = String(input).trim().split(/\s+/);
+  const cmd   = parts[0].toLowerCase();
+  const args  = parts.slice(1);
 
-export async function dispatchCommand(input, config, rl) {
-  const parts = input.trim().split(/\s+/);
-  const cmd = parts[0].toLowerCase();
-  const args = parts.slice(1);
-  const handler = COMMANDS[cmd];
-  if (!handler) {
-    console.log(`Unknown command: ${cmd}. Type /help for commands.`);
-    return config;
-  }
   try {
-    const result = await handler(args, config, rl);
-    return result || config;
-  } catch (err) {
-    console.log(`\x1b[31mCommand error:\x1b[0m ${err.message}`);
-    return config;
+    switch (cmd) {
+      case '/help': {
+        const m = await import('./help.js');
+        return m.helpCommand(args, config);
+      }
+      case '/agent': {
+        const m = await import('./agent.js');
+        return m.agentCommand(args, config);
+      }
+      case '/model': {
+        const m = await import('./model.js');
+        return m.modelCommand(args, config);
+      }
+      case '/provider': {
+        const m = await import('./provider.js');
+        return m.providerCommand(args, config);
+      }
+      case '/tools': {
+        const m = await import('./tools.js');
+        return m.toolsCommand(args, config);
+      }
+      case '/memory': {
+        const m = await import('./memory.js');
+        return m.memoryCommand(args, config);
+      }
+      case '/history': {
+        const m = await import('./history.js');
+        return m.historyCommand(args, config);
+      }
+      case '/chat': {
+        const m = await import('./chat.js');
+        return m.chatCommand(args, config);
+      }
+      case '/clear': {
+        const { showBanner } = await import('../ui/banner.js');
+        process.stdout.write('\x1Bc');
+        await showBanner(config.version, config.provider, config.model);
+        return;
+      }
+      case '/task': {
+        const m = await import('./task.js');
+        return m.taskCommand(args, config);
+      }
+      case '/search': {
+        const m = await import('./search.js');
+        return m.searchCommand(args, config);
+      }
+      case '/fetch': {
+        const m = await import('./fetch.js');
+        return m.fetchCommand(args, config);
+      }
+      case '/git': {
+        const m = await import('./git.js');
+        return m.gitCommand(args, config);
+      }
+      case '/diff': {
+        const m = await import('./diff.js');
+        return m.diffCommand(args, config);
+      }
+      case '/run': {
+        const m = await import('./run.js');
+        return m.runCommand(args, config);
+      }
+      case '/keys': {
+        const m = await import('./keys.js');
+        return m.keysCommand(args, config);
+      }
+      case '/config': {
+        const m = await import('./config.js');
+        return m.configCommand(args, config);
+      }
+      case '/export': {
+        const m = await import('./export.js');
+        return m.exportCommand(args, config);
+      }
+      case '/undo': {
+        const m = await import('./undo.js');
+        return m.undoCommand(args, config);
+      }
+      case '/exit': {
+        const chalk = (await import('chalk')).default;
+        console.log(chalk.hex('#00FF9F')('\n\u2714 Goodbye.'));
+        process.exit(0);
+      }
+      default: {
+        const chalk = (await import('chalk')).default;
+        console.log(chalk.hex('#FF4757')('\u2716 Unknown command: ') + cmd);
+        console.log(chalk.dim('  Type / to see all commands'));
+      }
+    }
+  } catch (e) {
+    const chalk = (await import('chalk')).default;
+    console.log(chalk.hex('#FF4757')('\u2716 Command error: ') + e.message);
   }
 }

package/src/commands/model.js

@@ -1,11 +1,26 @@
 import { saveConfig } from '../config/settings.js';
-import { clr } from '../ui/colors.js';
+import { PROVIDERS, getProvider } from '../providers/index.js';
+import chalk from 'chalk';
+
 export async function modelCommand(args, config) {
   if (args.length === 0) {
-    return console.log(clr.info('Current model: ' + config.provider + '/' + config.model));
+    console.log(chalk.hex('#54A0FF')('Current model: ') + chalk.white(config.provider + '/' + config.model));
+    return;
   }
-  config.model = args[0];
+
+  const modelName = args[0];
+
+  const prov = getProvider(modelName);
+  if (prov) {
+    config.provider = prov.value;
+    config.model = prov.freeModel;
+    saveConfig(config);
+    console.log(chalk.hex('#00FF9F')('Switched to provider: ') + chalk.white(prov.name) + chalk.dim(' (' + prov.freeModel + ')'));
+    return config;
+  }
+
+  config.model = modelName;
   saveConfig(config);
-  console.log(clr.success('Model set to: ' + config.model));
+  console.log(chalk.hex('#00FF9F')('Model set to: ') + chalk.white(modelName));
   return config;
 }

package/src/main.js

@@ -1,97 +1,168 @@
-import readline from 'readline';
 import chalk from 'chalk';
-import { renderAI, renderUser, renderInfo, renderError, renderSuccess, renderWarning, divider } from './ui/blocks.js';
+import { renderUser, renderAI, divider } from './ui/blocks.js';
+import { getPrompt, drawPromptBox, SlashPalette } from './ui/prompt.js';
 import { dispatchCommand } from './commands/index.js';
-import { callProvider } from './providers/index.js';
-import { loadHistory, saveHistory, addMessage } from './core/history.js';
 import { agentLoop } from './agents/loop.js';
+import { showBanner } from './ui/banner.js';
 
 export async function startChat(config) {
-  const history = loadHistory();
-
-  console.log(renderSuccess(
-    'CLARITY-AI v' + config.version + ' interactive session started.  ' +
-    'Type /help for commands. Ctrl+C to exit.'
-  ));
+  const history = [];
+  const palette = new SlashPalette();
+  let slashMode = false;
+  let slashBuffer = '';
+
+  const { top } = drawPromptBox(config.provider, config.model, config.agentMode);
+  console.log(chalk.hex('#00FF9F')('\u2714 ') + chalk.white('CLARITY-AI v' + config.version + ' interactive session started.') +
+              chalk.dim('  Type /help for commands. Ctrl+C to exit.'));
   console.log(divider());
   console.log();
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true,
-    historySize: 200,
-  });
+  const { emitKeypressEvents } = await import('readline');
+  emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+  let currentInput = '';
+
+  function drawPromptLine() {
+    process.stdout.write('\r\x1b[2K');
+    process.stdout.write(getPrompt(config.provider, config.model));
+    if (currentInput) process.stdout.write(currentInput);
+  }
 
-  function showPrompt() {
-    const pre =
-      chalk.hex('#00FFFF')('\u276f ') +
-      chalk.dim(config.provider + '/' + config.model) +
-      chalk.hex('#00FFFF')(' \u276f ');
-    rl.setPrompt(pre);
-    rl.prompt();
+  function clearAndPrompt() {
+    console.log();
+    drawPromptLine();
   }
 
-  process.stdin.on('keypress', (str, key) => {
-    if (key && key.ctrl && key.name === 'l') {
+  process.stdin.on('keypress', async (str, key) => {
+    if (!key) return;
+
+    if (key.ctrl && key.name === 'c') {
+      if (slashMode) {
+        palette.hide();
+        slashMode = false;
+        slashBuffer = '';
+        currentInput = '';
+        drawPromptLine();
+        return;
+      }
+      console.log('\n' + chalk.hex('#00FF9F')('\u2714 ') + chalk.dim('Session ended. Goodbye.'));
+      process.exit(0);
+    }
+
+    if (key.ctrl && key.name === 'l') {
       process.stdout.write('\x1Bc');
-      showPrompt();
+      await showBanner(config.version, config.provider, config.model);
+      drawPromptLine();
+      return;
     }
-  });
 
-  showPrompt();
+    if (key.ctrl && key.name === 'u') {
+      currentInput = '';
+      slashMode = false;
+      slashBuffer = '';
+      drawPromptLine();
+      return;
+    }
 
-  rl.on('line', async (input) => {
-    input = input.trim();
-    if (!input) { showPrompt(); return; }
+    if (key.name === 'escape') {
+      if (slashMode) {
+        palette.hide();
+        slashMode = false;
+        slashBuffer = '';
+        currentInput = '';
+        drawPromptLine();
+      }
+      return;
+    }
 
-    if (input.startsWith('/')) {
-      const newConfig = await dispatchCommand(input, config, rl);
-      if (newConfig) config = newConfig;
-      showPrompt();
+    if (slashMode) {
+      if (key.name === 'up') {
+        palette.selectPrev();
+        return;
+      }
+      if (key.name === 'down') {
+        palette.selectNext();
+        return;
+      }
+      if (key.name === 'return') {
+        const selected = palette.getSelected();
+        palette.hide();
+        slashMode = false;
+        currentInput = '';
+        drawPromptLine();
+        if (selected) {
+          console.log();
+          await dispatchCommand(selected.name, config, history);
+        }
+        clearAndPrompt();
+        return;
+      }
+      if (key.name === 'backspace') {
+        slashBuffer = slashBuffer.slice(0, -1);
+        currentInput = '/' + slashBuffer;
+        palette.filter(slashBuffer);
+        drawPromptLine();
+        return;
+      }
+      if (str && !key.ctrl && !key.meta) {
+        slashBuffer += str;
+        currentInput = '/' + slashBuffer;
+        palette.filter(slashBuffer);
+        drawPromptLine();
+        return;
+      }
       return;
     }
 
-    console.log();
-    console.log(renderUser(input));
-    console.log();
+    if (key.name === 'backspace') {
+      currentInput = currentInput.slice(0, -1);
+      drawPromptLine();
+      return;
+    }
 
-    if (config.agentMode !== false) {
-      const result = await agentLoop(input, config, history);
-      addMessage(history, 'user', input);
-      addMessage(history, 'assistant', result);
-      saveHistory(history);
-      console.log();
-      console.log(renderAI(result));
-      console.log();
-    } else {
-      addMessage(history, 'user', input);
-      console.log(chalk.hex('#555555')('\u25c6 Thinking...'));
-
-      let fullResponse = '';
-      const stream = callProvider(config, [
-        { role: 'system', content: 'You are CLARITY-AI, a helpful AI assistant. Keep responses short and direct.' },
-        ...history.slice(-10).map(m => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content })),
-        { role: 'user', content: input },
-      ]);
-
-      for await (const chunk of stream) {
-        fullResponse += chunk;
+    if (key.name === 'return') {
+      const input = currentInput.trim();
+      currentInput = '';
+
+      if (!input) {
+        console.log();
+        drawPromptLine();
+        return;
       }
 
+      process.stdout.write('\r\x1b[2K');
       console.log();
-      console.log(renderAI(fullResponse));
+      console.log(renderUser(input));
       console.log();
 
-      addMessage(history, 'assistant', fullResponse);
-      saveHistory(history);
+      if (input.startsWith('/')) {
+        await dispatchCommand(input, config, history);
+        clearAndPrompt();
+        return;
+      }
+
+      await agentLoop(input, config, history);
+      clearAndPrompt();
+      return;
     }
 
-    showPrompt();
-  });
+    if (str === '/' && currentInput === '') {
+      slashMode = true;
+      slashBuffer = '';
+      currentInput = '/';
+      console.log();
+      palette.show();
+      drawPromptLine();
+      return;
+    }
 
-  rl.on('SIGINT', () => {
-    console.log('\n' + renderInfo('Session ended. Goodbye.'));
-    process.exit(0);
+    if (str && !key.ctrl && !key.meta) {
+      currentInput += str;
+      drawPromptLine();
+    }
   });
+
+  console.log(top);
+  drawPromptLine();
 }

package/src/providers/index.js

@@ -16,15 +16,23 @@ export const PROVIDERS = [
 
 const senders = { groq: groqSend, gemini: geminiSend, openrouter: openrouterSend, openai: openaiSend, anthropic: anthropicSend, deepseek: deepseekSend };
 
-export function callProvider(config, messages) {
+export function streamProvider(config, messages) {
   const provider = config.provider || 'groq';
   const model = config.model || 'llama-3.3-70b-versatile';
   const apiKey = config.apiKeys?.[provider] || process.env[provider.toUpperCase() + '_API_KEY'] || '';
   const sender = senders[provider];
-  if (!sender) throw new Error(`Unknown provider: ${provider}`);
+  if (!sender) throw new Error('Unknown provider: ' + provider);
   return sender(apiKey, messages, model, true);
 }
 
+export async function callProvider(config, messages) {
+  let full = '';
+  for await (const chunk of streamProvider(config, messages)) {
+    full += chunk;
+  }
+  return full;
+}
+
 export function getProvider(name) {
   return PROVIDERS.find(p => p.value === name);
 }

package/src/ui/prompt.js

@@ -0,0 +1,127 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import { ALL_COMMANDS } from '../commands/index.js';
+
+const W = () => process.stdout.columns || 80;
+
+export function drawPromptBox(provider, model, agentMode = true) {
+  const w = Math.min(W(), 80);
+  const inner = w - 2;
+  const top    = chalk.hex('#333333')('\u250c') + chalk.hex('#333333')('\u2500'.repeat(inner)) + chalk.hex('#333333')('\u2510');
+  const bottom =
+    chalk.hex('#333333')('\u2514') +
+    chalk.hex('#333333')('\u2500 ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#333333')(' ' + '\u2500'.repeat(Math.max(0, inner - (provider + '/' + model).length - 14))) +
+    chalk.hex('#00FF9F')(agentMode ? 'agent: ON ' : 'agent: OFF') +
+    chalk.hex('#333333')('\u2500\u2518');
+  return { top, bottom };
+}
+
+export function getPrompt(provider, model) {
+  return (
+    chalk.hex('#333333')('\u2502 ') +
+    chalk.hex('#00FFFF')('\u276f ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#00FFFF')(' \u276f ')
+  );
+}
+
+export class SlashPalette {
+  constructor() {
+    this.visible = false;
+    this.query = '';
+    this.selected = 0;
+    this.commands = [];
+    this._lastLineCount = 0;
+  }
+
+  show() {
+    this.visible = true;
+    this.commands = ALL_COMMANDS;
+    this.selected = 0;
+    this.query = '';
+    this.render();
+  }
+
+  hide() {
+    this.visible = false;
+    this.query = '';
+    this.selected = 0;
+    const lines = this._lastLineCount;
+    this._lastLineCount = 0;
+    for (let i = 0; i < lines; i++) {
+      process.stdout.write('\x1b[A\x1b[2K');
+    }
+  }
+
+  filter(query) {
+    this.query = query;
+    this.selected = 0;
+    this.render();
+  }
+
+  selectNext() {
+    const filtered = this._filtered();
+    this.selected = Math.min(this.selected + 1, filtered.length - 1);
+    this.render();
+  }
+
+  selectPrev() {
+    this.selected = Math.max(this.selected - 1, 0);
+    this.render();
+  }
+
+  getSelected() {
+    const filtered = this._filtered();
+    return filtered[this.selected] || null;
+  }
+
+  _filtered() {
+    if (!this.query) return this.commands;
+    return this.commands.filter(c =>
+      c.name.includes(this.query) || c.description.toLowerCase().includes(this.query.toLowerCase())
+    );
+  }
+
+  render() {
+    const filtered = this._filtered();
+    const show = filtered.slice(0, 8);
+    const w = Math.min(W(), 80);
+
+    if (this._lastLineCount) {
+      for (let i = 0; i < this._lastLineCount; i++) {
+        process.stdout.write('\x1b[A\x1b[2K');
+      }
+    }
+
+    const lines = [];
+    lines.push(
+      chalk.bgHex('#1A1A2E').hex('#00FFFF').bold(' Commands ') +
+      chalk.bgHex('#1A1A2E').dim('  type to filter  ') +
+      chalk.bgHex('#1A1A2E').dim('esc to close'.padEnd(w - 28, ' '))
+    );
+    lines.push(chalk.hex('#333333')('\u2500'.repeat(w)));
+
+    if (show.length === 0) {
+      lines.push(chalk.dim('  No commands match "' + this.query + '"'));
+    } else {
+      show.forEach((cmd, i) => {
+        const isSelected = i === this.selected;
+        const prefix = isSelected ? chalk.hex('#00FFFF')(' \u276f ') : '   ';
+        const name   = isSelected
+          ? chalk.bgHex('#1A1A2E').hex('#00FFFF').bold((cmd.name).padEnd(18))
+          : chalk.hex('#9B59FF')((cmd.name).padEnd(18));
+        const desc   = isSelected
+          ? chalk.white(cmd.description)
+          : chalk.dim(cmd.description);
+        lines.push(prefix + name + '  ' + desc);
+      });
+    }
+
+    lines.push(chalk.hex('#333333')('\u2500'.repeat(w)));
+
+    process.stdout.write(lines.join('\n') + '\n');
+    this._lastLineCount = lines.length;
+  }
+}

package/src/ui/spinner.js

@@ -1,25 +1,100 @@
 import chalk from 'chalk';
-const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-export function createSpinner(text = '') {
-  let interval;
-  let i = 0;
-  return {
-    start() {
-      process.stdout.write(chalk.hex('#00FFFF')(FRAMES[0]) + ' ' + text);
-      interval = setInterval(() => {
-        i = (i + 1) % FRAMES.length;
-        process.stdout.write('\r' + chalk.hex('#00FFFF')(FRAMES[i]) + ' ' + text);
-      }, 80);
-    },
-    succeed(msg) {
-      clearInterval(interval);
-      process.stdout.write('\r' + chalk.hex('#00FF9F')('\u2714') + ' ' + (msg || text) + '\n');
-    },
-    fail(msg) {
-      clearInterval(interval);
-      process.stdout.write('\r' + chalk.hex('#FF4757')('\u2716') + ' ' + (msg || text) + '\n');
-    },
-    stop() { clearInterval(interval); },
-    update(t) { text = t; },
-  };
+
+const FRAMES = ['\u280b','\u2819','\u2839','\u2838','\u283c','\u2834','\u2826','\u2827','\u2807','\u280f'];
+const SUBAGENT_FRAMES = ['\u25f0\u25f1\u25f1\u25f1\u25f1','\u25f0\u25f0\u25f1\u25f1\u25f1','\u25f0\u25f0\u25f0\u25f1\u25f1','\u25f0\u25f0\u25f0\u25f0\u25f1','\u25f0\u25f0\u25f0\u25f0\u25f0','\u25f1\u25f0\u25f0\u25f0\u25f0','\u25f1\u25f1\u25f0\u25f0\u25f0','\u25f1\u25f1\u25f1\u25f0\u25f0','\u25f1\u25f1\u25f1\u25f1\u25f0','\u25f1\u25f1\u25f1\u25f1\u25f1'];
+
+export class Spinner {
+  constructor() {
+    this.frame = 0;
+    this.interval = null;
+    this.label = '';
+    this.sub = '';
+    this._active = false;
+  }
+
+  start(label, type = 'think') {
+    this._active = true;
+    this.label = label;
+    this.type = type;
+    this.frame = 0;
+
+    this.interval = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this._draw();
+    }, 80);
+
+    this._draw();
+  }
+
+  update(label, sub = '') {
+    this.label = label;
+    this.sub = sub;
+  }
+
+  stop(finalLabel, status = 'done') {
+    if (this.interval) clearInterval(this.interval);
+    this._active = false;
+    process.stdout.write('\r\x1b[2K');
+
+    const icon =
+      status === 'done'  ? chalk.hex('#00FF9F')('\u2714') :
+      status === 'error' ? chalk.hex('#FF4757')('\u2716') :
+      status === 'skip'  ? chalk.dim('\u2500') :
+                           chalk.hex('#00FF9F')('\u2714');
+
+    process.stdout.write(icon + ' ' + chalk.dim(finalLabel) + '\n');
+  }
+
+  _draw() {
+    process.stdout.write('\r\x1b[2K');
+
+    let spinChar, color;
+    if (this.type === 'think') {
+      spinChar = FRAMES[this.frame % FRAMES.length];
+      color = '#9B59FF';
+    } else if (this.type === 'tool') {
+      spinChar = FRAMES[this.frame % FRAMES.length];
+      color = '#00FFFF';
+    } else {
+      spinChar = SUBAGENT_FRAMES[this.frame % SUBAGENT_FRAMES.length];
+      color = '#FFD700';
+    }
+
+    const sub = this.sub ? chalk.dim(' \u00b7 ' + this.sub.slice(0, 40)) : '';
+    process.stdout.write(
+      chalk.hex(color)(spinChar) + ' ' +
+      chalk.white(this.label) +
+      sub
+    );
+  }
+}
+
+export class CollapsibleStep {
+  constructor(label, type = 'think') {
+    this.label = label;
+    this.type = type;
+    this.lines = [];
+    this._done = false;
+  }
+
+  addLine(line) {
+    this.lines.push(line);
+  }
+
+  printCollapsed(elapsed) {
+    const icon =
+      this.type === 'think' ? chalk.hex('#9B59FF')('+') :
+      this.type === 'tool'  ? chalk.hex('#00FFFF')('\u2699') :
+                              chalk.hex('#FFD700')('\u25c6');
+
+    const time = elapsed ? chalk.dim(' ' + elapsed + 'ms') : '';
+    console.log(icon + ' ' + chalk.white(this.label) + time);
+  }
+
+  printExpanded(elapsed) {
+    this.printCollapsed(elapsed);
+    for (const l of this.lines) {
+      console.log(chalk.dim('  \u2502 ') + chalk.hex('#888888')(l));
+    }
+  }
 }