clarity-ai 3.0.1 → 3.1.0

package/bin/clarity.js

@@ -1,2 +1,24 @@
 #!/usr/bin/env node
-import '../src/index.js';
+// 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';
+import { startChat } from '../src/main.js';
+
+async function main() {
+  const firstRun = isFirstRun();
+  let config = firstRun ? {} : loadConfig();
+
+  await showBanner(config.version, config.provider, config.model);
+
+  if (firstRun) {
+    config = await runSetupWizard();
+  }
+
+  await startChat(config);
+}
+
+main().catch(err => {
+  console.error('\x1b[31mFatal error:\x1b[0m', err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,25 +1,31 @@
 {
   "name": "clarity-ai",
-  "version": "3.0.1",
-  "description": "Autonomous AI Agent Terminal — OpenCode-style TUI for Termux",
+  "version": "3.1.0",
+  "description": "Autonomous AI Agent CLI 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",
-    "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"
-  },
-  "engines": { "node": ">=18.0.0" }
+    "figlet": "^1.7.0",
+    "gradient-string": "^2.0.2",
+    "ora": "^8.1.0",
+    "inquirer": "^9.2.12",
+    "cli-table3": "^0.6.3",
+    "glob": "^10.3.10",
+    "chokidar": "^3.5.3",
+    "marked": "^9.1.6",
+    "marked-terminal": "^6.1.0",
+    "diff": "^5.1.0",
+    "archiver": "^6.0.1",
+    "strip-ansi": "^7.1.0"
+  }
 }

package/scripts/postinstall.js

@@ -40,15 +40,20 @@ const binDir = process.env.npm_config_prefix ? `${process.env.npm_config_prefix}
 if (isTermux && binDir) {
   const { existsSync, writeFileSync, chmodSync, unlinkSync, lstatSync } = await import('fs');
   const { resolve } = await import('path');
-  const wrapperPath = resolve(binDir, 'clarity');
+  const symlinkPath = resolve(binDir, 'clarity');
 
   try {
-    const stat = lstatSync(wrapperPath);
-    if (stat.isSymbolicLink()) {
-      unlinkSync(wrapperPath);
-      writeFileSync(wrapperPath, `#!/data/data/com.termux/files/usr/bin/bash\nexec node "${resolve(process.env.PREFIX || '/usr', 'lib/node_modules/clarity-ai/bin/clarity.js')}" "$@"\n`);
-      chmodSync(wrapperPath, '755');
-      console.log(chalk.hex('#00ff88')('  ✓ Termux wrapper created at:'), chalk.hex('#00d2ff')(wrapperPath));
+    if (existsSync(symlinkPath)) {
+      const stat = lstatSync(symlinkPath);
+      if (stat.isSymbolicLink()) {
+        unlinkSync(symlinkPath);
+      }
     }
-  } catch {}
+    const clarityPkgDir = process.env.PREFIX ? `${process.env.PREFIX}/lib/node_modules/clarity-ai` : resolve(process.cwd());
+    writeFileSync(symlinkPath, `#!/data/data/com.termux/files/usr/bin/bash\nexec node "${clarityPkgDir}/bin/clarity.js" "$@"\n`);
+    chmodSync(symlinkPath, '755');
+    console.log(chalk.hex('#00ff88')('  ✓ Termux wrapper created at:'), chalk.hex('#00d2ff')(symlinkPath));
+  } catch (e) {
+    console.error(chalk.hex('#ff4466')('  ✗ Failed to create Termux wrapper:'), e.message);
+  }
 }

package/src/agents/code-agent.js

@@ -0,0 +1,18 @@
+import { execSync } from 'child_process';
+import { writeFileSync, unlinkSync } from 'fs';
+
+export async function codeAgent({ language, code, test }) {
+  const ext = language === 'python' ? 'py' : language === 'javascript' ? 'js' : 'sh';
+  const tmpFile = `/tmp/clarity-agent.${ext}`;
+  try {
+    writeFileSync(tmpFile, code + (test ? `\n${test}` : ''), 'utf8');
+    const cmd = language === 'python' ? `python3 ${tmpFile}` :
+                language === 'javascript' ? `node ${tmpFile}` : `bash ${tmpFile}`;
+    const out = execSync(cmd, { encoding: 'utf8', timeout: 15000 });
+    return out || '(no output)';
+  } catch (err) {
+    return err.stdout || err.stderr || err.message;
+  } finally {
+    try { unlinkSync(tmpFile); } catch {}
+  }
+}

