clarity-ai 1.0.0

package/src/commands/index.js

@@ -0,0 +1,725 @@
+import blocks from '../ui/blocks.js';
+import c from '../ui/colors.js';
+import settings from '../config/settings.js';
+import { setKey, getKey, listKeys, removeKey, testKey, hasAnyKeys, PROVIDER_NAMES } from '../config/keys.js';
+import { listModels, capabilities, getPriorityProviders } from '../providers/index.js';
+import agentManager from '../agents/manager.js';
+import { listTools, runTool } from '../tools/index.js';
+import memory from '../memory/store.js';
+import { isTermux, openURL } from '../utils/termux.js';
+import { renderMarkdown } from '../utils/markdown.js';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { resolve, dirname, basename, extname, join } from 'path';
+import readline from 'readline';
+
+const commandRegistry = {
+  async execute(input, context = {}) {
+    const parts = input.trim().split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    const fullInput = input.trim().slice(cmd.length).trim();
+
+    try {
+      switch (cmd) {
+        case '/help': return this.help(args);
+        case '/init': return this.init();
+        case '/chat': return this.chat();
+        case '/ask': return this.ask(args);
+        case '/clear': return this.clear();
+        case '/exit': return this.exit();
+
+        case '/keys': return this.keys(args);
+        case '/model': return this.model(args);
+        case '/config': return this.config(args);
+        case '/theme': return this.theme(args);
+
+        case '/file': return this.file(args);
+        case '/bash': return this.bash(args);
+        case '/code': return this.code(args);
+        case '/web': return this.web(args);
+        case '/search': return this.search(args);
+        case '/git': return this.git(args);
+        case '/pkg': return this.pkg(args);
+
+        case '/agent': return this.agent(args);
+        case '/tools': return this.tools(args);
+
+        case '/memory': return this.memory(args);
+        case '/history': return this.history(args);
+
+        case '/env': return this.env(args);
+        case '/status': return this.status();
+        case '/version': return this.version();
+
+        case '/translate': args.length ? blocks.ai(`Translation of "${args.join(' ')}": [AI translation unavailable - configure API keys]`) : blocks.warn('Usage', '/translate <text>');
+        case '/summarize': return args.length ? this.summarize(args[0]) : blocks.warn('Usage', '/summarize <file|url>');
+        case '/generate': return args.length ? this.generate(args) : blocks.warn('Usage', '/generate <type>');
+        case '/export': return args.length ? this.exportChat(args[0]) : blocks.warn('Usage', '/export <json|md|txt>');
+        case '/import': return args.length ? this.importChat(args[0]) : blocks.warn('Usage', '/import <file>');
+        case '/alias': return this.alias(args);
+        case '/plugin': return this.plugin(args);
+        case '/update': return this.update();
+        case '/debug': return args.length ? this.debug(args[0]) : blocks.warn('Usage', '/debug <file>');
+        case '/review': return args.length ? this.review(args[0]) : blocks.warn('Usage', '/review <file>');
+        case '/refactor': return args.length ? this.refactor(args[0]) : blocks.warn('Usage', '/refactor <file>');
+        case '/test': return args.length ? this.test(args[0]) : blocks.warn('Usage', '/test <file>');
+        case '/docs': return args.length ? this.docs(args[0]) : blocks.warn('Usage', '/docs <file>');
+        case '/deploy': return args.length ? this.deploy(args[0]) : blocks.warn('Usage', '/deploy <target>');
+        case '/explain': return args.length ? this.explain(args[0]) : blocks.warn('Usage', '/explain <code or file>');
+        case '/run': blocks.info('Run', 'Use /bash <command> to run shell commands');
+        default:
+          blocks.warn('Unknown Command', `Unknown command: ${cmd}. Type /help for available commands.`);
+      }
+    } catch (err) {
+      blocks.error('Command Error', err.message);
+    }
+    return null;
+  },
+
+  async init() {
+    const { default: inquirer } = await import('inquirer');
+    blocks.divider('CLARITY Setup');
+    blocks.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 — 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 } = 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, key);
+        blocks.success(p, `Key saved for ${PROVIDER_NAMES[p] || p}`);
+      } catch (err) {
+        blocks.error(p, err.message);
+      }
+    }
+
+    const configured = Object.keys(listKeys());
+    if (configured.length > 0) {
+      const defaultProvider = getPriorityProviders(configured)[0] || configured[0];
+      const models = listModels(defaultProvider);
+      const { model } = 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', model);
+
+      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);
+    }
+
+    blocks.success('Setup Complete', 'CLARITY configured successfully!\nRun \'clarity\' to start chatting');
+  },
+
+  async help(args) {
+    if (args.length > 0) {
+      const topic = args[0].replace('/', '');
+      blocks.info(`Help: /${topic}`, `See /help for all available commands.`);
+      return;
+    }
+
+    const categories = {
+      'CHAT & AI': ['/chat', '/ask <q>', '/clear', '/history show|clear|export', '/memory show|add|clear'],
+      'CONFIGURATION': ['/init', '/keys set|list|remove|test', '/model set|list', '/config show|reset', '/theme set|list'],
+      'FILES': ['/file create|read|delete|list|edit', '/bash <command>', '/code run|write|explain|fix|review|refactor|test|docs'],
+      'WEB & SEARCH': ['/web <url>', '/search <query>', '/translate <text>', '/summarize <file|url>'],
+      'AGENTS & TOOLS': ['/agent start|stop|list|logs', '/tools list|run'],
+      'DEVELOPMENT': ['/git <action>', '/pkg install|remove|search', '/debug <file>', '/deploy <target>', '/generate <type>'],
+      'SYSTEM': ['/env show|set|clear', '/status', '/version', '/update', '/alias create|list|remove', '/plugin install|list|remove'],
+      'UTILITIES': ['/export <json|md|txt>', '/import <file>', '/run', '/help [command]', '/exit'],
+    };
+
+    console.log(c.primary('┌─ CLARITY COMMANDS ───────────────────────────────────────────────┐'));
+    for (const [cat, cmds] of Object.entries(categories)) {
+      console.log(c.muted(`  ${cat}`));
+      cmds.forEach(cmd => {
+        const [name, ...rest] = cmd.split(' ');
+        console.log(`  ${c.cmd(name)} ${c.muted(rest.join(' '))}`);
+      });
+      console.log();
+    }
+    console.log(c.primary('└──────────────────────────────────────────────────────────────────┘'));
+  },
+
+  ask(args) {
+    const question = args.join(' ');
+    if (!question) { blocks.warn('Usage', '/ask <question>'); return; }
+    blocks.user(question);
+    blocks.info('Ask', 'Configure API keys with /init first to get AI responses.');
+  },
+
+  chat() {
+    blocks.info('Chat', 'Already in chat mode. Type your message or use / commands.');
+  },
+
+  clear() {
+    console.clear();
+    blocks.success('Cleared', 'Screen and context cleared.');
+  },
+
+  exit() {
+    blocks.info('Goodbye', 'Thank you for using CLARITY!');
+    return { exit: true };
+  },
+
+  async keys(args) {
+    const sub = args[0];
+    if (!sub) {
+      blocks.warn('Usage', '/keys set|list|remove|test <provider> [key]');
+      return;
+    }
+
+    switch (sub) {
+      case 'set': {
+        if (args.length < 3) { blocks.warn('Usage', '/keys set <provider> <key>'); return; }
+        try {
+          setKey(args[1], args.slice(2).join(' '));
+          blocks.success('Key Saved', `${PROVIDER_NAMES[args[1]] || args[1]} API key configured.`);
+        } catch (err) { blocks.error('Error', err.message); }
+        break;
+      }
+      case 'list': {
+        const keys = listKeys();
+        if (Object.keys(keys).length === 0) { blocks.info('No Keys', 'No API keys configured. Run /init to set up.'); return; }
+        const rows = Object.entries(keys).map(([p, info]) => [PROVIDER_NAMES[p] || p, info.keyPreview]);
+        blocks.table(['Provider', 'Key'], rows);
+        break;
+      }
+      case 'remove': {
+        if (args.length < 2) { blocks.warn('Usage', '/keys remove <provider>'); return; }
+        removeKey(args[1]);
+        blocks.success('Removed', `${PROVIDER_NAMES[args[1]] || args[1]} key removed.`);
+        break;
+      }
+      case 'test': {
+        if (args.length < 2) { blocks.warn('Usage', '/keys test <provider>'); return; }
+        const result = await testKey(args[1]);
+        if (result.success) blocks.success('Key Valid', `${PROVIDER_NAMES[args[1]] || args[1]} key is working!`);
+        else blocks.error('Key Invalid', `${PROVIDER_NAMES[args[1]] || args[1]}: ${result.error}`);
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/keys set|list|remove|test <provider>');
+    }
+  },
+
+  async model(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/model list|set <provider/model>'); return; }
+
+    switch (sub) {
+      case 'list': {
+        const configured = Object.keys(listKeys());
+        if (configured.length === 0) { blocks.info('No Keys', 'Configure keys first with /init'); return; }
+        for (const p of configured) {
+          const models = listModels(p);
+          blocks.info(p, models.map(m => `${p}/${m}`).join('\n'));
+        }
+        break;
+      }
+      case 'set': {
+        if (args.length < 2) { blocks.warn('Usage', '/model set <provider/model>'); return; }
+        settings.set('defaultModel', args[1]);
+        blocks.success('Model Set', `Default model: ${args[1]}`);
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/model list|set <provider/model>');
+    }
+  },
+
+  config(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/config show|reset'); return; }
+
+    switch (sub) {
+      case 'show': {
+        const all = settings.store;
+        const rows = Object.entries(all).map(([k, v]) => [k, String(v)]);
+        blocks.table(['Setting', 'Value'], rows);
+        break;
+      }
+      case 'reset': {
+        settings.clear();
+        blocks.success('Reset', 'Settings reset to defaults.');
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/config show|reset');
+    }
+  },
+
+  theme(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/theme set|list'); return; }
+
+    switch (sub) {
+      case 'set': {
+        if (args.length < 2) { blocks.warn('Usage', '/theme set <name>'); return; }
+        settings.set('theme', args[1]);
+        blocks.success('Theme Set', `Theme: ${args[1]}`);
+        break;
+      }
+      case 'list': {
+        blocks.info('Themes', 'dark, light, neon, mono');
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/theme set|list');
+    }
+  },
+
+  async file(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/file create|read|delete|list|edit <path>'); return; }
+    const filePath = args.slice(1).join(' ');
+
+    switch (sub) {
+      case 'create': {
+        if (!filePath) { blocks.warn('Usage', '/file create <path>'); return; }
+        const fullPath = resolve(filePath);
+        await mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, '', 'utf8');
+        blocks.success('Created', c.filename(fullPath));
+        break;
+      }
+      case 'read': {
+        if (!filePath) { blocks.warn('Usage', '/file read <path>'); return; }
+        const fullPath = resolve(filePath);
+        if (!existsSync(fullPath)) { blocks.error('Not Found', `File not found: ${fullPath}`); return; }
+        const content = readFileSync(fullPath, 'utf8');
+        blocks.file(fullPath, content.slice(0, 2000) + (content.length > 2000 ? '\n... (truncated)' : ''));
+        break;
+      }
+      case 'delete': {
+        if (!filePath) { blocks.warn('Usage', '/file delete <path>'); return; }
+        const fullPath = resolve(filePath);
+        if (!existsSync(fullPath)) { blocks.error('Not Found', `File not found: ${fullPath}`); return; }
+        unlinkSync(fullPath);
+        blocks.warn('Deleted', c.filename(fullPath));
+        break;
+      }
+      case 'list': {
+        const dir = resolve(filePath || '.');
+        if (!existsSync(dir)) { blocks.error('Not Found', `Directory not found: ${dir}`); return; }
+        const items = readdirSync(dir);
+        const rows = items.map(name => {
+          const full = join(dir, name);
+          const isDir = statSync(full).isDirectory();
+          return [isDir ? c.primary(name + '/') : name, isDir ? 'dir' : 'file'];
+        });
+        blocks.table(['Name', 'Type'], rows);
+        break;
+      }
+      case 'edit': {
+        if (!filePath) { blocks.warn('Usage', '/file edit <path>'); return; }
+        const fullPath = resolve(filePath);
+        if (!existsSync(fullPath)) { blocks.error('Not Found', `File not found: ${fullPath}`); return; }
+        const editor = process.env.EDITOR || 'nano';
+        const { execSync } = await import('child_process');
+        execSync(`${editor} "${fullPath}"`, { stdio: 'inherit' });
+        blocks.success('Edited', c.filename(fullPath));
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/file create|read|delete|list|edit <path>');
+    }
+  },
+
+  async bash(args) {
+    if (args.length === 0) { blocks.warn('Usage', '/bash <command>'); return; }
+    const cmd = args.join(' ');
+    
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    
+    try {
+      blocks.info('Running', c.cmd(cmd));
+      const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
+      if (stdout) console.log(c.code(stdout));
+      if (stderr) console.log(c.warning(stderr));
+    } catch (err) {
+      if (err.stdout) console.log(c.code(err.stdout));
+      if (err.stderr) console.log(c.error(err.stderr));
+      if (!err.stdout && !err.stderr) blocks.error('Error', err.message);
+    }
+  },
+
+  async code(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/code run|write|explain|fix|review|refactor|test|docs <file>'); return; }
+    
+    if (sub === 'run') {
+      const filePath = args.slice(1).join(' ');
+      if (!filePath) { blocks.warn('Usage', '/code run <file>'); return; }
+      const fullPath = resolve(filePath);
+      if (!existsSync(fullPath)) { blocks.error('Not Found', `File not found: ${fullPath}`); return; }
+      const ext = extname(fullPath);
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execAsync = promisify(exec);
+      
+      try {
+        let cmd;
+        if (ext === '.js' || ext === '.mjs') cmd = `node "${fullPath}"`;
+        else if (ext === '.py') cmd = `python3 "${fullPath}"`;
+        else if (ext === '.sh') cmd = `bash "${fullPath}"`;
+        else cmd = `node "${fullPath}"`;
+        
+        blocks.info('Running', c.cmd(cmd));
+        const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
+        if (stdout) console.log(c.code(stdout));
+        if (stderr) blocks.warn('Stderr', stderr);
+      } catch (err) {
+        blocks.error('Error', err.message);
+      }
+    } else {
+      blocks.info('AI Feature', `/${sub} requires API key configuration. Run /init first.`);
+    }
+  },
+
+  async web(args) {
+    if (args.length === 0) { blocks.warn('Usage', '/web <url>'); return; }
+    const url = args[0];
+    try {
+      const res = await fetch(url);
+      const text = await res.text();
+      const clean = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                        .replace(/<[^>]+>/g, ' ')
+                        .replace(/\s+/g, ' ').trim();
+      blocks.info(url, `Status: ${res.status}\n${clean.slice(0, 1500)}`);
+    } catch (err) {
+      blocks.error('Fetch Error', err.message);
+    }
+  },
+
+  async search(args) {
+    if (args.length === 0) { blocks.warn('Usage', '/search <query>'); return; }
+    const query = args.join(' ');
+    try {
+      const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1`;
+      const res = await fetch(url);
+      const data = await res.json();
+      const results = [];
+      if (data.AbstractText) results.push({ title: 'Summary', snippet: data.AbstractText });
+      if (data.RelatedTopics) {
+        data.RelatedTopics.slice(0, 5).forEach(t => {
+          if (t.Text) results.push({ title: t.Text.split(' - ')[0], snippet: t.Text });
+        });
+      }
+      if (results.length === 0) { blocks.info('No Results', `No results for: ${query}`); return; }
+      results.forEach((r, i) => console.log(`${c.primary(String(i + 1))}. ${c.white(r.title)}\n   ${c.muted(r.snippet.slice(0, 200))}\n`));
+    } catch (err) {
+      blocks.error('Search Error', err.message);
+    }
+  },
+
+  async git(args) {
+    if (args.length === 0) { blocks.warn('Usage', '/git <action> [args]'); return; }
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    
+    try {
+      const cmd = 'git ' + args.join(' ');
+      const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
+      if (stdout) console.log(c.code(stdout.slice(0, 2000)));
+      if (stderr) console.log(c.warning(stderr.slice(0, 1000)));
+    } catch (err) {
+      blocks.error('Git Error', err.message);
+    }
+  },
+
+  async pkg(args) {
+    if (args.length < 2) { blocks.warn('Usage', '/pkg install|remove|search <name>'); return; }
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    
+    const action = args[0];
+    const name = args.slice(1).join(' ');
+    const mgr = isTermux() ? 'pkg' : 'npm';
+    
+    try {
+      blocks.info('Package', `${mgr} ${action} ${name}`);
+      let cmd;
+      if (mgr === 'pkg') cmd = `pkg ${action === 'remove' ? 'uninstall' : action} -y ${name}`;
+      else cmd = `npm ${action} ${name}`;
+      const { stdout, stderr } = await execAsync(cmd, { timeout: 120000 });
+      if (stdout) console.log(c.code(stdout.slice(0, 1000)));
+      if (stderr) blocks.warn('', stderr.slice(0, 500));
+    } catch (err) {
+      blocks.error('Error', err.message);
+    }
+  },
+
+  async agent(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/agent start|stop|list|logs <type|id> [config]'); return; }
+
+    switch (sub) {
+      case 'list': {
+        agentManager.showStatus();
+        break;
+      }
+      case 'start': {
+        if (args.length < 2) { blocks.warn('Usage', '/agent start <type> [config]'); return; }
+        const type = args[1];
+        const config = args[2] ? JSON.parse(args.slice(2).join(' ')) : {};
+        const id = await agentManager.start(type, config);
+        blocks.success('Agent Started', `ID: ${id}`);
+        break;
+      }
+      case 'stop': {
+        if (args.length < 2) { blocks.warn('Usage', '/agent stop <id>'); return; }
+        await agentManager.stop(args[1]);
+        blocks.success('Agent Stopped', `Agent ${args[1]} stopped.`);
+        break;
+      }
+      case 'logs': {
+        if (args.length < 2) { blocks.warn('Usage', '/agent logs <id> [lines]'); return; }
+        const lines = args[2] ? parseInt(args[2]) : 20;
+        const logs = agentManager.getLogs(args[1], lines);
+        if (logs.length === 0) { blocks.info('Logs', 'No logs.'); return; }
+        logs.forEach(l => console.log(c.muted(`[${l.time.slice(11, 19)}] [${l.level}]`) + ' ' + l.msg));
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/agent start|stop|list|logs');
+    }
+  },
+
+  tools(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/tools list|run <name> [args]'); return; }
+
+    switch (sub) {
+      case 'list': {
+        const tools = listTools();
+        const rows = tools.map(t => [t.name, t.category, t.description]);
+        blocks.table(['Name', 'Category', 'Description'], rows);
+        break;
+      }
+      case 'run': {
+        if (args.length < 2) { blocks.warn('Usage', '/tools run <name> [args]'); return; }
+        blocks.warn('Tools', 'Tool execution requires API integration.');
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/tools list|run');
+    }
+  },
+
+  memory(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/memory show|add|clear'); return; }
+
+    switch (sub) {
+      case 'show': {
+        const ctx = memory.show();
+        if (ctx.length === 0) { blocks.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) { blocks.warn('Usage', '/memory add <note>'); return; }
+        memory.addNote(note);
+        blocks.success('Memory Added', note);
+        break;
+      }
+      case 'clear': {
+        memory.clear();
+        blocks.success('Cleared', 'Memory cleared.');
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/memory show|add|clear');
+    }
+  },
+
+  history(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/history show|clear|export [n|file]'); return; }
+
+    switch (sub) {
+      case 'show': {
+        const n = args[1] ? parseInt(args[1]) : 20;
+        const ctx = memory.show();
+        const recent = ctx.slice(-n);
+        if (recent.length === 0) { blocks.info('History', 'No history.'); return; }
+        recent.forEach(m => console.log(`${c.muted(m.role)}: ${m.content.slice(0, 150)}`));
+        break;
+      }
+      case 'clear': {
+        memory.clear();
+        blocks.success('Cleared', 'History cleared.');
+        break;
+      }
+      case 'export': {
+        const file = args[1] || `clarity-chat-${Date.now()}.md`;
+        const fullPath = resolve(file);
+        const ctx = memory.show();
+        const md = ctx.map(m => `**${m.role}**: ${m.content}`).join('\n\n');
+        writeFileSync(fullPath, `# CLARITY Chat Export\n\n${md}`, 'utf8');
+        blocks.success('Exported', c.filename(fullPath));
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/history show|clear|export');
+    }
+  },
+
+  env(args) {
+    const sub = args[0];
+    if (!sub) { blocks.warn('Usage', '/env show|set|clear'); return; }
+
+    switch (sub) {
+      case 'show': {
+        const rows = Object.entries(process.env).slice(0, 30).map(([k, v]) => [k, String(v).slice(0, 60)]);
+        blocks.table(['Variable', 'Value'], rows);
+        break;
+      }
+      case 'set': {
+        if (args.length < 3) { blocks.warn('Usage', '/env set <KEY> <value>'); return; }
+        process.env[args[1]] = args.slice(2).join(' ');
+        blocks.success('Set', `${args[1]}=${args.slice(2).join(' ')}`);
+        break;
+      }
+      case 'clear': {
+        blocks.warn('Env', 'Cannot clear all env variables.');
+        break;
+      }
+      default:
+        blocks.warn('Usage', '/env show|set|clear');
+    }
+  },
+
+  status() {
+    const mem = process.memoryUsage();
+    const rows = [
+      ['CLARITY', 'v1.0.0'],
+      ['Node.js', process.version],
+      ['Platform', `${process.platform} ${process.arch}`],
+      ['Termux', isTermux() ? 'Yes' : 'No'],
+      ['CWD', process.cwd()],
+      ['Memory', `${Math.round(mem.heapUsed / 1024 / 1024)}MB / ${Math.round(mem.heapTotal / 1024 / 1024)}MB`],
+      ['Uptime', `${Math.round(process.uptime())}s`],
+    ];
+    const keys = listKeys();
+    Object.entries(PROVIDER_NAMES).forEach(([p, name]) => {
+      rows.push([name, keys[p] ? '✓ Configured' : '○ Not set']);
+    });
+    blocks.table(['Key', 'Value'], rows);
+  },
+
+  version() {
+    blocks.info('CLARITY v1.0.0', 'AI Agent CLI for Termux\nNode.js ' + process.version + '\n' + (isTermux() ? 'Termux mode: active' : 'Standard terminal'));
+  },
+
+  summarize(target) {
+    if (!target) { blocks.warn('Usage', '/summarize <file|url>'); return; }
+    blocks.warn('Summarize', 'AI feature. Configure API keys with /init.');
+  },
+
+  generate(args) {
+    if (args.length === 0) { blocks.warn('Usage', '/generate <type> (readme|gitignore|dockerfile)'); return; }
+    blocks.warn('Generate', 'AI feature. Configure API keys with /init.');
+  },
+
+  exportChat(format) {
+    if (!format) { blocks.warn('Usage', '/export <json|md|txt>'); return; }
+    const ctx = memory.show();
+    const file = `clarity-export-${Date.now()}.${format}`;
+    let content = '';
+    if (format === 'json') content = JSON.stringify(ctx, null, 2);
+    else if (format === 'md') content = ctx.map(m => `**${m.role}**: ${m.content}`).join('\n\n');
+    else content = ctx.map(m => `${m.role}: ${m.content}`).join('\n\n');
+    writeFileSync(resolve(file), content, 'utf8');
+    blocks.success('Exported', c.filename(resolve(file)));
+  },
+
+  importChat(file) {
+    if (!file) { blocks.warn('Usage', '/import <file>'); return; }
+    blocks.warn('Import', 'Import feature - read file and restore chat session.');
+  },
+
+  alias(args) {
+    if (!args[0]) { blocks.warn('Usage', '/alias create|list|remove <name> [cmd]'); return; }
+    blocks.warn('Alias', 'Alias feature not yet implemented.');
+  },
+
+  plugin(args) {
+    if (!args[0]) { blocks.warn('Usage', '/plugin install|list|remove <name>'); return; }
+    blocks.warn('Plugin', 'Plugin system not yet implemented.');
+  },
+
+  update() {
+    blocks.info('Update', 'Run: npm install -g clarity-ai@latest');
+  },
+
+  debug(file) {
+    if (!file) { blocks.warn('Usage', '/debug <file>'); return; }
+    const fullPath = resolve(file);
+    if (!existsSync(fullPath)) { blocks.error('Not Found', `File not found: ${fullPath}`); return; }
+    blocks.warn('Debug', 'AI-powered debugging. Configure API keys with /init.');
+  },
+
+  review(file) {
+    if (!file) { blocks.warn('Usage', '/review <file>'); return; }
+    blocks.warn('Review', 'AI-powered code review. Configure API keys with /init.');
+  },
+
+  refactor(file) {
+    if (!file) { blocks.warn('Usage', '/refactor <file>'); return; }
+    blocks.warn('Refactor', 'AI-powered refactoring. Configure API keys with /init.');
+  },
+
+  test(file) {
+    if (!file) { blocks.warn('Usage', '/test <file>'); return; }
+    blocks.warn('Test', 'AI-powered test generation. Configure API keys with /init.');
+  },
+
+  docs(file) {
+    if (!file) { blocks.warn('Usage', '/docs <file>'); return; }
+    blocks.warn('Docs', 'AI-powered documentation. Configure API keys with /init.');
+  },
+
+  deploy(target) {
+    if (!target) { blocks.warn('Usage', '/deploy <target>'); return; }
+    blocks.info('Deploy via', `npm publish`);
+  },
+
+  explain(codeOrFile) {
+    if (!codeOrFile) { blocks.warn('Usage', '/explain <code or file>'); return; }
+    blocks.warn('Explain', 'AI-powered explanation. Configure API keys with /init.');
+  },
+};
+
+export default commandRegistry;