clarity-ai 1.0.0

package/src/providers/openrouter.js

@@ -0,0 +1,52 @@
+const PROVIDER = {
+  name: 'openrouter',
+  free: true,
+  streaming: true,
+  models: ['meta-llama/llama-3.1-8b-instruct:free', 'google/gemma-2-9b-it:free', 'mistralai/mistral-7b-instruct:free'],
+  baseURL: 'https://openrouter.ai/api/v1',
+};
+
+async function* sendMessage(apiKey, messages, model = 'meta-llama/llama-3.1-8b-instruct:free', stream = true) {
+  const url = `${PROVIDER.baseURL}/chat/completions`;
+  const body = { model, messages, stream };
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json', 'HTTP-Referer': 'https://clarity-ai.local', 'X-Title': 'CLARITY AI' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) throw new Error(`OpenRouter API error: ${res.status} ${res.statusText}`);
+
+  if (!stream) {
+    const data = await res.json();
+    yield data.choices[0].message.content;
+    return;
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+    
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') return;
+        try {
+          const json = JSON.parse(data);
+          const delta = json.choices?.[0]?.delta?.content;
+          if (delta) yield delta;
+        } catch {}
+      }
+    }
+  }
+}
+
+export { PROVIDER, sendMessage };

package/src/tools/bash.js

@@ -0,0 +1,25 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const DANGEROUS = ['rm -rf', 'sudo ', 'dd if=', 'mkfs.', ':(){ :|:& };:'];
+
+async function execute(args) {
+  const command = args.command || args;
+  if (typeof command !== 'string') throw new Error('Command must be a string');
+
+  const isDangerous = DANGEROUS.some(d => command.includes(d));
+  if (isDangerous) {
+    return { stdout: '', stderr: '', exitCode: -1, duration: 0, warning: 'Potentially dangerous command blocked' };
+  }
+
+  const start = Date.now();
+  try {
+    const { stdout, stderr } = await execAsync(command, { timeout: 30000 });
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0, duration: Date.now() - start };
+  } catch (err) {
+    return { stdout: err.stdout?.trim() || '', stderr: err.stderr?.trim() || err.message, exitCode: err.code || 1, duration: Date.now() - start };
+  }
+}
+
+export { execute };

package/src/tools/code.js

@@ -0,0 +1,52 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFileSync, unlinkSync, mkdtempSync } from 'fs';
+import { resolve } from 'path';
+
+const execAsync = promisify(exec);
+
+async function execute(args) {
+  const code = args.code || args;
+  const language = args.language || 'javascript';
+  const start = Date.now();
+
+  try {
+    if (language === 'javascript' || language === 'js') {
+      const result = await evalCode(code);
+      return { output: result, error: null, duration: Date.now() - start, language };
+    } else if (language === 'python' || language === 'py') {
+      const tmpDir = mkdtempSync('/tmp/clarity_');
+      const tmpFile = resolve(tmpDir, 'script.py');
+      writeFileSync(tmpFile, code);
+      try {
+        const { stdout, stderr } = await execAsync(`python3 "${tmpFile}"`, { timeout: 15000 });
+        return { output: stdout.trim(), error: stderr.trim() || null, duration: Date.now() - start, language };
+      } finally {
+        try { unlinkSync(tmpFile); } catch {}
+      }
+    } else if (language === 'bash' || language === 'sh') {
+      const tmpDir = mkdtempSync('/tmp/clarity_');
+      const tmpFile = resolve(tmpDir, 'script.sh');
+      writeFileSync(tmpFile, code);
+      try {
+        const { stdout, stderr } = await execAsync(`bash "${tmpFile}"`, { timeout: 15000 });
+        return { output: stdout.trim(), error: stderr.trim() || null, duration: Date.now() - start, language };
+      } finally {
+        try { unlinkSync(tmpFile); } catch {}
+      }
+    } else {
+      throw new Error(`Unsupported language: ${language}`);
+    }
+  } catch (err) {
+    return { output: null, error: err.message, duration: Date.now() - start, language };
+  }
+}
+
+async function evalCode(code) {
+  const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+  const fn = new AsyncFunction('"use strict"; ' + code);
+  const result = await fn();
+  return result !== undefined ? String(result) : 'undefined';
+}
+
+export { execute };

