clarity-ai 3.2.0 → 4.0.0

package/bin/clarity.js

@@ -1,24 +1,17 @@
 #!/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';
-import { startChat } from '../src/main.js';
+import React from 'react';
+import { render } from 'ink';
+import { App } from '../ui/App.js';
+import { loadConfig } from '../core/config.js';
+import { ensureApiKey } from '../core/keyCheck.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);
+  const config = loadConfig();
+  await ensureApiKey(config.provider || 'groq');
+  render(React.createElement(App, { config }), { fullscreen: true });
 }
 
 main().catch(err => {
-  console.error('\x1b[31mFatal error:\x1b[0m', err.message);
+  console.error('\n\x1b[31mFatal error:\x1b[0m', err.message);
   process.exit(1);
 });

package/core/agent.js

@@ -0,0 +1,52 @@
+import { callAI } from './providers/index.js';
+import { TOOLS, executeTool } from './tools.js';
+import { extractCommandFromText } from './intentDetect.js';
+
+export async function runAgent({ messages, model, provider, agentMode, onToolCall }) {
+  let history = [...messages];
+  const MAX_ITERATIONS = 10;
+
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const response = await callAI({
+      model, provider,
+      messages: history,
+      tools: agentMode ? TOOLS : undefined,
+    });
+
+    const { content, tool_calls, finish_reason } = response;
+
+    if (!tool_calls || tool_calls.length === 0 || finish_reason === 'stop') {
+      if (agentMode) {
+        const cmd = extractCommandFromText(content || '');
+        if (cmd) {
+          onToolCall?.('bash(' + cmd.slice(0, 60) + ')');
+          const result = await executeTool('bash', { command: cmd });
+          history.push({ role: 'assistant', content });
+          history.push({ role: 'tool', name: 'bash', content: String(result) });
+          continue;
+        }
+      }
+      return content;
+    }
+
+    history.push({ role: 'assistant', content, tool_calls });
+
+    for (const call of tool_calls) {
+      const name = call.function.name;
+      const args = JSON.parse(call.function.arguments || '{}');
+
+      onToolCall?.(name + '(' + JSON.stringify(args).slice(0, 80) + ')');
+
+      const result = await executeTool(name, args);
+
+      history.push({
+        role: 'tool',
+        tool_call_id: call.id,
+        name,
+        content: String(result),
+      });
+    }
+  }
+
+  return 'Max iterations reached.';
+}

