clarity-ai 3.0.1 → 3.0.2

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.0.2",
+  "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,85 @@
+import { callProvider } from '../providers/index.js';
+import { buildSystemPrompt } from '../core/context.js';
+import { addMessage } from '../core/history.js';
+
+const TOOLS_DESC = `You are CLARITY, an autonomous AI agent. You have access to these tools:
+- bash <command>: Execute shell commands
+- read_file <path>: Read file contents
+- write_file <path> <content>: Create/overwrite files
+- edit_file <path> <old> <new>: Replace text in files
+- delete_file <path>: Delete files
+- list_dir <dir>: List directory contents
+- search_files <pattern>: Find files by glob
+- grep <pattern> <path>: Search file contents
+- web_search <query>: Search the web
+- web_fetch <url>: Fetch URL content
+- git <subcommand>: Git operations
+- memory <read/write/search/clear>: Persistent memory
+- pkg_manager <npm/pip> <install> <pkg>: Install packages
+- code_runner <lang> <code>: Execute code snippets
+
+Respond with JSON:
+{"tool": "tool_name", "args": {"arg1": "val1"}}
+or to respond to user:
+{"response": "your final answer here"}`;
+
+export async function agentLoop(userMessage, config, history) {
+  const messages = [
+    { role: 'system', content: buildSystemPrompt(TOOLS_DESC) },
+    ...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;
+    }
+
+    try {
+      const jsonMatch = fullResponse.match(/\{[^]*\}/);
+      if (!jsonMatch) {
+        finalResponse = fullResponse;
+        break;
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      if (parsed.response) {
+        finalResponse = parsed.response;
+        break;
+      }
+
+      if (parsed.tool) {
+        toolCalls++;
+        const toolName = parsed.tool;
+        const args = parsed.args || {};
+
+        let result;
+        try {
+          const mod = await import(`../tools/${toolName}.js`);
+          const toolFn = Object.values(mod)[0];
+          result = await toolFn(args);
+        } catch (e) {
+          result = `Tool error: ${e.message}`;
+        }
+
+        messages.push({ role: 'assistant', content: fullResponse });
+        messages.push({ role: 'user', content: `Tool result: ${result}` });
+      }
+    } catch {
+      finalResponse = fullResponse;
+      break;
+    }
+  }
+
+  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);
+}

package/src/commands/config.js