package/src/tools/files.js

@@ -0,0 +1,62 @@
+import { promises as fs } from 'fs';
+import { resolve, dirname, basename } from 'path';
+import { glob } from 'glob';
+
+async function create(args) {
+  const filePath = resolve(args.path);
+  const content = args.content || '';
+  await fs.mkdir(dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content, 'utf8');
+  return { success: true, path: filePath, size: content.length };
+}
+
+async function read(args) {
+  const filePath = resolve(args.path);
+  const content = await fs.readFile(filePath, 'utf8');
+  const stat = await fs.stat(filePath);
+  return { content, size: content.length, lines: content.split('\n').length, modified: stat.mtime };
+}
+
+async function del(args) {
+  const filePath = resolve(args.path);
+  await fs.unlink(filePath);
+  return { success: true, path: filePath };
+}
+
+async function list(args) {
+  const dir = resolve(args.path || '.');
+  const pattern = args.pattern || '*';
+  const files = await glob(pattern, { cwd: dir, nodir: false });
+  const details = await Promise.all(files.map(async (f) => {
+    try {
+      const stat = await fs.stat(resolve(dir, f));
+      return { name: f, size: stat.size, isDir: stat.isDirectory(), modified: stat.mtime };
+    } catch { return { name: f, size: 0, isDir: false }; }
+  }));
+  return { directory: dir, files: details };
+}
+
+async function copy(args) {
+  const src = resolve(args.source);
+  const dest = resolve(args.destination);
+  await fs.mkdir(dirname(dest), { recursive: true });
+  await fs.copyFile(src, dest);
+  return { success: true, source: src, destination: dest };
+}
+
+async function move(args) {
+  const src = resolve(args.source);
+  const dest = resolve(args.destination);
+  await fs.mkdir(dirname(dest), { recursive: true });
+  await fs.rename(src, dest);
+  return { success: true, source: src, destination: dest };
+}
+
+async function stat(args) {
+  const filePath = resolve(args.path);
+  const s = await fs.stat(filePath);
+  return { path: filePath, size: s.size, isDir: s.isDirectory(), isFile: s.isFile(), modified: s.mtime, created: s.birthtime, mode: s.mode };
+}
+
+const tools = { create, read, delete: del, list, copy, move, stat };
+export default tools;

package/src/tools/git.js

@@ -0,0 +1,67 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function execute(args) {
+  const action = args.action || args;
+  const repo = args.repo || '';
+  const message = args.message || 'update';
+
+  if (typeof action === 'string') {
+    let cmd = '';
+    switch (action) {
+      case 'status': cmd = 'git status'; break;
+      case 'diff': cmd = 'git diff'; break;
+      case 'log': cmd = 'git log --oneline -10'; break;
+      case 'branch': cmd = 'git branch -a'; break;
+      default: cmd = `git ${action}`;
+    }
+    const start = Date.now();
+    try {
+      const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
+      return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0, duration: Date.now() - start };
+    } catch (err) {
+      return { stdout: '', stderr: err.message, exitCode: 1, duration: Date.now() - start };
+    }
+  }
+
+  const start = Date.now();
+  try {
+    let result;
+    switch (action) {
+      case 'add': {
+        const { stdout, stderr } = await execAsync('git add -A', { timeout: 10000 });
+        result = { stdout, stderr };
+        break;
+      }
+      case 'commit': {
+        const { stdout, stderr } = await execAsync(`git commit -m "${message}"`, { timeout: 10000 });
+        result = { stdout, stderr };
+        break;
+      }
+      case 'push': {
+        const { stdout, stderr } = await execAsync('git push', { timeout: 60000 });
+        result = { stdout, stderr };
+        break;
+      }
+      case 'pull': {
+        const { stdout, stderr } = await execAsync('git pull', { timeout: 60000 });
+        result = { stdout, stderr };
+        break;
+      }
+      case 'clone': {
+        const { stdout, stderr } = await execAsync(`git clone ${repo}`, { timeout: 120000 });
+        result = { stdout, stderr };
+        break;
+      }
+      default:
+        throw new Error(`Unknown git action: ${action}`);
+    }
+    return { ...result, exitCode: 0, duration: Date.now() - start };
+  } catch (err) {
+    return { stdout: '', stderr: err.message, exitCode: 1, duration: Date.now() - start };
+  }
+}
+
+export { execute };

