clarity-ai 1.3.1 → 2.0.1

package/.env.example

@@ -0,0 +1,6 @@
+GROQ_API_KEY=
+GEMINI_API_KEY=
+OPENROUTER_API_KEY=
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+DEEPSEEK_API_KEY=

package/AGENTS.md

@@ -0,0 +1,47 @@
+# CLARITY-AI — Agent Guide
+
+## Project
+Single-package Node.js CLI tool (`clarity-ai`) — ESM module (`"type": "module"`).  
+Entry: `bin/clarity.js` → imports `src/index.js`.  
+Install: `npm install -g clarity-ai` → command `clarity`.
+
+## Key Architecture
+- **`src/providers/index.js`**: `sendMessage()` MUST be a plain `function`, NOT `async function`. Wrapping an async generator in `async` returns a Promise instead of an async iterable → `for await...of` breaks ("stream is not async iterable"). Each provider exports `async function* sendMessage(...)`. Provider model lists updated as of June 2026 — see `capabilities` object.
+- **`src/commands/index.js`**: All 40+ slash commands in one file, routed by switch. Single-file design — do NOT split into separate command files without changing the dispatcher. `/model` uses interactive inquirer selector. `/provider` switches provider + auto-filters models.
+- **`src/config/keys.js`**: API keys stored via `conf` package, obfuscated with base64-reverse (not real encryption). Provider regex patterns are strict — Gemini keys must match `/^AIzaSy[A-Za-z0-9_-]{20,}$/`.
+- **`src/ui/chatbox.js`**: Prompt bar design — grey fill (`\x1b[48;5;236m`) + purple outline (`chalk.hex('#7b2ff7')`). `renderPromptBar()` draws the bar, `showPrompt()` writes ` ◆ `. Pressing `/` at the prompt shows all command suggestions via `suggestCommands()` with `rl._refreshLine()`.
+- **`src/ui/prompt.js`**: History management only. `showPrompt()` and `showSuggestions()` moved to `chatbox.js`. `createPrompt()` creates readline interface with `terminal: true` (enables keypress events).
+- **Default model**: `groq/llama-3.3-70b-versatile` (updated in `src/config/settings.js`).
+
+## Termux Quirks
+- No `node-gyp`, no native modules, no `fsevents`.
+- `npm install -g` symlinks don't work for execution on Termux (permission denied across mount points). Postinstall creates a shell wrapper at `$PREFIX/bin/clarity`.
+- `open` package replaced with `termux-open-url` via `exec`.
+- Console clear: `console.clear()` at startup.
+
+## Commands
+```bash
+# Dev workflow (no test/lint scripts configured)
+npm start                    # node bin/clarity.js
+node bin/clarity.js /status  # run individual command
+node bin/clarity.js          # interactive chat mode
+
+# Publishing
+npm version patch && npm publish  # bump + publish (needs npm token with write access)
+```
+
+## Provider Streaming Contract
+Each provider file exports `{ PROVIDER, sendMessage }` where `sendMessage` is:
+```js
+async function* sendMessage(apiKey, messages, model, stream) → AsyncGenerator<string>
+```
+SSE parsing pattern: read `data: ` lines, parse JSON, yield `choices[0].delta.content`.
+
+## Known Gotchas
+- **Provider router must NOT be async**: `src/providers/index.js` `sendMessage` is a regular function returning the async generator directly.
+- **Model name format**: config stores `"provider/modelname"` (e.g. `groq/llama-3.3-70b-versatile`). Router strips prefix before passing to provider.
+- **No boxen/ora deps**: v1.2.0 removed them. Custom ANSI escape shaded boxes in `src/ui/blocks.js`. Custom spinner in `src/ui/spinner.js`.
+- **Config paths**: XDG-compliant (`~/.config/clarity/`, `~/.local/share/clarity/`, `~/.cache/clarity/`).
+- **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.

package/bin/clarity.js

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

package/config.json.example

@@ -0,0 +1,8 @@
+{
+  "theme": "dark",
+  "defaultModel": "groq/llama-3.3-70b-versatile",
+  "stream": true,
+  "showTokens": true,
+  "saveHistory": true,
+  "agentMode": "auto"
+}

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "clarity-ai",
-  "version": "1.3.1",
-  "description": "AI agent CLI for Termux and terminal — chat, code, automate",
+  "version": "2.0.1",
+  "description": "Autonomous AI Agent CLI for Termux",
   "type": "module",
-  "main": "src/index.js",
   "bin": {
     "clarity": "bin/clarity.js"
   },
   "scripts": {
     "start": "node bin/clarity.js",
-    "postinstall": "node scripts/postinstall.js"
+    "dev": "node --watch bin/clarity.js"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
     "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",
-    "figlet": "^1.7.0",
-    "gradient-string": "^2.0.2",
-    "cli-table3": "^0.6.3",
+    "cli-table3": "^0.6.5",
+    "wrap-ansi": "^9.0.1",
     "semver": "^7.6.0",
     "glob": "^10.3.12"
   },
@@ -31,10 +32,8 @@
     "cli",
     "termux",
     "agent",
