clarity-ai 3.0.2 → 3.2.0

package/src/main.js

@@ -1,90 +1,168 @@
-import readline from 'readline';
-import { clr } from './ui/colors.js';
-import { blocks } from './ui/blocks.js';
+import chalk from 'chalk';
+import { renderUser, renderAI, divider } from './ui/blocks.js';
+import { getPrompt, drawPromptBox, SlashPalette } from './ui/prompt.js';
 import { dispatchCommand } from './commands/index.js';
-import { callProvider } from './providers/index.js';
-import { loadHistory, saveHistory, addMessage } from './core/history.js';
 import { agentLoop } from './agents/loop.js';
+import { showBanner } from './ui/banner.js';
 
 export async function startChat(config) {
-  const history = loadHistory();
-
-  console.log(blocks.info(
-    'CLARITY-AI v' + config.version + ' interactive session started.\n' +
-    'Type /help for commands. Ctrl+C to exit.\n' +
-    'Provider: ' + config.provider + ' | Model: ' + config.model,
-    '◆ Ready ── ' + new Date().toLocaleTimeString()
-  ));
+  const history = [];
+  const palette = new SlashPalette();
+  let slashMode = false;
+  let slashBuffer = '';
+
+  const { top } = drawPromptBox(config.provider, config.model, config.agentMode);
+  console.log(chalk.hex('#00FF9F')('\u2714 ') + chalk.white('CLARITY-AI v' + config.version + ' interactive session started.') +
+              chalk.dim('  Type /help for commands. Ctrl+C to exit.'));
+  console.log(divider());
   console.log();
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true,
-    historySize: 100,
-  });
+  const { emitKeypressEvents } = await import('readline');
+  emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+  let currentInput = '';
+
+  function drawPromptLine() {
+    process.stdout.write('\r\x1b[2K');
+    process.stdout.write(getPrompt(config.provider, config.model));
+    if (currentInput) process.stdout.write(currentInput);
+  }
 