package/src/tools/index.js

@@ -0,0 +1,40 @@
+import * as bash from './bash.js';
+import files from './files.js';
+import * as web from './web.js';
+import * as search from './search.js';
+import * as code from './code.js';
+import * as git from './git.js';
+import * as pkg from './pkg.js';
+import * as system from './system.js';
+
+const toolRegistry = {
+  bash: { name: 'bash', description: 'Execute shell commands', category: 'shell', execute: bash.execute, schema: { command: 'string' } },
+  files: { name: 'files', description: 'File operations (create/read/delete/list/copy/move/stat)', category: 'file', execute: (args) => {
+    const op = args.operation || 'list';
+    return files[op] ? files[op](args) : files.list(args);
+  }, schema: { operation: 'string', path: 'string' } },
+  web: { name: 'web', description: 'Fetch and display web pages', category: 'web', execute: web.execute, schema: { url: 'string' } },
+  search: { name: 'search', description: 'Search the web via DuckDuckGo', category: 'web', execute: search.execute, schema: { query: 'string' } },
+  code: { name: 'code', description: 'Execute code (js/python/bash)', category: 'code', execute: code.execute, schema: { code: 'string', language: 'string' } },
+  git: { name: 'git', description: 'Git operations', category: 'git', execute: git.execute, schema: { action: 'string', repo: 'string', message: 'string' } },
+  pkg: { name: 'pkg', description: 'Package manager (npm/pip/pkg)', category: 'system', execute: pkg.execute, schema: { action: 'string', name: 'string', manager: 'string' } },
+  system: { name: 'system', description: 'System information', category: 'system', execute: system.execute, schema: {} },
+};
+
+function getTool(name) {
+  return toolRegistry[name] || null;
+}
+
+function listTools() {
+  return Object.entries(toolRegistry).map(([name, t]) => ({
+    name, description: t.description, category: t.category
+  }));
+}
+
+async function runTool(name, args) {
+  const tool = toolRegistry[name];
+  if (!tool) throw new Error(`Unknown tool: ${name}`);
+  return await tool.execute(args);
+}
+
+export { getTool, listTools, runTool, toolRegistry };

package/src/tools/pkg.js

@@ -0,0 +1,46 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { isTermux } from '../utils/termux.js';
+
+const execAsync = promisify(exec);
+
+async function execute(args) {
+  const action = args.action || args;
+  const name = args.name || args.package || '';
+  const manager = args.manager || (isTermux() ? 'pkg' : 'npm');
+  const start = Date.now();
+
+  try {
+    let cmd;
+    if (manager === 'npm') {
+      switch (action) {
+        case 'install': cmd = `npm install ${name}`; break;
+        case 'remove': cmd = `npm uninstall ${name}`; break;
+        case 'search': cmd = `npm search ${name}`; break;
+        case 'list': cmd = 'npm list --depth=0'; break;
+        default: throw new Error(`Unknown action: ${action}`);
+      }
+    } else if (manager === 'pip') {
+      switch (action) {
+        case 'install': cmd = `pip install ${name}`; break;
+        case 'remove': cmd = `pip uninstall -y ${name}`; break;
+        case 'search': cmd = `pip search ${name}`; break;
+        case 'list': cmd = 'pip list'; break;
+        default: throw new Error(`Unknown action: ${action}`);
+      }
+    } else if (manager === 'pkg' && isTermux()) {
+      switch (action) {
+        case 'install': cmd = `pkg install -y ${name}`; break;
+        case 'remove': cmd = `pkg uninstall -y ${name}`; break;
+        default: throw new Error(`Unknown action: ${action}`);
+      }
+    }
+
+    const { stdout, stderr } = await execAsync(cmd, { timeout: 120000 });
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0, duration: Date.now() - start, manager };
+  } catch (err) {
+    return { stdout: '', stderr: err.message, exitCode: 1, duration: Date.now() - start, manager };
+  }
+}
+
+export { execute };