package/src/agents/file-agent.js

@@ -0,0 +1,24 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+export async function fileAgent({ action, path, content, pattern }) {
+  const abs = resolve(path || '.');
+  switch (action) {
+    case 'read':
+      if (!existsSync(abs)) return `Error: Not found: ${abs}`;
+      return readFileSync(abs, 'utf8');
+    case 'write':
+      if (!existsSync(dirname(abs))) mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, content || '', 'utf8');
+      return `Written: ${abs}`;
+    case 'delete':
+      if (!existsSync(abs)) return `Error: Not found: ${abs}`;
+      unlinkSync(abs);
+      return `Deleted: ${abs}`;
+    case 'list':
+      if (!existsSync(abs)) return `Error: Not found: ${abs}`;
+      return readdirSync(abs).join('\n');
+    default:
+      return 'Usage: file <read/write/delete/list> <path> [content]';
+  }
+}

package/src/agents/git-agent.js

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process';
+
+export async function gitAgent({ action, message, branch }) {
+  try {
+    switch (action) {
+      case 'status':
+        return execSync('git status', { encoding: 'utf8' });
+      case 'log':
+        return execSync('git log --oneline -10', { encoding: 'utf8' });
+      case 'commit':
+        execSync('git add .', { encoding: 'utf8' });
+        return execSync(`git commit -m "${message || 'update'}"`, { encoding: 'utf8' });
+      case 'push':
+        return execSync('git push', { encoding: 'utf8', timeout: 30000 });
+      case 'pull':
+        return execSync('git pull', { encoding: 'utf8', timeout: 30000 });
+      case 'branch':
+        return execSync(`git branch ${branch || ''}`, { encoding: 'utf8' });
+      case 'diff':
+        return execSync('git diff', { encoding: 'utf8' });
+      default:
+        return 'Usage: git <status|log|commit|push|pull|branch|diff> [args]';
+    }
+  } catch (err) {
+    return err.stderr || err.message;
+  }
+}

package/src/agents/loop.js

@@ -0,0 +1,205 @@
+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 { 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;
+  });
+}
+
+async function executeToolCall(toolName, toolInput) {
+  switch (toolName) {
+    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;
+    }
+
+    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++;
+        }
+      }
+
+      const filtered = filterContextHunks(hunks, 2);
+      writeFileSync(path, updated, 'utf-8');
+      console.log(renderEdit(path, filtered));
+      return 'Edited ' + path;
+    }
+
+    case 'bash': {
+      const { command } = toolInput;
+      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;
+      }
+    }
+
+    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;
+    }
+
+    default: {
+      try {
+        const mod = await import('../tools/' + toolName + '.js');
+        const toolFn = Object.values(mod)[0];
+        const result = await toolFn(toolInput);
+        console.log(renderTool(toolName, JSON.stringify(toolInput).slice(0, 60), result));
+        return result;
+      } catch (e) {
+        return 'Tool error: ' + e.message;
+      }
+    }
+  }
+}
+
+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;
+
+  while (toolCalls < maxToolCalls) {
+    let fullResponse = '';
+    const stream = callProvider(config, messages);
+    for await (const chunk of stream) {
+      fullResponse += chunk;
+    }
+
+    const jsonMatch = fullResponse.match(/\{[^]*\}/);
+    if (!jsonMatch) {
+      finalResponse = fullResponse;
+      break;
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonMatch[0]);
+    } catch {
+      finalResponse = fullResponse;
+      break;
+    }
+
+    if (parsed.response) {
+      finalResponse = parsed.response;
+      break;
+    }
+
+    if (parsed.tool) {
+      toolCalls++;
+      const toolName = parsed.tool;
+      const args = parsed.args || {};
+
+      const result = await executeToolCall(toolName, args);
+
+      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';
+}