@@ -1,146 +1,19 @@
-import blocks from '../blocks.js';
-import c from '../colors.js';
-import settings from '../config/settings.js';
-import { setKey, getKey, listKeys, removeKey, testKey, hasAnyKeys, PROVIDER_NAMES, PROVIDER_REGEX } from '../config/keys.js';
-import { listModels, getPriorityProviders } from '../providers/index.js';
-
-const { info, success, warn, error: errorBox, table, divider } = blocks;
-
-export async function keys(args, context) {
-  const sub = args[0];
-  if (!sub) { warn('Usage', '/keys set|list|remove|test <provider> [key]'); return; }
-
-  switch (sub) {
-    case 'set': {
-      if (args.length < 3) { warn('Usage', '/keys set <provider> <key>'); return; }
-      try {
-        setKey(args[1], args.slice(2).join(' '));
-        success('Key Saved', `${PROVIDER_NAMES[args[1]] || args[1]} API key configured.`);
-      } catch (err) { errorBox('Error', err.message); }
-      break;
-    }
-    case 'list': {
-      const k = listKeys();
-      if (Object.keys(k).length === 0) { info('No Keys', 'No API keys configured. Run /init to set up.'); return; }
-      const rows = Object.entries(k).map(([p, info]) => [PROVIDER_NAMES[p] || p, info.keyPreview]);
-      table(['Provider', 'Key'], rows);
-      break;
-    }
-    case 'remove': {
-      if (args.length < 2) { warn('Usage', '/keys remove <provider>'); return; }
-      removeKey(args[1]);
-      success('Removed', `${PROVIDER_NAMES[args[1]] || args[1]} key removed.`);
-      break;
-    }
-    case 'test': {
-      if (args.length < 2) { warn('Usage', '/keys test <provider>'); return; }
-      const result = await testKey(args[1]);
-      if (result.success) success('Key Valid', `${PROVIDER_NAMES[args[1]] || args[1]} key is working!`);
-      else errorBox('Key Invalid', `${PROVIDER_NAMES[args[1]] || args[1]}: ${result.error}`);
-      break;
-    }
-    default:
-      warn('Usage', '/keys set|list|remove|test');
-  }
-}
-
-export async function key(args, context) {
-  if (args.length < 2) { warn('Usage', '/key <provider> <key>'); return; }
-  try {
-    setKey(args[0], args.slice(1).join(' '));
-    success('Key Saved', `${PROVIDER_NAMES[args[0]] || args[0]} API key configured.`);
-  } catch (err) { errorBox('Error', err.message); }
-}
-
-export async function config(args, context) {
-  const sub = args[0];
-  if (!sub) { warn('Usage', '/config show|reset [key] [value]'); return; }
-
-  switch (sub) {
-    case 'show': {
-      const all = settings.store;
-      const rows = Object.entries(all).map(([k, v]) => [k, String(v)]);
-      table(['Setting', 'Value'], rows);
-      break;
-    }
-    case 'reset': {
-      settings.clear();
-      success('Reset', 'Settings reset to defaults.');
-      break;
-    }
-    default:
-      warn('Usage', '/config show|reset');
-  }
-}
-
-export async function set(args, context) {
-  if (args.length < 2) { warn('Usage', '/set <key> <value>'); return; }
-  const val = args.slice(1).join(' ');
-  const num = parseFloat(val);
-  settings.set(args[0], isNaN(num) ? val : num);
-  success('Set', `${args[0]} = ${settings.get(args[0])}`);
-}
-
-export async function reset(args, context) {
-  settings.clear();
-  success('Reset', 'All settings reset to defaults.');
-}
-
-export async function init(args, context) {
-  const { default: inquirer } = await import('inquirer');
-  divider('CLARITY Setup');
-  info('Welcome', "Let's configure your AI agent CLI\nPress Ctrl+C to cancel at any time.");
-
-  const { providers: selected } = await inquirer.prompt([{
-    type: 'checkbox',
-    name: 'providers',
-    message: 'Which AI providers do you want to configure?',
-    choices: [
-      { name: 'Groq (FREE \u2014 Recommended)', value: 'groq', checked: true },
-      { name: 'Google Gemini (FREE)', value: 'gemini', checked: true },
-      { name: 'OpenRouter (FREE models)', value: 'openrouter' },
-      { name: 'Anthropic Claude', value: 'anthropic' },
-      { name: 'OpenAI GPT', value: 'openai' },
-      { name: 'DeepSeek', value: 'deepseek' },
-    ]
-  }]);
-
-  for (const p of selected) {
-    const { key: apiKey } = await inquirer.prompt([{
-      type: 'password',
-      name: 'key',
-      message: `Enter your ${PROVIDER_NAMES[p] || p} API key:`,
-      validate: v => v.length > 0 || 'Key is required',
-    }]);
-    try {
-      setKey(p, apiKey);
-      success(p, `Key saved for ${PROVIDER_NAMES[p] || p}`);
-    } catch (err) {
-      errorBox(p, err.message);
+import { loadConfig, saveConfig } from '../config/settings.js';
+import { clr } from '../ui/colors.js';
+export async function configCommand(args, config) {
+  if (args.length === 0) {
+    const cfg = loadConfig();
+    for (const [key, val] of Object.entries(cfg || config)) {
+      if (key === 'apiKeys') continue;
+      console.log('  ' + clr.secondary(key) + ': ' + clr.dim(JSON.stringify(val)));
     }
+    return;
   }
-
-  const configured = Object.keys(listKeys());
-  if (configured.length > 0) {
-    const defaultProvider = getPriorityProviders(configured)[0] || configured[0];
-    const models = listModels(defaultProvider);
-    const { model: defaultModel } = await inquirer.prompt([{
-      type: 'list',
-      name: 'model',
-      message: 'Select your default model:',
-      choices: models.map(m => ({ name: `${defaultProvider}/${m}`, value: `${defaultProvider}/${m}` })),
-    }]);
-    settings.set('defaultModel', defaultModel);
-
-    const { stream, showTokens, saveHist } = await inquirer.prompt([
-      { type: 'confirm', name: 'stream', message: 'Stream responses?', default: true },
-      { type: 'confirm', name: 'showTokens', message: 'Show token usage?', default: true },
-      { type: 'confirm', name: 'saveHist', message: 'Save chat history?', default: true },
-    ]);
-    settings.set('stream', stream);
-    settings.set('showTokens', showTokens);
-    settings.set('saveHistory', saveHist);
+  if (args.length === 2) {
+    config[args[0]] = args[1];
+    saveConfig(config);
+    console.log(clr.success(args[0] + ' = ' + args[1]));
+    return config;
   }
-
-  success('Setup Complete', 'CLARITY configured successfully!\nRun \'clarity\' to start chatting');
+  console.log('  ' + clr.dim('Usage: /config [key] [value]'));
 }

package/src/commands/diff.js

@@ -0,0 +1,12 @@
+import { clr } from '../ui/colors.js';
+export async function diffCommand(args, config) {
+  const [f1, f2] = args;
+  if (!f1 || !f2) return console.log(clr.error('Usage: /diff <file1> <file2>'));
+  try {
+    const { diffTool } = await import('../tools/diff-tool.js');
+    const result = await diffTool({ file1: f1, file2: f2 });
+    console.log('\n' + result + '\n');
+  } catch (err) {
+    console.log(clr.error(`Diff error: ${err.message}`));
+  }
+}

package/src/commands/exit.js

@@ -0,0 +1,5 @@
+import { blocks } from '../ui/blocks.js';
+export async function exitCommand(args, config, rl) {
+  console.log('\n' + blocks.info('Session ended. Goodbye.', '◆ EXIT'));
+  process.exit(0);
+}