package/src/tools/search.js

@@ -0,0 +1,29 @@
+async function execute(args) {
+  const query = args.query || args;
+  if (typeof query !== 'string') throw new Error('Query must be a string');
+
+  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: data.AbstractSource || 'Result', url: data.AbstractURL || '', snippet: data.AbstractText });
+  }
+  if (data.RelatedTopics) {
+    for (const topic of data.RelatedTopics.slice(0, 8)) {
+      if (topic.Text) {
+        results.push({ title: topic.Text.split(' - ')[0], url: topic.FirstURL || '', snippet: topic.Text });
+      }
+      if (topic.Topics) {
+        topic.Topics.slice(0, 3).forEach(t => {
+          if (t.Text) results.push({ title: t.Text.split(' - ')[0], url: t.FirstURL || '', snippet: t.Text });
+        });
+      }
+    }
+  }
+
+  return { query, results, total: results.length };
+}
+
+export { execute };

package/src/tools/system.js

@@ -0,0 +1,29 @@
+import os from 'os';
+
+async function execute() {
+  const mem = process.memoryUsage();
+  return {
+    node: process.version,
+    platform: os.platform(),
+    arch: os.arch(),
+    release: os.release(),
+    hostname: os.hostname(),
+    cwd: process.cwd(),
+    memory: {
+      total: Math.round(os.totalmem() / 1024 / 1024) + 'MB',
+      free: Math.round(os.freemem() / 1024 / 1024) + 'MB',
+      heapUsed: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
+      heapTotal: Math.round(mem.heapTotal / 1024 / 1024) + 'MB',
+    },
+    cpu: {
+      model: os.cpus()[0]?.model || 'unknown',
+      cores: os.cpus().length,
+      loadAvg: os.loadavg().map(l => l.toFixed(2)),
+    },
+    uptime: Math.round(os.uptime() / 3600) + 'h',
+    pid: process.pid,
+    env: Object.keys(process.env).length + ' variables',
+  };
+}
+
+export { execute };

package/src/tools/web.js

@@ -0,0 +1,24 @@
+async function execute(args) {
+  const url = args.url || args;
+  if (typeof url !== 'string') throw new Error('URL must be a string');
+
+  const start = Date.now();
+  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();
+
+  return {
+    status: res.status,
+    headers: Object.fromEntries(res.headers),
+    body: clean.slice(0, 2000),
+    duration: Date.now() - start,
+    url,
+    size: text.length,
+  };
+}
+
+export { execute };

package/src/ui/banner.js

@@ -0,0 +1,15 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+import c from './colors.js';
+
+const GRADIENT = gradient(['#00d2ff', '#7b2ff7']);
+
+function renderBanner() {
+  const text = figlet.textSync('CLARITY', { font: 'ANSI Shadow' });
+  console.log(GRADIENT(text));
+  console.log(c.muted('AI Agent CLI — v1.0.0  ⚡ Termux Ready'));
+  console.log(c.muted('─'.repeat(process.stdout.columns || 80)));
+  console.log();
+}
+
+export default renderBanner;

package/src/ui/blocks.js

