clarity-ai 3.0.2 → 3.2.0

package/CHANGELOG.md

@@ -0,0 +1,71 @@
+# Change Log
+
+---
+
+## 3.1.0 (2026-06-05)
+
+### UI Rewrite — OpenCode Style
+- **User messages**: Light purple background (`#2D1B4E`), `#C39BD3` text, `❯ YOU` header bar
+- **AI responses**: Left border only (`│`), no box, no background, `◆ CLARITY` header
+- **File edits**: OpenCode diff format — `✎ filename` bar + `+`/`-` lines with line numbers
+- **File writes**: `+ filename` header with line count written
+- **Tool calls**: Inline `⚙ toolname · input` with preview output (max 8 lines)
+- **Info/Error/Success/Warning**: Clean single-line renders with icons
+
+### System Prompt — Anti-Hallucination
+- Strict rules: NEVER fabricate content, NEVER confirm before acting
+- Always ground responses in actual tool output
+- Read files before editing, never overwrite unread files
+- Short, direct responses — no filler
+
+### Agent Loop — Inline Diff Display
+- `executeToolCall()` handles write_file, edit_file, bash, read_file natively
+- edit_file computes unified diff using `diff` package (`diffLines`)
+- `filterContextHunks()` shows ±2 context lines around changes
+- Dynamic fallback for other tools via `import()` from `tools/` directory
+
+---
+
+## 3.0.2 (2026-06-05)
+
+- Complete rebuild per CLARITY_V3_PROMPT.md spec
+- Removed all Ink+React code (15 files) — replaced with readline-based TUI
+- 25 tool modules in `src/tools/`, 20 command modules in `src/commands/`
+- 6 provider modules with streaming SSE parsing
+- ReAct agent loop with JSON-only tool call parsing
+- Figlet+gradient animated banner, first-run setup wizard
+
+---
+
+## 3.0.1 (2026-06-05)
+
+- Fixed JSX → createElement conversion in all Ink components
+- Fixed import errors and TTY check
+- Fixed Termux bin wrapper (symlink → bash script)
+
+---
+
+## 3.0.0 (2026-06-05)
+
+- Complete Ink+React TUI rewrite
+- 11 React components, global state with reducer
+- Parallel subagent spawning
+- 15 tools, 17 commands
+
+---
+
+## 2.0.0 (2026-06-04)
+
+- Figlet+gradient banner, 12 block types with timestamps
+- 22-token color palette
+- ReAct agent loop with JSON parsing and 3 retry attempts
+- 20 tools, first-run wizard, split commands
+
+---
+
+## 1.3.0 (2026-06-04)
+
+- Provider model lists updated to 2026
+- Interactive `/model` selector, `/provider` command
+- Grey-fill + purple-outline prompt bar
+- Tab completer on readline

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-ai",
-  "version": "3.0.2",
+  "version": "3.2.0",
   "description": "Autonomous AI Agent CLI for Termux",
   "type": "module",
   "bin": {

package/src/agents/loop.js

@@ -1,85 +1,296 @@
-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"}`;
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import chalk from 'chalk';
+import { Spinner, CollapsibleStep } from '../ui/spinner.js';
+import { renderAI, renderWrite, renderEdit, renderTool } from '../ui/blocks.js';
+import { callProvider, streamProvider } from '../providers/index.js';
+import { addMessage, saveHistory } from '../core/history.js';
+import { diffLines } from 'diff';
+
+const SYSTEM_PROMPT = 'You are CLARITY, an autonomous AI agent CLI running in Termux on Android.\n\n' +
+'## CRITICAL RULES\n' +
+'1. NEVER fabricate file contents or command outputs.\n' +
+'2. NEVER confirm before acting — just do it.\n' +
+'3. ALWAYS ground responses in actual tool output.\n' +
+'4. SHORT responses. No filler.\n' +
+'5. When editing files, read first then edit.\n\n' +
+'## RESPONSE FORMAT\n' +
+'Respond with JSON ONLY:\n' +
+'To use a tool: {"tool": "tool_name", "args": {"key": "value"}}\n' +
+'To answer: {"response": "your message"}\n\n' +
+'Available tools: bash, read_file, write_file, edit_file, list_directory, search_files, grep, web_search, web_fetch, git, memory, code_runner, pkg_manager';
+
+function detectIntent(message) {
+  const lower = message.toLowerCase().trim();
+  const chatPatterns = [
+    /^(hi|hello|hey|sup|yo|what'?s up|howdy)/,
+    /^(how are you|how do you|what are you|who are you|what can you)/,
+    /^(thanks|thank you|ok|okay|cool|nice|great|good|sure|yes|no|yep|nope)/,
+    /^(what is|what's|explain|tell me about|describe|define)/,
+    /^(can you|could you|would you|will you)\s+(explain|tell|describe|help me understand)/,
+  ];
+  for (const p of chatPatterns) {
+    if (p.test(lower)) return 'chat';
+  }
+  const toolPatterns = [
+    { re: /(create|make|mkdir|new)\s+(a\s+)?(dir|directory|folder)/, intent: 'bash' },
+    { re: /(create|make|write|generate)\s+(a\s+)?(file|script|code|program)/, intent: 'write_file' },
+    { re: /(run|execute|launch|start)\s+/, intent: 'bash' },
+    { re: /(edit|modify|change|update|fix)\s+(the\s+)?file/, intent: 'edit_file' },
+    { re: /(read|show|display|cat|open)\s+(the\s+)?file/, intent: 'read_file' },
+    { re: /(list|ls|show)\s+(files|dir|directory|folders)/, intent: 'list_directory' },
+    { re: /(search|find|grep|look for)/, intent: 'search' },
+    { re: /(install|npm|pip|pkg)\s+/, intent: 'bash' },
+    { re: /(git\s+)/, intent: 'git' },
+    { re: /(cd\s+|navigate to|go to)/, intent: 'bash' },
+  ];
+  for (const { re } of toolPatterns) {
+    if (re.test(lower)) return 'agent';
+  }
+  return 'chat';
+}
+
+async function executeTool(name, args) {
+  switch (name) {
+    case 'bash': {
+      try {
+        const out = execSync(args.command, {
+          encoding: 'utf-8', timeout: 30000,
+          cwd: process.env.HOME || '/data/data/com.termux/files/home',
+        });
+        return out.trim() || '(no output)';
+      } catch (e) {
+        return 'ERROR: ' + (e.stderr || e.message || String(e));
+      }
+    }
+    case 'read_file': {
+      if (!existsSync(args.path)) return 'ERROR: File not found: ' + args.path;
+      return readFileSync(args.path, 'utf-8');
+    }
+    case 'write_file': {
+      const dir = dirname(args.path);
+      if (dir !== '.') mkdirSync(dir, { recursive: true });
+      writeFileSync(args.path, args.content, 'utf-8');
+      const lines = args.content.split('\n').length;
+      return 'Written ' + lines + ' lines to ' + args.path;
+    }
+    case 'edit_file': {
+      if (!existsSync(args.path)) return 'ERROR: File not found: ' + args.path;
+      const original = readFileSync(args.path, 'utf-8');
+      if (!original.includes(args.old_str)) return 'ERROR: String not found in ' + args.path;
+      const updated = original.replace(args.old_str, args.new_str);
+      writeFileSync(args.path, updated, 'utf-8');
+      return 'Edited ' + args.path;
+    }
+    case 'list_directory': {
+      try {
+        const out = execSync('ls -la "' + (args.path || '.') + '"', { encoding: 'utf-8' });
+        return out.trim();
+      } catch (e) {
+        return 'ERROR: ' + e.message;
+      }
+    }
+    case 'search_files': {
+      try {
+        const out = execSync('find "' + (args.path || '.') + '" -name "' + args.pattern + '" 2>/dev/null | head -20', { encoding: 'utf-8' });
+        return out.trim() || 'No files found';
+      } catch (e) {
+        return 'ERROR: ' + e.message;
+      }
+    }
+    case 'grep': {
+      try {
+        const out = execSync('grep -rn "' + args.pattern + '" "' + args.path + '" 2>/dev/null | head -20', { encoding: 'utf-8' });
+        return out.trim() || 'No matches';
+      } catch (e) {
+        return 'No matches or error: ' + e.message;
+      }
+    }
+    default: {
+      try {
+        const mod = await import('../tools/' + name + '.js');
+        const toolFn = Object.values(mod)[0];
+        const result = await toolFn(args);
+        return result;
+      } catch (e) {
+        return 'Tool error: ' + e.message;
+      }
+    }
+  }
+}
+
+function renderToolStep(name, args, result, elapsed) {
+  const argPreview = (() => {
+    if (args.command)  return String(args.command).slice(0, 50);
+    if (args.path)     return args.path;
+    if (args.pattern)  return args.pattern;
+    return JSON.stringify(args).slice(0, 50);
+  })();
+
+  const header =
+    chalk.hex('#00FFFF')('\u2699 ') +
+    chalk.hex('#00FFFF').bold(name) +
+    chalk.dim(' \u00b7 ' + argPreview) +
+    chalk.dim('  (' + elapsed + 'ms)');
+  console.log(header);
+
+  if (name === 'write_file' && args.content) {
+    const lineCount = args.content.split('\n').length;
+    console.log(renderWrite(args.path, lineCount));
+    return;
+  }
+
+  if (name === 'edit_file' && existsSync(args.path)) {
+    try {
+      const original = readFileSync(args.path, 'utf-8');
+      const updated  = original.replace(args.old_str || '', args.new_str || '');
+      const changes  = diffLines(original, updated);
+      const hunks    = [];
+      let lineNum    = 1;
+      for (const part of changes) {
+        const partLines = part.value.split('\n');
+        if (partLines[partLines.length - 1] === '') partLines.pop();
+        for (const line of partLines) {
+          if (part.added)        hunks.push({ type: 'add',    line, lineNum });
+          else if (part.removed) hunks.push({ type: 'remove', line, lineNum });
+          else                   hunks.push({ type: 'context', line, lineNum });
+          lineNum++;
+        }
+      }
+      const changed = new Set(hunks.map((h, i) => h.type !== 'context' ? i : -1).filter(i => i >= 0));
+      const filtered = hunks.filter((_, i) => {
+        if (hunks[i].type !== 'context') return true;
+        for (const c of changed) if (Math.abs(i - c) <= 2) return true;
+        return false;
+      });
+      console.log(renderEdit(args.path, filtered));
+    } catch {}
+    return;
+  }
+
+  if (result && result !== '(no output)' && !result.startsWith('ERROR') && name !== 'read_file') {
+    const resultLines = String(result).split('\n').slice(0, 6);
+    for (const l of resultLines) {
+      console.log(chalk.dim('  \u2502 ') + chalk.hex('#AAAAAA')(l));
+    }
+    if (String(result).split('\n').length > 6) {
+      console.log(chalk.dim('  \u2502 ...'));
+    }
+  }
+
+  if (result && String(result).startsWith('ERROR')) {
+    console.log(chalk.hex('#FF4757')('  \u2716 ') + chalk.hex('#FF4757')(result));
+  }
+}
 
 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 })),