-    "clarity",
-    "chatgpt",
-    "gemini",
-    "groq"
+    "autonomous",
+    "clarity"
   ],
   "license": "MIT"
 }

package/src/agent/intent.js

@@ -0,0 +1,15 @@
+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();
+  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; }
+  }
+  return score >= 2 ? 'agent' : 'chat';
+}

package/src/agent/loop.js

@@ -0,0 +1,105 @@
+import { toolBox, success, errorBox } from '../blocks.js';
+import { sendMessage } from '../providers/index.js';
+import { executeTool } from './tools.js';
+
+const AGENT_PROMPT = `You are CLARITY, an autonomous AI agent. You have tools available. Respond in JSON:
+{
+  "thought": "your reasoning",
+  "tool": "tool_name",
+  "args": { "key": "value" },
+  "done": false
+}
+When task is complete, set done: true and provide a summary.`;
+
+function extractJSON(text) {
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) return null;
+  try {
+    return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+}
+
+export async function agentLoop(conversation, model, apiKey) {
+  const messages = [
+    { role: 'system', content: AGENT_PROMPT },
+    ...conversation
+  ];
+
+  let step = 0;
+
+  while (true) {
+    step++;
+
+    const gen = sendMessage(apiKey, messages, model, false);
+    let raw = '';
+    for await (const chunk of gen) {
+      raw += chunk;
+    }
+
+    let parsed = null;
+    let attempts = 0;
+    while (!parsed && attempts < 3) {
+      parsed = extractJSON(raw);
+      if (!parsed) {
+        attempts++;
+        if (attempts < 3) {
+          const retryGen = sendMessage(apiKey, [
+            { role: 'system', content: AGENT_PROMPT },
+            ...messages,
+            { role: 'user', content: `Your previous response was not valid JSON. Please respond with valid JSON only:\n${raw}\n\nRespond ONLY with valid JSON.` }
+          ], model, false);
+          raw = '';
+          for await (const chunk of retryGen) {
+            raw += chunk;
+          }
+        }
+      }
+    }
+
+    if (!parsed) {
+      errorBox('Agent Error', 'Failed to parse JSON response after 3 attempts');
+      break;
+    }
+
+    const { thought, tool, args, done, summary } = parsed;
+
+    if (done) {
+      success('Task Complete', summary || 'Done');
+      return summary || 'Done';
+    }
+
+    if (!tool) {
+      errorBox('Agent Error', 'No tool specified in response');
+      break;
+    }
+
+    const start = Date.now();
+    let result;
+    let status;
+
+    try {
+      result = await executeTool(tool, args || {});
+      status = 'success';
+    } catch (err) {
+      result = err.message;
+      status = 'error';
+    }
+
+    const elapsed = Date.now() - start;
+
+    toolBox(tool, {
+      args: args || {},
+      status,
+      duration: elapsed + 'ms',
+      result: typeof result === 'string' ? result.slice(0, 500) : JSON.stringify(result).slice(0, 500)
+    });
+
+    messages.push({ role: 'assistant', content: JSON.stringify(parsed) });
+    messages.push({
+      role: 'user',
+      content: `Tool "${tool}" returned: ${typeof result === 'string' ? result.slice(0, 2000) : JSON.stringify(result).slice(0, 2000)}`
+    });
+  }
+}

package/src/agent/planner.js

@@ -0,0 +1,37 @@
+import { sendMessage } from '../providers/index.js';
+
+const PLAN_PROMPT = `You are CLARITY's planning system. Given a user task, create a step-by-step plan using available tools.
+
+Available tools: file_read, file_write, file_append, file_delete, file_list, file_exists, shell_run, shell_run_silent, npm_install, pkg_install, web_search, web_fetch, code_run, git_status, git_commit, sys_info, env_get, env_set, ai_ask, summarize
+
+Respond in JSON:
+{
+  "steps": [
+    { "step": "description of what to do", "tool": "tool_name", "args": { "key": "value" } }
+  ]
+}
+
+Provide only the JSON, no other text.`;
+
+export async function createPlan(task, model, apiKey) {
+  const messages = [
+    { role: 'system', content: PLAN_PROMPT },
+    { role: 'user', content: task }
+  ];
+
+  const gen = sendMessage(apiKey, messages, model, false);
+  let raw = '';
+  for await (const chunk of gen) {
+    raw += chunk;
+  }
+
+  const match = raw.match(/\{[\s\S]*\}/);
+  if (!match) return [{ step: 'Failed to parse plan', tool: null, args: null }];
+
+  try {
+    const parsed = JSON.parse(match[0]);
+    return parsed.steps || [];
+  } catch {
+    return [{ step: 'Failed to parse plan', tool: null, args: null }];
+  }
+}

package/src/agent/tools.js

@@ -0,0 +1,254 @@
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, appendFileSync, unlinkSync, readdirSync, existsSync } from 'fs';
+import { cpus, totalmem } from 'os';
+
+const tools = [];
+
+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;
+  }
+});
+
+export { tools };
+
+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);
+}