-  function showPrompt() {
-    const pre = clr.primary('❯ ') + clr.dim(config.provider + '/' + config.model) + clr.primary(' ❯ ');
-    rl.setPrompt(pre);
-    rl.prompt();
+  function clearAndPrompt() {
+    console.log();
+    drawPromptLine();
   }
 
-  process.stdin.on('keypress', (str, key) => {
-    if (key && key.ctrl && key.name === 'l') {
+  process.stdin.on('keypress', async (str, key) => {
+    if (!key) return;
+
+    if (key.ctrl && key.name === 'c') {
+      if (slashMode) {
+        palette.hide();
+        slashMode = false;
+        slashBuffer = '';
+        currentInput = '';
+        drawPromptLine();
+        return;
+      }
+      console.log('\n' + chalk.hex('#00FF9F')('\u2714 ') + chalk.dim('Session ended. Goodbye.'));
+      process.exit(0);
+    }
+
+    if (key.ctrl && key.name === 'l') {
       process.stdout.write('\x1Bc');
-      showPrompt();
+      await showBanner(config.version, config.provider, config.model);
+      drawPromptLine();
+      return;
+    }
+
+    if (key.ctrl && key.name === 'u') {
+      currentInput = '';
+      slashMode = false;
+      slashBuffer = '';
+      drawPromptLine();
+      return;
     }
-  });
 
-  showPrompt();
+    if (key.name === 'escape') {
+      if (slashMode) {
+        palette.hide();
+        slashMode = false;
+        slashBuffer = '';
+        currentInput = '';
+        drawPromptLine();
+      }
+      return;
+    }
 
-  rl.on('line', async (input) => {
-    input = input.trim();
-    if (!input) { showPrompt(); return; }
+    if (slashMode) {
+      if (key.name === 'up') {
+        palette.selectPrev();
+        return;
+      }
+      if (key.name === 'down') {
+        palette.selectNext();
+        return;
+      }
+      if (key.name === 'return') {
+        const selected = palette.getSelected();
+        palette.hide();
+        slashMode = false;
+        currentInput = '';
+        drawPromptLine();
+        if (selected) {
+          console.log();
+          await dispatchCommand(selected.name, config, history);
+        }
+        clearAndPrompt();
+        return;
+      }
+      if (key.name === 'backspace') {
+        slashBuffer = slashBuffer.slice(0, -1);
+        currentInput = '/' + slashBuffer;
+        palette.filter(slashBuffer);
+        drawPromptLine();
+        return;
+      }
+      if (str && !key.ctrl && !key.meta) {
+        slashBuffer += str;
+        currentInput = '/' + slashBuffer;
+        palette.filter(slashBuffer);
+        drawPromptLine();
+        return;
+      }
+      return;
+    }
 
-    if (input.startsWith('/')) {
-      const newConfig = await dispatchCommand(input, config, rl);
-      if (newConfig) config = newConfig;
-      showPrompt();
+    if (key.name === 'backspace') {
+      currentInput = currentInput.slice(0, -1);
+      drawPromptLine();
       return;
     }
 
-    console.log('\n' + blocks.user(input) + '\n');
-
-    if (config.agentMode !== false) {
-      const result = await agentLoop(input, config, history);
-      addMessage(history, 'user', input);
-      addMessage(history, 'assistant', result);
-      saveHistory(history);
-      console.log('\n' + blocks.ai(result) + '\n');
-    } else {
-      addMessage(history, 'user', input);
-      console.log(clr.dim('◆ Thinking...'));
-
-      let fullResponse = '';
-      const stream = callProvider(config, [
-        { role: 'system', content: 'You are CLARITY-AI, a helpful AI assistant.' },
-        ...history.slice(-10).map(m => ({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content })),
-        { role: 'user', content: input },
-      ]);
-
-      process.stdout.write(clr.ai('') + ' ');
-      for await (const chunk of stream) {
-        fullResponse += chunk;
-        process.stdout.write(chunk);
+    if (key.name === 'return') {
+      const input = currentInput.trim();
+      currentInput = '';
+
+      if (!input) {
+        console.log();
+        drawPromptLine();
+        return;
       }
-      console.log('\n');
 
-      addMessage(history, 'assistant', fullResponse);
-      saveHistory(history);
+      process.stdout.write('\r\x1b[2K');
+      console.log();
+      console.log(renderUser(input));
+      console.log();
+
+      if (input.startsWith('/')) {
+        await dispatchCommand(input, config, history);
+        clearAndPrompt();
+        return;
+      }
+
+      await agentLoop(input, config, history);
+      clearAndPrompt();
+      return;
     }
 
-    showPrompt();
-  });
+    if (str === '/' && currentInput === '') {
+      slashMode = true;
+      slashBuffer = '';
+      currentInput = '/';
+      console.log();
+      palette.show();
+      drawPromptLine();
+      return;
+    }
 
-  rl.on('SIGINT', () => {
-    console.log('\n' + blocks.info('Session ended. Goodbye.', '◆ EXIT'));
-    process.exit(0);
+    if (str && !key.ctrl && !key.meta) {
+      currentInput += str;
+      drawPromptLine();
+    }
   });
+
+  console.log(top);
+  drawPromptLine();
 }

package/src/providers/index.js

@@ -16,15 +16,23 @@ export const PROVIDERS = [
 
 const senders = { groq: groqSend, gemini: geminiSend, openrouter: openrouterSend, openai: openaiSend, anthropic: anthropicSend, deepseek: deepseekSend };
 
-export function callProvider(config, messages) {
+export function streamProvider(config, messages) {
   const provider = config.provider || 'groq';
   const model = config.model || 'llama-3.3-70b-versatile';
   const apiKey = config.apiKeys?.[provider] || process.env[provider.toUpperCase() + '_API_KEY'] || '';
   const sender = senders[provider];
-  if (!sender) throw new Error(`Unknown provider: ${provider}`);
+  if (!sender) throw new Error('Unknown provider: ' + provider);
   return sender(apiKey, messages, model, true);
 }
 
+export async function callProvider(config, messages) {
+  let full = '';
+  for await (const chunk of streamProvider(config, messages)) {
+    full += chunk;
+  }
+  return full;
+}
+
 export function getProvider(name) {
   return PROVIDERS.find(p => p.value === name);
 }

package/src/ui/blocks.js

@@ -1,65 +1,132 @@
-// src/ui/blocks.js
 import chalk from 'chalk';
 import { clr } from './colors.js';
 import stripAnsi from 'strip-ansi';
 
-const W = process.stdout.columns || 80;
+const W = () => process.stdout.columns || 80;
 
-const BORDERS = {
-  round:  { tl:'╭', tr:'╮', bl:'╰', br:'╯', h:'─', v:'│' },
-  sharp:  { tl:'┌', tr:'┐', bl:'└', br:'┘', h:'─', v:'│' },
-  double: { tl:'╔', tr:'╗', bl:'╚', br:'╝', h:'═', v:'║' },
-  thick:  { tl:'▛', tr:'▜', bl:'▙', br:'▟', h:'▀', v:'█' },
-};
+export function renderUser(text) {
+  const w = Math.min(W(), 80);
+  const lines = String(text).split('\n');
+  const out = [];
+  out.push(chalk.hex('#9B59FF').bold('\u276f YOU ') + chalk.hex('#9B59FF')('\u2500'.repeat(Math.max(0, w - 7))));
+  for (const line of lines) {
+    const vis = stripAnsi(line).length;
+    const pad = Math.max(0, w - vis - 1);
+    out.push(chalk.hex('#C39BD3').bgHex('#2D1B4E')(line + ' '.repeat(pad)));
+  }
+  return out.join('\n');
+}
+
+export function renderAI(text) {
+  const w = Math.min(W(), 80);
+  const lines = String(text).split('\n');
+  const out = [];
+  out.push(chalk.hex('#9B59FF')('\u25c6 CLARITY ') + chalk.hex('#555555')('\u2500'.repeat(Math.max(0, w - 11))));
+  for (const line of lines) {
+    out.push(chalk.hex('#7B2FFF')('\u2502') + ' ' + chalk.white(line));
+  }
+  return out.join('\n');
+}
 
-function box(content, opts = {}) {
-  const {
-    title = '',
-    style = 'round',
-    color = '#00FFFF',
-    width = Math.min(W - 2, 78),
-    padding = 1,
-  } = opts;
+export function renderEdit(filepath, hunks) {
+  const out = [];
+  const fname = filepath.split('/').pop();
+  out.push(
+    chalk.bgHex('#1A1A2E').hex('#74B9FF').bold(' \u270e ' + fname + ' ') +
+    chalk.dim(' ' + filepath)
+  );
+  out.push(chalk.hex('#333333')('\u2500'.repeat(Math.min(W(), 80))));
+  for (const h of hunks) {
+    if (h.type === 'add') {
+      out.push(
+        chalk.hex('#00FF9F')('+') +
+        chalk.dim(String(h.lineNum).padStart(4)) +
+        ' ' +
+        chalk.hex('#00FF9F')(h.line)
+      );
+    } else if (h.type === 'remove') {
+      out.push(
+        chalk.hex('#FF4757')('-') +
+        chalk.dim(String(h.lineNum).padStart(4)) +
+        ' ' +
+        chalk.hex('#FF4757').strikethrough(h.line)
+      );
+    } else {
+      out.push(
+        chalk.dim(' ') +
+        chalk.dim(String(h.lineNum).padStart(4)) +
+        ' ' +
+        chalk.hex('#888888')(h.line)
+      );
+    }
+  }
+  return out.join('\n');
+}
 
-  const b = BORDERS[style] || BORDERS.round;
-  const colorFn = (t) => chalk.hex(color)(t);
-  const inner = width - 2;
+export function renderWrite(filepath, lineCount) {
+  const fname = filepath.split('/').pop();
+  return [
+    chalk.bgHex('#1A1A2E').hex('#00FF9F').bold(' + ' + fname + ' ') +
+    chalk.dim(' ' + filepath),
+    chalk.hex('#00FF9F')('  ' + lineCount + ' lines written'),
+  ].join('\n');
+}
 
-  const lines = String(content).split('\n');
-  const padded = lines.map(l => {
-    const vis = stripAnsi(l).length;
-    const pad = Math.max(0, inner - padding * 2 - vis);
-    return colorFn(b.v) + ' '.repeat(padding) + l + ' '.repeat(pad) + colorFn(b.v);
-  });
+export function renderTool(toolName, input, output) {
+  const out = [];
+  out.push(chalk.hex('#FFD700')('\u2699 ') + chalk.hex('#FFD700').bold(toolName) + chalk.dim(' \u00b7 ' + String(input).slice(0, 60)));
+  if (output) {
+    const lines = String(output).split('\n').slice(0, 8);
+    for (const l of lines) {
+      out.push(chalk.dim('  \u2502 ') + chalk.hex('#AAAAAA')(l));
+    }
+    if (String(output).split('\n').length > 8) {
+      out.push(chalk.dim('  \u2502 ...'));
+    }
+  }
+  return out.join('\n');
+}
 
-  const titleStr = title
-    ? colorFn(b.h).repeat(2) + ' ' + chalk.bold(title) + ' ' + colorFn(b.h).repeat(Math.max(0, inner - title.length - 4))
-    : colorFn(b.h).repeat(inner);
+export function renderInfo(msg) {
+  return chalk.hex('#54A0FF')('\u2139 ') + chalk.hex('#54A0FF')(msg);
+}
 
-  const top    = colorFn(b.tl) + titleStr + colorFn(b.tr);
-  const bottom = colorFn(b.bl) + colorFn(b.h).repeat(inner) + colorFn(b.br);
+export function renderError(msg) {
+  return chalk.hex('#FF4757')('\u2716 ') + chalk.hex('#FF4757')(msg);
+}
+
+export function renderSuccess(msg) {
+  return chalk.hex('#00FF9F')('\u2714 ') + chalk.hex('#00FF9F')(msg);
+}
+
+export function renderWarning(msg) {
+  return chalk.hex('#FFB800')('\u26a0 ') + chalk.hex('#FFB800')(msg);
+}
+
+export function divider() {
+  return chalk.hex('#333333')('\u2500'.repeat(Math.min(process.stdout.columns || 80, 80)));
+}
 
-  return [top, ...padded, bottom].join('\n');
+export function renderPromptPrefix(provider, model) {
+  return (
+    chalk.hex('#00FFFF')('\u276f ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#00FFFF')(' \u276f ')
+  );
 }
 
-// 12 named block types
 export const blocks = {
-  info:     (msg, title) => box(clr.info(msg),    { title: title || 'ℹ INFO',    color: '#54A0FF', style: 'round'  }),
-  success:  (msg, title) => box(clr.success(msg), { title: title || '✔ SUCCESS', color: '#00FF9F', style: 'round'  }),
-  warning:  (msg, title) => box(clr.warning(msg), { title: title || '⚠ WARNING', color: '#FFB800', style: 'sharp'  }),
-  error:    (msg, title) => box(clr.error(msg),   { title: title || '✖ ERROR',   color: '#FF4757', style: 'sharp'  }),
-  code:     (msg, title) => box(chalk.hex('#E8E8E8')(msg), { title: title || '◆ CODE', color: '#9B59FF', style: 'sharp' }),
-  file:     (msg, title) => box(clr.filepath(msg),{ title: title || '📄 FILE',   color: '#74B9FF', style: 'round'  }),
-  ai:       (msg, title) => box(clr.ai(msg),      { title: title || '◆ CLARITY', color: '#9B59FF', style: 'round'  }),
-  user:     (msg, title) => box(clr.user(msg),    { title: title || '❯ YOU',     color: '#00FFFF', style: 'round'  }),
-  tool:     (msg, title) => box(clr.tool(msg),    { title: title || '⚙ TOOL',    color: '#00FF9F', style: 'double' }),
-  task:     (msg, title) => box(clr.gold(msg),    { title: title || '▶ TASK',    color: '#FFD700', style: 'double' }),
-  divider:  ()           => clr.muted('─'.repeat(Math.min(W, 80))),
-  progress: (pct, label) => {
-    const filled = Math.round(pct / 100 * 30);
-    const bar = chalk.hex('#00FFFF')('█'.repeat(filled)) + chalk.gray('░'.repeat(30 - filled));
-    return `[${bar}] ${chalk.bold(pct + '%')} ${label || ''}`;
-  },
+  ai:       renderAI,
+  user:     renderUser,
+  info:     (msg) => renderInfo(msg),
+  error:    (msg) => renderError(msg),
+  success:  (msg) => renderSuccess(msg),
+  warning:  (msg) => renderWarning(msg),
+  divider,
+  edit:     renderEdit,
+  write:    renderWrite,
+  tool:     renderTool,
+  task:     (msg) => chalk.hex('#FFD700')('\u25b6 ') + chalk.hex('#FFD700')(msg),
 };
 
 export default blocks;

package/src/ui/input.js

@@ -1,60 +1,29 @@
 import readline from 'readline';
 import chalk from 'chalk';
-import { clr } from './colors.js';
 
-export function createPrompt(config) {
+export function createInput(config) {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     terminal: true,
-    historySize: 100,
-  });
-
-  const promptStr = clr.primary('❯ ') + clr.dim(config.provider + '/' + config.model) + clr.primary(' ❯ ');
-
-  rl.on('SIGINT', () => {
-    process.stdout.write('\n');
-    process.exit(0);
+    historySize: 200,
   });
 
   process.stdin.on('keypress', (str, key) => {
-    if (key.ctrl && key.name === 'd') {
-      process.stdout.write('\n');
-      process.exit(0);
-    }
-    if (key.ctrl && key.name === 'l') {
-      console.clear();
-      return rl._refreshLine();
-    }
-    if (key.ctrl && key.name === 'u') {
-      const pos = rl.cursor;
-      rl.line = rl.line.slice(pos);
-      rl.cursor = 0;
-      return rl._refreshLine();
-    }
-    if (key.ctrl && key.name === 'a') {
-      rl.cursor = 0;
-      return rl._refreshLine();
-    }
-    if (key.ctrl && key.name === 'e') {
-      rl.cursor = rl.line.length;
-      return rl._refreshLine();
-    }
-    if (key.ctrl && key.name === 'k') {
-      rl.line = rl.line.slice(0, rl.cursor);
-      return rl._refreshLine();
-    }
-    if (key.ctrl && key.name === 'w') {
-      const before = rl.line.slice(0, rl.cursor);
-      const after = rl.line.slice(rl.cursor);
-      const trimmed = before.replace(/\S+\s*$/, '');
-      rl.line = trimmed + after;
-      rl.cursor = trimmed.length;
-      return rl._refreshLine();
+    if (key && key.ctrl && key.name === 'l') {
+      process.stdout.write('\x1Bc');
+      process.stdout.write(chalk.hex('#00FFFF').bold('\n  CLARITY v3.0\n\n'));
+      rl.prompt();
     }
   });
 
-  rl.setPrompt(promptStr);
-
   return rl;
 }
+
+export function getPromptString(provider, model) {
+  return (
+    chalk.hex('#00FFFF')('\u276f ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#00FFFF')(' \u276f ')
+  );
+}

package/src/ui/prompt.js

@@ -0,0 +1,127 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import { ALL_COMMANDS } from '../commands/index.js';
+
+const W = () => process.stdout.columns || 80;
+
+export function drawPromptBox(provider, model, agentMode = true) {
+  const w = Math.min(W(), 80);
+  const inner = w - 2;
+  const top    = chalk.hex('#333333')('\u250c') + chalk.hex('#333333')('\u2500'.repeat(inner)) + chalk.hex('#333333')('\u2510');
+  const bottom =
+    chalk.hex('#333333')('\u2514') +
+    chalk.hex('#333333')('\u2500 ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#333333')(' ' + '\u2500'.repeat(Math.max(0, inner - (provider + '/' + model).length - 14))) +
+    chalk.hex('#00FF9F')(agentMode ? 'agent: ON ' : 'agent: OFF') +
+    chalk.hex('#333333')('\u2500\u2518');
+  return { top, bottom };
+}
+
+export function getPrompt(provider, model) {
+  return (
+    chalk.hex('#333333')('\u2502 ') +
+    chalk.hex('#00FFFF')('\u276f ') +
+    chalk.dim(provider + '/' + model) +
+    chalk.hex('#00FFFF')(' \u276f ')
+  );
+}
+
+export class SlashPalette {
+  constructor() {
+    this.visible = false;
+    this.query = '';
+    this.selected = 0;
+    this.commands = [];
+    this._lastLineCount = 0;
+  }
+
+  show() {
+    this.visible = true;
+    this.commands = ALL_COMMANDS;
+    this.selected = 0;
+    this.query = '';
+    this.render();
+  }
+
+  hide() {
+    this.visible = false;
+    this.query = '';
+    this.selected = 0;
+    const lines = this._lastLineCount;
+    this._lastLineCount = 0;
+    for (let i = 0; i < lines; i++) {
+      process.stdout.write('\x1b[A\x1b[2K');
+    }
+  }
+
+  filter(query) {
+    this.query = query;
+    this.selected = 0;
+    this.render();
+  }
+
+  selectNext() {
+    const filtered = this._filtered();
+    this.selected = Math.min(this.selected + 1, filtered.length - 1);
+    this.render();
+  }
+
+  selectPrev() {
+    this.selected = Math.max(this.selected - 1, 0);
+    this.render();
+  }
+
+  getSelected() {
+    const filtered = this._filtered();
+    return filtered[this.selected] || null;
+  }
+
+  _filtered() {
+    if (!this.query) return this.commands;
+    return this.commands.filter(c =>
+      c.name.includes(this.query) || c.description.toLowerCase().includes(this.query.toLowerCase())
+    );
+  }
+
+  render() {
+    const filtered = this._filtered();
+    const show = filtered.slice(0, 8);
+    const w = Math.min(W(), 80);
+
+    if (this._lastLineCount) {
+      for (let i = 0; i < this._lastLineCount; i++) {
+        process.stdout.write('\x1b[A\x1b[2K');
+      }
+    }
+
+    const lines = [];
+    lines.push(
+      chalk.bgHex('#1A1A2E').hex('#00FFFF').bold(' Commands ') +
+      chalk.bgHex('#1A1A2E').dim('  type to filter  ') +
+      chalk.bgHex('#1A1A2E').dim('esc to close'.padEnd(w - 28, ' '))
+    );
+    lines.push(chalk.hex('#333333')('\u2500'.repeat(w)));
+
+    if (show.length === 0) {
+      lines.push(chalk.dim('  No commands match "' + this.query + '"'));
+    } else {
+      show.forEach((cmd, i) => {
+        const isSelected = i === this.selected;
+        const prefix = isSelected ? chalk.hex('#00FFFF')(' \u276f ') : '   ';
+        const name   = isSelected
+          ? chalk.bgHex('#1A1A2E').hex('#00FFFF').bold((cmd.name).padEnd(18))
+          : chalk.hex('#9B59FF')((cmd.name).padEnd(18));
+        const desc   = isSelected
+          ? chalk.white(cmd.description)
+          : chalk.dim(cmd.description);
+        lines.push(prefix + name + '  ' + desc);
+      });
+    }
+
+    lines.push(chalk.hex('#333333')('\u2500'.repeat(w)));
+
+    process.stdout.write(lines.join('\n') + '\n');
+    this._lastLineCount = lines.length;
+  }
+}