clarity-ai 1.3.1 → 2.0.0

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/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.0",
+  "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/agents/BaseAgent.js

@@ -1,54 +0,0 @@
-import logger from '../utils/logger.js';
-
-class BaseAgent {
-  constructor(config = {}) {
-    this.id = config.id || `agent_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
-    this.name = config.name || 'Agent';
-    this.type = config.type || 'base';
-    this.status = 'stopped';
-    this.logs = [];
-    this.config = config;
-    this._interval = null;
-  }
-
-  async start() {
-    this.status = 'running';
-    this.log('info', 'Agent started');
-  }
-
-  async stop() {
-    this.status = 'stopped';
-    if (this._interval) {
-      clearInterval(this._interval);
-      this._interval = null;
-    }
-    this.log('info', 'Agent stopped');
-  }
-
-  async pause() {
-    this.status = 'paused';
-    this.log('info', 'Agent paused');
-  }
-
-  async resume() {
-    this.status = 'running';
-    this.log('info', 'Agent resumed');
-  }
-
-  log(level, msg) {
-    const entry = { level, msg, time: new Date().toISOString() };
-    this.logs.push(entry);
-    if (this.logs.length > 1000) this.logs.shift();
-    logger[level](`[${this.id}] ${msg}`);
-  }
-
-  emit(event, data) {
-    this.log('info', `Event: ${event} ${data ? JSON.stringify(data) : ''}`);
-  }
-
-  getStatus() {
-    return { id: this.id, name: this.name, type: this.type, status: this.status, logCount: this.logs.length };
-  }
-}
-
-export default BaseAgent;

package/src/agents/CodeAgent.js

@@ -1,57 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-import { watch, readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-
-class CodeAgent extends BaseAgent {
-  constructor(config) {
-    super({ ...config, type: 'code', name: config.name || 'Code Watcher' });
-    this.file = config.file;
-    this.language = config.language || 'auto';
-    this.autoFix = config.autoFix || false;
-    this._watcher = null;
-  }
-
-  async start() {
-    if (!this.file) {
-      this.log('error', 'No file specified');
-      return;
-    }
-    await super.start();
-    const filePath = resolve(this.file);
-    this.log('info', `Watching ${filePath} for errors`);
-
-    try {
-      const content = readFileSync(filePath, 'utf8');
-      this.analyze(content);
-    } catch {}
-
-    this._watcher = watch(filePath, (eventType) => {
-      if (eventType === 'change') {
-        try {
-          const content = readFileSync(filePath, 'utf8');
-          this.analyze(content);
-        } catch {}
-      }
-    });
-  }
-
-  analyze(content) {
-    const lines = content.split('\n');
-    const errors = [];
-    lines.forEach((line, i) => {
-      if (line.length > 200) errors.push({ line: i + 1, msg: 'Line too long' });
-      if (line.includes('\t')) errors.push({ line: i + 1, msg: 'Tab character detected' });
-    });
-    if (errors.length > 0) {
-      this.log('warn', `Found ${errors.length} issues in ${this.file}`);
-      errors.forEach(e => this.log('warn', `  L${e.line}: ${e.msg}`));
-    }
-  }
-
-  async stop() {
-    if (this._watcher) { this._watcher.close(); this._watcher = null; }
-    await super.stop();
-  }
-}
-
-export default CodeAgent;

package/src/agents/FileAgent.js

@@ -1,39 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-import { watch } from 'fs';
-import { resolve } from 'path';
-
-class FileAgent extends BaseAgent {
-  constructor(config) {
-    super({ ...config, type: 'file', name: config.name || 'File Watcher' });
-    this.watchDir = config.watchDir || '.';
-    this.pattern = config.pattern || '*';
-    this.onChangePrompt = config.onChangePrompt || 'File changed: {path}';
-    this._watcher = null;
-  }
-
-  async start() {
-    await super.start();
-    try {
-      const dir = resolve(this.watchDir);
-      this._watcher = watch(dir, { recursive: true }, (eventType, filename) => {
-        if (filename && filename.match(this.pattern.replace('*', '.*'))) {
-          this.log('info', `File ${eventType}: ${filename}`);
-          this.emit('fileChange', { eventType, filename });
-        }
-      });
-      this.log('info', `Watching ${dir} for changes`);
-    } catch (err) {
-      this.log('error', `Watch error: ${err.message}`);
-    }
-  }
-
-  async stop() {
-    if (this._watcher) {
-      this._watcher.close();
-      this._watcher = null;
-    }
-    await super.stop();
-  }
-}
-
-export default FileAgent;

package/src/agents/MonitorAgent.js

@@ -1,54 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-import os from 'os';
-
-class MonitorAgent extends BaseAgent {
-  constructor(config) {
-    super({ ...config, type: 'monitor', name: config.name || 'System Monitor' });
-    this.intervalMs = config.intervalMs || 5000;
-    this.alertThresholds = config.alertThresholds || { cpu: 90, memory: 90 };
-  }
-
-  async start() {
-    await super.start();
-    this.log('info', `Monitoring system every ${this.intervalMs}ms`);
-    this._interval = setInterval(() => this.check(), this.intervalMs);
-  }
-
-  check() {
-    const mem = process.memoryUsage();
-    const memPct = Math.round((mem.heapUsed / mem.heapTotal) * 100);
-    const load = os.loadavg()[0];
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const memUsage = Math.round(((totalMem - freeMem) / totalMem) * 100);
-
-    const stats = {
-      cpu: load.toFixed(2),
-      memory: memPct,
-      systemMem: memUsage,
-      heap: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
-      uptime: Math.round(process.uptime()) + 's',
-    };
-
-    if (memPct > this.alertThresholds.memory) {
-      this.log('warn', `High memory usage: ${memPct}%`);
-    }
-    if (load > this.alertThresholds.cpu / 100) {
-      this.log('warn', `High CPU load: ${load}`);
-    }
-
-    this.emit('stats', stats);
-  }
-
-  getStats() {
-    const mem = process.memoryUsage();
-    return {
-      cpu: os.loadavg()[0].toFixed(2),
-      memory: Math.round((mem.heapUsed / mem.heapTotal) * 100),
-      uptime: Math.round(process.uptime()),
-      os: `${os.platform()} ${os.arch()}`,
-    };
-  }
-}
-
-export default MonitorAgent;

package/src/agents/ShellAgent.js

@@ -1,31 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-class ShellAgent extends BaseAgent {
-  constructor(config) {
-    super({ ...config, type: 'shell', name: config.name || 'Shell Runner' });
-    this.command = config.command || 'echo hello';
-    this.intervalMs = config.intervalMs || 60000;
-    this.storeOutput = config.storeOutput !== false;
-  }
-
-  async start() {
-    await super.start();
-    this.log('info', `Running command every ${this.intervalMs}ms: ${this.command}`);
-    this._interval = setInterval(async () => {
-      try {
-        const { stdout, stderr } = await execAsync(this.command);
-        if (this.storeOutput) this.log('info', `Output: ${stdout.trim().slice(0, 200)}`);
-        if (stderr) this.log('warn', `Stderr: ${stderr.trim().slice(0, 200)}`);
-        this.emit('commandComplete', { command: this.command, stdout, stderr });
-      } catch (err) {
-        this.log('error', `Command failed: ${err.message}`);
-      }
-    }, this.intervalMs);
-  }
-}
-
-export default ShellAgent;

package/src/agents/WebAgent.js

@@ -1,39 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-
-class WebAgent extends BaseAgent {
-  constructor(config) {
-    super({ ...config, type: 'web', name: config.name || 'Web Fetcher' });
-    this.url = config.url;
-    this.intervalMs = config.intervalMs || 300000;
-    this.lastContent = '';
-  }
-
-  async start() {
-    if (!this.url) {
-      this.log('error', 'No URL configured');
-      return;
-    }
-    await super.start();
-    this.log('info', `Fetching ${this.url} every ${this.intervalMs}ms`);
-    await this.fetch();
-    this._interval = setInterval(() => this.fetch(), this.intervalMs);
-  }
-
-  async fetch() {
-    try {
-      const res = await fetch(this.url);
-      const text = await res.text();
-      const clean = text.replace(/<[^>]+>/g, '').trim().slice(0, 500);
-      if (this.lastContent && clean !== this.lastContent) {
-        this.log('info', 'Content changed!');
-        this.emit('contentChange', { url: this.url, preview: clean.slice(0, 100) });
-      }
-      this.lastContent = clean;
-      this.log('info', `Fetched ${this.url} (${text.length} bytes)`);
-    } catch (err) {
-      this.log('error', `Fetch failed: ${err.message}`);
-    }
-  }
-}
-
-export default WebAgent;

package/src/agents/manager.js

@@ -1,116 +0,0 @@
-import BaseAgent from './BaseAgent.js';
-import FileAgent from './FileAgent.js';
-import ShellAgent from './ShellAgent.js';
-import WebAgent from './WebAgent.js';
-import CodeAgent from './CodeAgent.js';
-import MonitorAgent from './MonitorAgent.js';
-import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
-import { resolve, dirname } from 'path';
-import paths from '../config/paths.js';
-import blocks from '../ui/blocks.js';
-
-const AGENT_MAP = {
-  file: FileAgent,
-  shell: ShellAgent,
-  web: WebAgent,
-  code: CodeAgent,
-  monitor: MonitorAgent,
-};
-
-class AgentManager {
-  constructor() {
-    this.agents = new Map();
-  }
-
-  async start(agentType, config = {}) {
-    const AgentClass = AGENT_MAP[agentType];
-    if (!AgentClass) throw new Error(`Unknown agent type: ${agentType}`);
-    
-    const agent = new AgentClass(config);
-    this.agents.set(agent.id, agent);
-    await agent.start();
-    this.save();
-    return agent.id;
-  }
-
-  async stop(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent) throw new Error(`Agent not found: ${agentId}`);
-    await agent.stop();
-    this.agents.delete(agentId);
-    this.save();
-  }
-
-  list() {
-    return Array.from(this.agents.values()).map(a => a.getStatus());
-  }
-
-  getLogs(agentId, lines = 50) {
-    const agent = this.agents.get(agentId);
-    if (!agent) throw new Error(`Agent not found: ${agentId}`);
-    return agent.logs.slice(-lines);
-  }
-
-  async restart(agentId) {
-    const agent = this.agents.get(agentId);
-    if (!agent) throw new Error(`Agent not found: ${agentId}`);
-    await agent.stop();
-    await agent.start();
-    this.save();
-  }
-
-  save() {
-    try {
-      const dir = dirname(paths.agents);
-      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-      const data = Array.from(this.agents.values()).map(a => ({
-        type: a.type, config: a.config, id: a.id, name: a.name, status: a.status
-      }));
-      writeFileSync(paths.agents, JSON.stringify(data, null, 2));
-    } catch {}
-  }
-
-  async restore() {
-    try {
-      if (!existsSync(paths.agents)) return;
-      const data = JSON.parse(readFileSync(paths.agents, 'utf8'));
-      for (const item of data) {
-        const AgentClass = AGENT_MAP[item.type];
-        if (AgentClass && item.status === 'running') {
-          const agent = new AgentClass(item.config);
-          this.agents.set(agent.id, agent);
-          await agent.start();
-        }
-      }
-    } catch {}
-  }
-
-  showStatus() {
-    const list = this.list();
-    if (list.length === 0) {
-      blocks.info('Agents', 'No agents running.');
-      return;
-    }
-    const headers = ['ID', 'Name', 'Type', 'Status', 'Logs'];
-    const rows = list.map(a => [
-      a.id.slice(0, 12),
-      a.name,
-      a.type,
-      statusBadge(a.status),
-      String(a.logCount),
-    ]);
-    blocks.table(headers, rows);
-  }
-}
-
-function statusBadge(status) {
-  switch (status) {
-    case 'running': return '● running';
-    case 'error': return '✗ error';
-    case 'idle': return '○ idle';
-    default: return '– stopped';
-  }
-}
-
-const agentManager = new AgentManager();
-export default agentManager;