@@ -0,0 +1,55 @@
+import boxen from 'boxen';
+import cliTable3 from 'cli-table3';
+import c from './colors.js';
+
+const blocks = {
+  info(title, message) {
+    console.log(boxen(message, { padding: 1, borderColor: '#44aaff', borderStyle: 'round', title: ` ℹ ${title} `, titleAlignment: 'left' }));
+  },
+  success(title, message) {
+    console.log(boxen(message, { padding: 1, borderColor: '#00ff88', borderStyle: 'round', title: ` ✓ ${title} `, titleAlignment: 'left' }));
+  },
+  warn(title, message) {
+    console.log(boxen(message, { padding: 1, borderColor: '#ffcc00', borderStyle: 'round', title: ` ⚠ ${title} `, titleAlignment: 'left' }));
+  },
+  error(title, message) {
+    console.log(boxen(message, { padding: 1, borderColor: '#ff4466', borderStyle: 'round', title: ` ✗ ${title} `, titleAlignment: 'left' }));
+  },
+  code(language, code) {
+    console.log(`\n${c.muted('```' + language)}`);
+    console.log(c.code(code));
+    console.log(`${c.muted('```')}\n`);
+  },
+  file(path, content) {
+    console.log(boxen(c.filename(path) + '\n\n' + content, { padding: 1, borderColor: '#ffcc66', borderStyle: 'single' }));
+  },
+  ai(message) {
+    console.log(boxen(c.ai(message), { padding: 1, borderColor: '#7b2ff7', borderStyle: 'double' }));
+  },
+  user(message) {
+    console.log(boxen(c.user(message), { padding: 1, borderColor: '#00d2ff', borderStyle: 'single' }));
+  },
+  table(headers, rows) {
+    const t = new cliTable3({ head: headers.map(h => c.primary(h)), style: { border: ['#555577'] } });
+    rows.forEach(r => t.push(r));
+    console.log(t.toString());
+  },
+  divider(label) {
+    const width = process.stdout.columns || 80;
+    const side = Math.floor((width - (label ? label.length + 4 : 0)) / 2);
+    console.log(c.muted('─'.repeat(side) + (label ? ` ${label} ` : '') + '─'.repeat(side)));
+  },
+  badge(text, color = 'cyan') {
+    const colors = { cyan: c.primary, purple: c.accent, green: c.success, yellow: c.warning, red: c.error };
+    return (colors[color] || c.primary)(`[${text}]`);
+  },
+  progress(label, pct) {
+    const width = 20;
+    const filled = Math.round(width * pct / 100);
+    const empty = width - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    console.log(`${c.muted(label)} ${c.primary(bar)} ${c.white(String(pct))}%`);
+  }
+};
+
+export default blocks;

package/src/ui/chatbox.js

@@ -0,0 +1,126 @@
+import readline from 'readline';
+import c from './colors.js';
+import renderBanner from './banner.js';
+import settings from '../config/settings.js';
+import { hasAnyKeys } from '../config/keys.js';
+import { getKey, PROVIDER_NAMES } from '../config/keys.js';
+import { sendMessage } from '../providers/index.js';
+import { createPrompt, addToHistory, loadHistory } from './prompt.js';
+import blocks from './blocks.js';
+import spin from './spinner.js';
+import { renderMarkdown } from '../utils/markdown.js';
+import commandRegistry from '../commands/index.js';
+import memory from '../memory/store.js';
+
+let rl = null;
+let conversation = [];
+
+function getHeader() {
+  const model = settings.get('defaultModel') || 'groq/llama3-70b-8192';
+  const width = process.stdout.columns || 80;
+  const header = ` CLARITY CHAT ──────── Model: ${model} ── /help for commands `;
+  return c.primary('┌─') + c.muted(header.padEnd(width - 4, '─')) + c.primary('┐');
+}
+
+function startChat() {
+  if (!hasAnyKeys()) {
+    blocks.warn('No API Keys', 'Run /init to configure API keys first.');
+    return;
+  }
+
+  loadHistory();
+  console.clear();
+  renderBanner();
+  console.log(getHeader());
+  console.log();
+
+  rl = createPrompt();
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    addToHistory(input);
+
+    if (input.startsWith('/')) {
+      const result = await commandRegistry.execute(input, { rl, conversation });
+      if (result?.exit) { closeChat(); return; }
+    } else {
+      conversation.push({ role: 'user', content: input });
+      blocks.user(input);
+      await handleAIResponse();
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    console.log(c.muted('\nGoodbye!'));
+    process.exit(0);
+  });
+
+  rl.on('SIGINT', () => {
+    console.log(c.muted('\nUse /exit to quit'));
+    rl.prompt();
+  });
+}
+
+async function handleAIResponse() {
+  const model = settings.get('defaultModel') || 'groq/llama3-70b-8192';
+  const [provider] = model.split('/');
+  const apiKey = getKey(provider);
+
+  if (!apiKey) {
+    blocks.error('Key Missing', `No API key for ${PROVIDER_NAMES[provider] || provider}`);
+    return;
+  }
+
+  const ctx = memory.getContext();
+  const messages = [...ctx, ...conversation];
+
+  spin.start('CLARITY is thinking...');
+
+  try {
+    const stream = sendMessage(apiKey, messages, model, settings.get('stream'));
+
+    if (settings.get('stream')) {
+      spin.stop();
+      process.stdout.write(c.ai('CLARITY ▸ '));
+      let full = '';
+      for await (const chunk of stream) {
+        full += chunk;
+        process.stdout.write(c.white(chunk));
+      }
+      process.stdout.write('\n\n');
+      conversation.push({ role: 'assistant', content: full });
+      memory.add(conversation);
+    } else {
+      let full = '';
+      for await (const chunk of stream) {
+        full += chunk;
+      }
+      spin.stop();
+      const rendered = renderMarkdown(full);
+      blocks.ai(rendered);
+      conversation.push({ role: 'assistant', content: full });
+      memory.add(conversation);
+    }
+
+    if (settings.get('showTokens')) {
+      const inTokens = Math.ceil(conversation.reduce((s, m) => s + m.content.length, 0) / 4);
+      const outTokens = Math.ceil(conversation.filter(m => m.role === 'assistant').reduce((s, m) => s + m.content.length, 0) / 4);
+      console.log(c.muted(`[tokens: ${inTokens} in / ${outTokens} out | cost: free]`));
+    }
+  } catch (err) {
+    spin.fail('Error');
+    blocks.error('AI Error', err.message);
+  }
+}
+
+function closeChat() {
+  if (rl) rl.close();
+  console.log(c.muted('\nThank you for using CLARITY!'));
+  process.exit(0);
+}
+
+export { startChat, closeChat, conversation };

package/src/ui/colors.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+export const c = {
+  primary: chalk.hex('#00d2ff'),
+  accent: chalk.hex('#7b2ff7'),
+  success: chalk.hex('#00ff88'),
+  warning: chalk.hex('#ffcc00'),
+  error: chalk.hex('#ff4466'),
+  info: chalk.hex('#00aaff'),
+  muted: chalk.hex('#666888'),
+  white: chalk.hex('#f0f0ff'),
+  user: chalk.hex('#00d2ff').bold,
+  ai: chalk.hex('#bb88ff').bold,
+  system: chalk.hex('#888888').italic,
+  code: chalk.hex('#aaffcc'),
+  filename: chalk.hex('#ffcc66').underline,
+  cmd: chalk.hex('#ff8844').bold,
+  bgError: chalk.bgHex('#3d0010').hex('#ff4466'),
+  bgSuccess: chalk.bgHex('#003d1a').hex('#00ff88'),
+  bgInfo: chalk.bgHex('#001a3d').hex('#00aaff'),
+  bgWarn: chalk.bgHex('#3d3000').hex('#ffcc00'),
+};
+export default c;