package/src/agents/monitor-agent.js

@@ -0,0 +1,22 @@
+import { watch } from 'fs';
+import { resolve } from 'path';
+
+let watchers = [];
+
+export async function monitorAgent({ action, path, event }) {
+  if (action === 'watch') {
+    const abs = resolve(path || '.');
+    const watcher = watch(abs, { recursive: true }, (eventType, filename) => {
+      console.log(`[monitor] ${eventType}: ${filename}`);
+    });
+    watchers.push(watcher);
+    return `Watching: ${abs}`;
+  } else if (action === 'stop') {
+    for (const w of watchers) w.close();
+    watchers = [];
+    return 'Monitoring stopped';
+  } else if (action === 'status') {
+    return `Active watchers: ${watchers.length}`;
+  }
+  return 'Usage: monitor <watch|stop|status> [path]';
+}

package/src/agents/planner.js

@@ -0,0 +1,21 @@
+import { callProvider } from '../providers/index.js';
+
+export async function planTask(userMessage, config) {
+  const messages = [
+    { role: 'system', content: 'You are a task planner. Break down the user\'s goal into a numbered step-by-step plan. Be specific and actionable. Respond with a JSON array of steps.' },
+    { role: 'user', content: userMessage },
+  ];
+
+  let response = '';
+  const stream = callProvider(config, messages);
+  for await (const chunk of stream) {
+    response += chunk;
+  }
+
+  try {
+    const jsonMatch = response.match(/\[[^]*\]/);
+    if (jsonMatch) return JSON.parse(jsonMatch[0]);
+  } catch {}
+
+  return response.split('\n').filter(l => /^\d+\./.test(l)).map((l, i) => ({ step: i + 1, task: l.replace(/^\d+\.\s*/, '') }));
+}

package/src/agents/shell-agent.js

@@ -0,0 +1,11 @@
+import { execSync } from 'child_process';
+
+export async function shellAgent({ command, cwd, timeout }) {
+  if (!command) return 'No command specified';
+  try {
+    const out = execSync(command, { encoding: 'utf8', timeout: timeout || 30000, cwd: cwd || process.cwd() });
+    return out || '(no output)';
+  } catch (err) {
+    return err.stderr || err.message;
+  }
+}

package/src/agents/web-agent.js