+  const intent = detectIntent(userMessage);
+  const spinner = new Spinner();
+  const msgHistory = Array.isArray(history) ? history : (history.messages || []);
+
+  if (intent === 'chat') {
+    spinner.start('Thinking', 'think');
+    const t0 = Date.now();
+
+    const messages = [
+      { role: 'system', content: 'You are CLARITY-AI, a helpful assistant. Keep responses short.' },
+      ...msgHistory.slice(-10).map(m => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content })),
+      { role: 'user', content: userMessage },
+    ];
+
+    const response = await callProvider(config, messages);
+    const elapsed = Date.now() - t0;
+    spinner.stop('Thought ' + (elapsed < 1000 ? elapsed + 'ms' : (elapsed/1000).toFixed(1) + 's'), 'done');
+
+    addMessage(msgHistory, 'user', userMessage);
+    addMessage(msgHistory, 'assistant', response);
+    saveHistory(msgHistory);
+
+    console.log();
+    console.log(renderAI(response));
+    console.log();
+    return;
+  }
+
+  let messages = [
+    { role: 'system', content: SYSTEM_PROMPT },
+    ...msgHistory.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;
+  let loopCount = 0;
+  const MAX_LOOPS = 15;
+
+  while (loopCount < MAX_LOOPS) {
+    loopCount++;
+
+    spinner.start('Thinking', 'think');
+    const t0 = Date.now();
 
-  while (toolCalls < maxToolCalls) {
     let fullResponse = '';
-    const stream = callProvider(config, messages);
+    const stream = streamProvider(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;
-      }
+    const thinkMs = Date.now() - t0;
+    spinner.stop('Thought ' + (thinkMs < 1000 ? thinkMs + 'ms' : (thinkMs/1000).toFixed(1) + 's'), 'done');
 
-      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}`;
-        }
+    const jsonMatch = fullResponse.match(/\{[^]*\}/);
+    if (!jsonMatch) {
+      console.log();
+      console.log(renderAI(fullResponse));
+      console.log();
+      addMessage(msgHistory, 'user', userMessage);
+      addMessage(msgHistory, 'assistant', fullResponse);
+      saveHistory(msgHistory);
+      return;
+    }
 
-        messages.push({ role: 'assistant', content: fullResponse });
-        messages.push({ role: 'user', content: `Tool result: ${result}` });
-      }
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonMatch[0]);
     } catch {
-      finalResponse = fullResponse;
-      break;
+      console.log();
+      console.log(renderAI(fullResponse));
+      console.log();
+      addMessage(msgHistory, 'user', userMessage);
+      addMessage(msgHistory, 'assistant', fullResponse);
+      saveHistory(msgHistory);
+      return;
     }
-  }
 
-  if (toolCalls >= maxToolCalls) {
-    finalResponse += '\n\n(Max tool calls reached)';
+    if (parsed.response) {
+      const finalText = parsed.response;
+      console.log();
+      console.log(renderAI(finalText));
+      console.log();
+      addMessage(msgHistory, 'user', userMessage);
+      addMessage(msgHistory, 'assistant', finalText);
+      saveHistory(msgHistory);
+      return;
+    }
+
+    if (parsed.tool) {
+      const name = parsed.tool;
+      const args = parsed.args || {};
+      const argPreview = args.command || args.path || args.pattern || '';
+
+      spinner.start('Running ' + name, 'tool');
+      spinner.update('Running ' + name, argPreview.slice(0, 40));
+
+      const ts = Date.now();
+      const result = await executeTool(name, args);
+      const te = Date.now() - ts;
+
+      spinner.stop(name + ' \u00b7 ' + argPreview.slice(0, 30), 'done');
+      renderToolStep(name, args, result, te);
+
+      messages.push({ role: 'assistant', content: fullResponse });
+      messages.push({ role: 'user', content: 'Tool result: ' + result });
+    }
   }
 
-  return finalResponse || 'No response generated';
+  console.log(chalk.hex('#FFB800')('\u26a0 Max tool calls reached. Stopping.'));
 }

package/src/commands/index.js

@@ -1,61 +1,125 @@
-import { helpCommand } from './help.js';
-import { chatCommand } from './chat.js';
-import { agentCommand } from './agent.js';
-import { toolsCommand } from './tools.js';
-import { memoryCommand } from './memory.js';
-import { historyCommand } from './history.js';
-import { modelCommand } from './model.js';
-import { providerCommand } from './provider.js';
-import { configCommand } from './config.js';
-import { clearCommand } from './clear.js';
-import { runCommand } from './run.js';
-import { taskCommand } from './task.js';
-import { searchCommand } from './search.js';
-import { fetchCommand } from './fetch.js';
-import { gitCommand } from './git.js';
-import { diffCommand } from './diff.js';
-import { undoCommand } from './undo.js';
-import { exportCommand } from './export.js';
-import { keysCommand } from './keys.js';
-import { exitCommand } from './exit.js';
+export const ALL_COMMANDS = [
+  { name: '/help',     description: 'Show all commands' },
+  { name: '/agent',    description: 'Toggle agent mode on/off' },
+  { name: '/model',    description: 'Switch AI model' },
+  { name: '/provider', description: 'Switch AI provider' },
+  { name: '/tools',    description: 'List all tools + permissions' },
+  { name: '/memory',   description: 'View or clear memory' },
+  { name: '/history',  description: 'View conversation history' },
+  { name: '/chat',     description: 'Start new chat session' },
+  { name: '/clear',    description: 'Clear screen + redraw banner' },
+  { name: '/task',     description: 'Run a full autonomous task' },
+  { name: '/search',   description: 'Web search' },
+  { name: '/fetch',    description: 'Fetch a URL' },
+  { name: '/git',      description: 'Git operations' },
+  { name: '/diff',     description: 'Compare two files' },
+  { name: '/run',      description: 'Execute a script file' },
+  { name: '/keys',     description: 'Manage API keys' },
+  { name: '/config',   description: 'View or edit settings' },
+  { name: '/export',   description: 'Export chat to markdown' },
+  { name: '/compact',  description: 'Compress conversation history' },
+  { name: '/undo',     description: 'Revert last AI file change' },
+  { name: '/exit',     description: 'Exit CLARITY' },
+];
 
-const COMMANDS = {
-  '/help': helpCommand,
-  '/chat': chatCommand,
-  '/agent': agentCommand,
-  '/tools': toolsCommand,
-  '/memory': memoryCommand,
-  '/history': historyCommand,
-  '/model': modelCommand,
-  '/provider': providerCommand,
-  '/config': configCommand,
-  '/clear': clearCommand,
-  '/run': runCommand,
-  '/task': taskCommand,
-  '/search': searchCommand,
-  '/fetch': fetchCommand,
-  '/git': gitCommand,
-  '/diff': diffCommand,
-  '/undo': undoCommand,
-  '/export': exportCommand,
-  '/keys': keysCommand,
-  '/exit': exitCommand,
-};
+export async function dispatchCommand(input, config, history) {
+  const parts = String(input).trim().split(/\s+/);
+  const cmd   = parts[0].toLowerCase();
+  const args  = parts.slice(1);
 
-export async function dispatchCommand(input, config, rl) {
-  const parts = input.trim().split(/\s+/);
-  const cmd = parts[0].toLowerCase();
-  const args = parts.slice(1);
-  const handler = COMMANDS[cmd];
-  if (!handler) {
-    console.log(`Unknown command: ${cmd}. Type /help for commands.`);
-    return config;
-  }
   try {
-    const result = await handler(args, config, rl);
-    return result || config;
-  } catch (err) {
-    console.log(`\x1b[31mCommand error:\x1b[0m ${err.message}`);
-    return config;
+    switch (cmd) {
+      case '/help': {
+        const m = await import('./help.js');
+        return m.helpCommand(args, config);
+      }
+      case '/agent': {
+        const m = await import('./agent.js');
+        return m.agentCommand(args, config);
+      }
+      case '/model': {
+        const m = await import('./model.js');
+        return m.modelCommand(args, config);
+      }
+      case '/provider': {
+        const m = await import('./provider.js');
+        return m.providerCommand(args, config);
+      }
+      case '/tools': {
+        const m = await import('./tools.js');
+        return m.toolsCommand(args, config);
+      }
+      case '/memory': {
+        const m = await import('./memory.js');
+        return m.memoryCommand(args, config);
+      }
+      case '/history': {
+        const m = await import('./history.js');
+        return m.historyCommand(args, config);
+      }
+      case '/chat': {
+        const m = await import('./chat.js');
+        return m.chatCommand(args, config);
+      }
+      case '/clear': {
+        const { showBanner } = await import('../ui/banner.js');
+        process.stdout.write('\x1Bc');
+        await showBanner(config.version, config.provider, config.model);
+        return;
+      }
+      case '/task': {
+        const m = await import('./task.js');
+        return m.taskCommand(args, config);
+      }
+      case '/search': {
+        const m = await import('./search.js');
+        return m.searchCommand(args, config);
+      }
+      case '/fetch': {
+        const m = await import('./fetch.js');
+        return m.fetchCommand(args, config);
+      }
+      case '/git': {
+        const m = await import('./git.js');
+        return m.gitCommand(args, config);
+      }
+      case '/diff': {
+        const m = await import('./diff.js');
+        return m.diffCommand(args, config);
+      }
+      case '/run': {
+        const m = await import('./run.js');
+        return m.runCommand(args, config);
+      }
+      case '/keys': {
+        const m = await import('./keys.js');
+        return m.keysCommand(args, config);
+      }
+      case '/config': {
+        const m = await import('./config.js');
+        return m.configCommand(args, config);
+      }
+      case '/export': {
+        const m = await import('./export.js');
+        return m.exportCommand(args, config);
+      }
+      case '/undo': {
+        const m = await import('./undo.js');
+        return m.undoCommand(args, config);
+      }
+      case '/exit': {
+        const chalk = (await import('chalk')).default;
+        console.log(chalk.hex('#00FF9F')('\n\u2714 Goodbye.'));
+        process.exit(0);
+      }
+      default: {
+        const chalk = (await import('chalk')).default;
+        console.log(chalk.hex('#FF4757')('\u2716 Unknown command: ') + cmd);
+        console.log(chalk.dim('  Type / to see all commands'));
+      }
+    }
+  } catch (e) {
+    const chalk = (await import('chalk')).default;
+    console.log(chalk.hex('#FF4757')('\u2716 Command error: ') + e.message);
   }
 }

package/src/commands/model.js

@@ -1,11 +1,26 @@
 import { saveConfig } from '../config/settings.js';
-import { clr } from '../ui/colors.js';
+import { PROVIDERS, getProvider } from '../providers/index.js';
+import chalk from 'chalk';
+
 export async function modelCommand(args, config) {
   if (args.length === 0) {
-    return console.log(clr.info('Current model: ' + config.provider + '/' + config.model));
+    console.log(chalk.hex('#54A0FF')('Current model: ') + chalk.white(config.provider + '/' + config.model));
+    return;
   }
-  config.model = args[0];
+
+  const modelName = args[0];
+
+  const prov = getProvider(modelName);
+  if (prov) {
+    config.provider = prov.value;
+    config.model = prov.freeModel;
+    saveConfig(config);
+    console.log(chalk.hex('#00FF9F')('Switched to provider: ') + chalk.white(prov.name) + chalk.dim(' (' + prov.freeModel + ')'));
+    return config;
+  }
+
+  config.model = modelName;
   saveConfig(config);
-  console.log(clr.success('Model set to: ' + config.model));
+  console.log(chalk.hex('#00FF9F')('Model set to: ') + chalk.white(modelName));
   return config;
 }