package/core/config.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.clarity');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  provider: 'groq',
+  model: 'groq/llama-3.3-70b-versatile',
+  keys: {},
+  agentMode: true,
+  maxTokens: 4096,
+  temperature: 0.7,
+};
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULTS };
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, 'utf-8');
+    return { ...DEFAULTS, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function saveKey(provider, key) {
+  const config = loadConfig();
+  config.keys = config.keys || {};
+  config.keys[provider] = key;
+  saveConfig(config);
+}

package/core/intentDetect.js

@@ -0,0 +1,13 @@
+export function extractCommandFromText(text) {
+  const patterns = [
+    /```(?:bash|sh)\n([\s\S]+?)```/,
+    /Run(?:: | the following)?\s*`([^`]+)`/i,
+    /execute[:\s]+`([^`]+)`/i,
+    /run (?:this |the following )?command[:\s]*`([^`]+)`/i,
+  ];
+  for (const p of patterns) {
+    const m = text.match(p);
+    if (m) return m[1].trim();
+  }
+  return null;
+}

package/core/keyCheck.js

@@ -0,0 +1,21 @@
+import { createInterface } from 'readline';
+import { loadConfig, saveKey } from './config.js';
+
+export function ensureApiKey(provider) {
+  const config = loadConfig();
+  const key = config.keys?.[provider];
+  if (key) return key;
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(
+      '\n\x1b[33m No ' + provider + ' API key found.\x1b[0m\n Enter your ' + provider + ' key: ',
+      (answer) => {
+        rl.close();
+        const trimmed = answer.trim();
+        saveKey(provider, trimmed);
+        resolve(trimmed);
+      }
+    );
+  });
+}

package/core/providers/index.js

@@ -0,0 +1,79 @@
+import Groq from 'groq-sdk';
+
+export async function callAI({ model, provider, messages, tools }) {
+  const providerName = provider || 'groq';
+  const modelName = model.replace(/^[^/]+\//, '');
+
+  switch (providerName.toLowerCase()) {
+    case 'groq': {
+      const { loadConfig } = await import('../config.js');
+      const config = loadConfig();
+      const apiKey = config.keys?.groq;
+      if (!apiKey) throw new Error('No Groq API key set. Use /keys groq <key>.');
+
+      const client = new Groq({ apiKey });
+      const res = await client.chat.completions.create({
+        model: modelName,
+        messages,
+        tools: tools && tools.length > 0 ? tools : undefined,
+        tool_choice: tools && tools.length > 0 ? 'auto' : undefined,
+      });
+      const choice = res.choices[0];
+      return {
+        content: choice.message.content || '',
+        tool_calls: choice.message.tool_calls || null,
+        finish_reason: choice.finish_reason,
+      };
+    }
+
+    case 'openrouter': {
+      const { loadConfig } = await import('../config.js');
+      const config = loadConfig();
+      const apiKey = config.keys?.openrouter;
+      if (!apiKey) throw new Error('No OpenRouter API key set.');
+
+      const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'Bearer ' + apiKey,
+          'HTTP-Referer': 'https://clarity-ai.local',
+          'X-Title': 'CLARITY AI',
+        },
+        body: JSON.stringify({
+          model: modelName,
+          messages,
+          tools: tools && tools.length > 0 ? tools : undefined,
+        }),
+      });
+      const data = await res.json();
+      const choice = data.choices?.[0];
+      return {
+        content: choice?.message?.content || '',
+        tool_calls: choice?.message?.tool_calls || null,
+        finish_reason: choice?.finish_reason,
+      };
+    }
+
+    case 'gemini': {
+      const { GoogleGenerativeAI } = await import('@google/generative-ai');
+      const { loadConfig } = await import('../config.js');
+      const config = loadConfig();
+      const apiKey = config.keys?.gemini;
+      if (!apiKey) throw new Error('No Gemini API key set.');
+
+      const genAI = new GoogleGenerativeAI(apiKey);
+      const model_ = genAI.getGenerativeModel({ model: modelName });
+      const chat = model_.startChat({ messages });
+      const result = await chat.sendMessage(messages[messages.length - 1]?.content || '');
+      return {
+        content: result.response.text() || '',
+        tool_calls: null,
+        finish_reason: 'stop',
+      };
+    }
+
+    default:
+      throw new Error('Unknown provider: ' + providerName);
+  }
+}

package/core/tools.js

@@ -0,0 +1,178 @@
+import { exec } from 'child_process';
+import { readFile, writeFile, readdir, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function outputFile(path, content) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) await mkdir(dir, { recursive: true });
+  await writeFile(path, content, 'utf-8');
+}
+
+export const TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'bash',
+      description: 'Execute a bash command in the Termux shell and return stdout/stderr',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'The bash command to run' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read a file from the filesystem',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          offset: { type: 'number', description: 'Line offset to start reading' },
+          limit: { type: 'number', description: 'Max lines to read' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          content: { type: 'string' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_dir',
+      description: 'List files in a directory',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', default: '.' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'grep',
+      description: 'Search for a pattern in files',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string' },
+          path: { type: 'string' },
+          flags: { type: 'string', default: '-r' },
+        },
+        required: ['pattern', 'path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'web_search',
+      description: 'Search the web for information',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+        },
+        required: ['query'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'web_fetch',
+      description: 'Fetch a URL and return its text content',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', format: 'uri' },
+        },
+        required: ['url'],
+      },
+    },
+  },
+];
+
+export async function executeTool(name, args) {
+  switch (name) {
+    case 'bash': {
+      try {
+        const { stdout, stderr } = await execAsync(args.command, { timeout: 30000 });
+        return stdout || stderr || '(no output)';
+      } catch (e) {
+        return 'Error: ' + (e.stderr || e.message);
+      }
+    }
+    case 'read_file': {
+      const content = await readFile(args.path, 'utf8');
+      const lines = content.split('\n');
+      const start = args.offset || 0;
+      const end = args.limit ? start + args.limit : lines.length;
+      return lines.slice(start, end).join('\n');
+    }
+    case 'write_file': {
+      await outputFile(args.path, args.content);
+      return 'Written to ' + args.path;
+    }
+    case 'list_dir': {
+      const files = await readdir(args.path || '.');
+      return files.join('\n');
+    }
+    case 'grep': {
+      try {
+        const { stdout } = await execAsync(
+          'grep ' + (args.flags || '-r') + ' "' + args.pattern + '" "' + args.path + '"',
+          { timeout: 10000 }
+        );
+        return stdout || '(no matches)';
+      } catch (e) {
+        return e.stdout || '(no matches)';
+      }
+    }
+    case 'web_search': {
+      try {
+        const url = 'https://api.duckduckgo.com/?q=' + encodeURIComponent(args.query) + '&format=json&no_html=1';
+        const res = await fetch(url);
+        const data = await res.json();
+        return data.AbstractText || data.RelatedTopics?.slice(0,3)?.map(t => t.Text).join('\n') || 'No results';
+      } catch (e) {
+        return 'Search error: ' + e.message;
+      }
+    }
+    case 'web_fetch': {
+      try {
+        const res = await fetch(args.url);
+        const text = await res.text();
+        return text.slice(0, 5000);
+      } catch (e) {
+        return 'Fetch error: ' + e.message;
+      }
+    }
+    default:
+      return 'Unknown tool: ' + name;
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clarity-ai",
-  "version": "3.2.0",
-  "description": "Autonomous AI Agent CLI for Termux",
+  "version": "4.0.0",
+  "description": "Ink+React TUI Autonomous AI Agent CLI for Termux",
   "type": "module",
   "bin": {
     "clarity": "bin/clarity.js"
@@ -14,18 +14,15 @@
     "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",
-    "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"
+    "@google/generative-ai": "^0.24.1",
+    "@inkjs/ui": "^2.0.0",
+    "@langchain/langgraph": "^1.3.5",
+    "groq-sdk": "^1.2.1",
+    "ink": "^7.0.5",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^4.0.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0"
   }
 }