@@ -0,0 +1,16 @@
+export async function webAgent({ action, url, query }) {
+  try {
+    if (action === 'search') {
+      const res = await fetch(`https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1`);
+      const data = await res.json();
+      return data.AbstractText || JSON.stringify(data.RelatedTopics?.slice(0, 5) || 'No results');
+    } else if (action === 'fetch') {
+      const res = await fetch(url);
+      const html = await res.text();
+      return html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().substring(0, 5000);
+    }
+    return 'Usage: web <search|fetch> <query|url>';
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}

package/src/commands/agent.js

@@ -0,0 +1,14 @@
+import { clr } from '../ui/colors.js';
+export async function agentCommand(args, config) {
+  const mode = args[0];
+  if (mode === 'on' || mode === 'true') {
+    config.agentMode = true;
+    console.log(clr.success('Agent mode: ON'));
+  } else if (mode === 'off' || mode === 'false') {
+    config.agentMode = false;
+    console.log(clr.warning('Agent mode: OFF'));
+  } else {
+    console.log(clr.info(`Agent mode: ${config.agentMode ? 'ON' : 'OFF'}`));
+  }
+  return config;
+}

package/src/commands/chat.js

@@ -1,104 +1,8 @@
-import blocks from '../blocks.js';
-import c from '../colors.js';
-import memStore from '../memory/store.js';
-import { writeFileSync } from 'fs';
-import { resolve } from 'path';
-
-const { info, success, warn, error: errorBox, table, divider } = blocks;
-
-export async function clear(args, context) {
-  console.clear();
-  success('Cleared', 'Screen and context cleared.');
-}
-
-export async function history(args, context) {
-  const sub = args[0];
-  if (!sub) { warn('Usage', '/history show|clear|export [n|file]'); return; }
-
-  switch (sub) {
-    case 'show': {
-      const n = args[1] ? parseInt(args[1]) : 20;
-      const ctx = memStore.show();
-      const recent = ctx.slice(-n);
-      if (recent.length === 0) { info('History', 'No history.'); return; }
-      recent.forEach(m => console.log(`${c.muted(m.role)}: ${m.content.slice(0, 150)}`));
-      break;
-    }
-    case 'clear': {
-      memStore.clear();
-      success('Cleared', 'History cleared.');
-      break;
-    }
-    case 'export': {
-      const file = args[1] || `clarity-chat-${Date.now()}.md`;
-      const fullPath = resolve(file);
-      const ctx = memStore.show();
-      const md = ctx.map(m => `**${m.role}**: ${m.content}`).join('\n\n');
-      writeFileSync(fullPath, `# CLARITY Chat Export\n\n${md}`, 'utf8');
-      success('Exported', c.filename(fullPath));
-      break;
-    }
-    default:
-      warn('Usage', '/history show|clear|export');
-  }
-}
-
-export async function retry(args, context) {
-  const ctx = memStore.show();
-  const lastUser = ctx.filter(m => m.role === 'user').pop();
-  if (!lastUser) { warn('Retry', 'No previous user message to retry.'); return; }
-  info('Retry', `Retrying: "${lastUser.content.slice(0, 80)}..."`);
-}
-
-export async function copy(args, context) {
-  const ctx = memStore.show();
-  const last = ctx.filter(m => m.role === 'assistant').pop();
-  if (!last) { warn('Copy', 'No AI response to copy.'); return; }
-  try {
-    if (process.env.PREFIX?.includes('com.termux') || process.env.TERMUX_VERSION) {
-      const { execSync } = await import('child_process');
-      execSync(`termux-clipboard-set "${last.content.replace(/"/g, '\\"')}"`);
-    } else {
-      const { default: clipboard } = await import('clipboardy');
-      clipboard.writeSync(last.content);
-    }
-    success('Copied', 'Last AI response copied to clipboard.');
-  } catch {
-    info('Copy', last.content.slice(0, 500));
-  }
-}
-
-export async function ask(args, context) {
-  const question = args.join(' ');
-  if (!question) { warn('Usage', '/ask <question>'); return; }
-  blocks.user(question);
-  info('Ask', 'Configure API keys with /init first to get AI responses.');
-}
-
-export async function memory(args, context) {
-  const sub = args[0];
-  if (!sub) { warn('Usage', '/memory show|add|clear'); return; }
-
-  switch (sub) {
-    case 'show': {
-      const ctx = memStore.show();
-      if (ctx.length === 0) { info('Memory', 'No context stored.'); return; }
-      ctx.forEach(m => console.log(`${c.muted(m.role)}: ${m.content.slice(0, 200)}`));
-      break;
-    }
-    case 'add': {
-      const note = args.slice(1).join(' ');
-      if (!note) { warn('Usage', '/memory add <note>'); return; }
-      memStore.addNote(note);
-      success('Memory Added', note);
-      break;
-    }
-    case 'clear': {
-      memStore.clear();
-      success('Cleared', 'Memory cleared.');
-      break;
-    }
-    default:
-      warn('Usage', '/memory show|add|clear');
+import { blocks } from '../ui/blocks.js';
+export async function chatCommand(args, config) {
+  if (args[0] === 'new') {
+    console.log(blocks.info('New chat session started.', '◆ CHAT'));
+    return { ...config, chatHistory: [] };
   }
+  console.log(blocks.info('Chat mode active. Provider: ' + config.provider + ', Model: ' + config.model, '◆ CHAT'));
 }

package/src/commands/clear.js

@@ -0,0 +1,5 @@
+export async function clearCommand(args, config) {
+  process.stdout.write('\x1Bc');
+  const { showBanner } = await import('../ui/banner.js');
+  await showBanner(config.version, config.provider, config.model);
+}