clarity-ai 1.0.0

package/README.md

@@ -0,0 +1,108 @@
+# CLARITY — AI Agent CLI
+
+```
+ ██████╗██╗      █████╗ ██████╗ ██╗████████╗██╗   ██╗
+██╔════╝██║     ██╔══██╗██╔══██╗██║╚══██╔══╝╚██╗ ██╔╝
+██║     ██║     ███████║██████╔╝██║   ██║    ╚████╔╝ 
+██║     ██║     ██╔══██║██╔══██╗██║   ██║     ╚██╔╝  
+╚██████╗███████╗██║  ██║██║  ██║██║   ██║      ██║   
+ ╚═════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝   ╚═╝      ╚═╝   
+```
+
+AI agent CLI for Termux and terminal — chat, code, automate.
+
+## Install
+
+```bash
+npm install -g clarity-ai
+```
+
+### Termux Install
+
+```bash
+pkg update && pkg install nodejs-lts
+npm install -g clarity-ai
+clarity init
+```
+
+## Quick Start
+
+```bash
+# Interactive setup
+clarity init
+
+# Start chatting
+clarity
+
+# One-shot question
+clarity /ask "What is the weather?"
+
+# Run commands
+clarity /bash ls -la
+```
+
+## Commands
+
+### Chat & AI
+| Command | Description |
+|---|---|
+| `/chat` | Start interactive chat session |
+| `/ask <q>` | One-shot question |
+| `/clear` | Clear screen and conversation |
+| `/history show [n]` | Show last N messages |
+| `/memory show\|add\|clear` | AI memory management |
+
+### Configuration
+| Command | Description |
+|---|---|
+| `/init` | Interactive setup wizard |
+| `/keys set\|list\|remove\|test` | API key management |
+| `/model set\|list` | Switch AI model |
+| `/config show\|reset` | Settings management |
+| `/theme set\|list` | Color themes |
+
+### Files & Code
+| Command | Description |
+|---|---|
+| `/file create\|read\|delete\|list\|edit` | File operations |
+| `/bash <command>` | Execute shell commands |
+| `/code run\|write\|explain\|fix` | Code operations |
+| `/git <action>` | Git operations |
+
+### Web & Search
+| Command | Description |
+|---|---|
+| `/web <url>` | Fetch and display URL |
+| `/search <query>` | Web search |
+| `/translate <text>` | Translate text |
+| `/summarize <file\|url>` | Summarize content |
+
+### Agents & Tools
+| Command | Description |
+|---|---|
+| `/agent start\|stop\|list\|logs` | Background agents |
+| `/tools list\|run` | Tool management |
+
+### System
+| Command | Description |
+|---|---|
+| `/status` | System status |
+| `/version` | Version info |
+| `/env show\|set` | Environment variables |
+| `/help [command]` | Command help |
+| `/exit` | Exit CLARITY |
+
+## Provider Comparison
+
+| Provider | Free Tier | Streaming | Priority |
+|---|---|---|---|
+| Groq | ✓ | ✓ | 1 (fastest) |
+| Google Gemini | ✓ | ✓ | 2 |
+| DeepSeek | Cheap | ✓ | 3 |
+| OpenRouter | ✓ | ✓ | 4 |
+| OpenAI | Paid | ✓ | 5 |
+| Anthropic | Paid | ✓ | 6 |
+
+## License
+
+MIT

package/bin/clarity.js

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

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "clarity-ai",
+  "version": "1.0.0",
+  "description": "AI agent CLI for Termux and terminal — chat, code, automate",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "clarity": "bin/clarity.js"
+  },
+  "scripts": {
+    "start": "node bin/clarity.js",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12",
+    "node-fetch": "^3.3.2",
+    "conf": "^12.0.0",
+    "marked": "^12.0.0",
+    "marked-terminal": "^7.1.0",
+    "ora": "^8.0.1",
+    "boxen": "^7.1.1",
+    "figlet": "^1.7.0",
+    "gradient-string": "^2.0.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.5",
+    "axios": "^1.6.8",
+    "fs-extra": "^11.2.0",
+    "glob": "^10.3.12",
+    "open": "^10.1.0",
+    "update-notifier": "^7.0.0",
+    "semver": "^7.6.0",
+    "strip-ansi": "^7.1.0",
+    "wrap-ansi": "^9.0.0"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "termux",
+    "agent",
+    "clarity",
+    "chatgpt",
+    "gemini",
+    "groq"
+  ],
+  "license": "MIT"
+}

package/scripts/postinstall.js

@@ -0,0 +1,53 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import boxen from 'boxen';
+import chalk from 'chalk';
+
+const GRADIENT = gradient(['#00d2ff', '#7b2ff7']);
+
+try {
+  const text = figlet.textSync('CLARITY', { font: 'ANSI Shadow' });
+  console.log(GRADIENT(text));
+} catch {
+  console.log(GRADIENT('CLARITY'));
+}
+
+const nodeVersion = process.versions.node;
+const [major] = nodeVersion.split('.').map(Number);
+
+if (major < 18) {
+  console.log(boxen(
+    chalk.hex('#ff4466').bold(`Node.js 18+ required. You have v${nodeVersion}`) + '\n' +
+    chalk.hex('#ffcc00')('Termux: pkg install nodejs-lts'),
+    { padding: 1, borderColor: 'red', borderStyle: 'round' }
+  ));
+  process.exit(1);
+}
+
+const isTermux = process.env.PREFIX?.includes('com.termux');
+
+console.log(boxen(
+  chalk.hex('#00ff88').bold('CLARITY installed successfully!') + '\n' +
+  chalk.hex('#00d2ff')('Run: clarity init'),
+  { padding: 1, borderColor: 'green', borderStyle: 'round' }
+));
+
+console.log(chalk.hex('#666888')("Run 'clarity init' to configure your AI keys and get started."));
+
+const binDir = process.env.npm_config_prefix ? `${process.env.npm_config_prefix}/bin` : null;
+if (isTermux && binDir) {
+  const { existsSync, writeFileSync, chmodSync, unlinkSync } = await import('fs');
+  const { resolve } = await import('path');
+  const wrapperPath = resolve(binDir, 'clarity');
+  const targetPath = resolve(process.argv[1] || '.', '..', 'bin', 'clarity.js');
+
+  try {
+    const stat = await import('fs').then(fs => fs.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));
+    }
+  } catch {}
+}

package/src/agents/BaseAgent.js

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,116 @@
+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;