clarity-ai 1.0.0

package/src/config/keys.js

@@ -0,0 +1,104 @@
+import Conf from 'conf';
+import paths from './paths.js';
+
+const PROVIDER_REGEX = {
+  groq: /^gsk_[A-Za-z0-9]{30,}$/,
+  openrouter: /^sk-or-[A-Za-z0-9]{20,}$/,
+  anthropic: /^sk-ant-[A-Za-z0-9]{20,}$/,
+  openai: /^sk-[A-Za-z0-9]{20,}$/,
+  gemini: /^AIzaSy[A-Za-z0-9_-]{20,}$/,
+  deepseek: /^[A-Za-z0-9]{20,}$/,
+};
+
+const PROVIDER_NAMES = {
+  groq: 'Groq',
+  openrouter: 'OpenRouter',
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  gemini: 'Google Gemini',
+  deepseek: 'DeepSeek',
+};
+
+const keys = new Conf({
+  projectName: 'clarity',
+  configName: 'keys',
+  cwd: paths.config,
+});
+
+function obfuscate(key) {
+  return Buffer.from(key).toString('base64').split('').reverse().join('');
+}
+
+function deobfuscate(encoded) {
+  return Buffer.from(encoded.split('').reverse().join(''), 'base64').toString();
+}
+
+function setKey(provider, key) {
+  const name = provider.toLowerCase();
+  if (!PROVIDER_REGEX[name]) {
+    throw new Error(`Unknown provider: ${provider}. Supported: ${Object.keys(PROVIDER_REGEX).join(', ')}`);
+  }
+  if (!PROVIDER_REGEX[name].test(key)) {
+    throw new Error(`Invalid key format for ${name}. Expected format: ${PROVIDER_REGEX[name]}`);
+  }
+  keys.set(name, obfuscate(key));
+}
+
+function getKey(provider) {
+  const encoded = keys.get(provider.toLowerCase());
+  if (!encoded) return null;
+  return deobfuscate(encoded);
+}
+
+function listKeys() {
+  const all = {};
+  for (const [provider, _] of Object.entries(PROVIDER_REGEX)) {
+    const key = keys.get(provider);
+    if (key) {
+      all[provider] = {
+        configured: true,
+        keyPreview: deobfuscate(key).slice(0, 8) + '...' + deobfuscate(key).slice(-4),
+      };
+    }
+  }
+  return all;
+}
+
+function removeKey(provider) {
+  keys.delete(provider.toLowerCase());
+}
+
+function hasAnyKeys() {
+  return Object.keys(PROVIDER_REGEX).some(p => keys.get(p));
+}
+
+async function testKey(provider) {
+  const apiKey = getKey(provider);
+  if (!apiKey) return { success: false, error: 'No key configured' };
+  
+  try {
+    const testEndpoints = {
+      groq: { url: 'https://api.groq.com/openai/v1/models', headers: { 'Authorization': `Bearer ${apiKey}` } },
+      gemini: { url: `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}` },
+      openrouter: { url: 'https://openrouter.ai/api/v1/models', headers: { 'Authorization': `Bearer ${apiKey}` } },
+      openai: { url: 'https://api.openai.com/v1/models', headers: { 'Authorization': `Bearer ${apiKey}` } },
+      anthropic: { url: 'https://api.anthropic.com/v1/messages', headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }, method: 'POST', body: { model: 'claude-3-haiku-20240307', max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] } },
+      deepseek: { url: 'https://api.deepseek.com/v1/models', headers: { 'Authorization': `Bearer ${apiKey}` } },
+    };
+    
+    const endpoint = testEndpoints[provider];
+    if (!endpoint) return { success: false, error: 'Unknown provider' };
+    
+    const res = await fetch(endpoint.url, {
+      method: endpoint.method || 'GET',
+      headers: { ...endpoint.headers, 'Content-Type': 'application/json' },
+      body: endpoint.body ? JSON.stringify(endpoint.body) : undefined,
+    });
+    
+    return { success: res.ok, status: res.status, error: res.ok ? null : `HTTP ${res.status}` };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+export { setKey, getKey, listKeys, removeKey, hasAnyKeys, testKey, PROVIDER_NAMES, PROVIDER_REGEX };

package/src/config/paths.js

@@ -0,0 +1,22 @@
+import { isTermux } from '../utils/termux.js';
+import { homedir } from 'os';
+import { resolve } from 'path';
+
+const HOME = homedir();
+const XDG_CONFIG = process.env.XDG_CONFIG_HOME || resolve(HOME, '.config');
+const XDG_DATA = process.env.XDG_DATA_HOME || resolve(HOME, '.local', 'share');
+const XDG_CACHE = process.env.XDG_CACHE_HOME || resolve(HOME, '.cache');
+
+const paths = {
+  config: resolve(XDG_CONFIG, 'clarity'),
+  data: resolve(XDG_DATA, 'clarity'),
+  cache: resolve(XDG_CACHE, 'clarity'),
+  logs: resolve(XDG_CACHE, 'clarity', 'logs'),
+  history: resolve(XDG_CONFIG, 'clarity', 'history'),
+  keys: resolve(XDG_CONFIG, 'clarity', 'keys.json'),
+  settings: resolve(XDG_CONFIG, 'clarity', 'settings.json'),
+  agents: resolve(XDG_CONFIG, 'clarity', 'agents.json'),
+  memory: resolve(XDG_DATA, 'clarity', 'memory.json'),
+};
+
+export default paths;

package/src/config/settings.js

@@ -0,0 +1,28 @@
+import Conf from 'conf';
+import paths from './paths.js';
+
+const schema = {
+  theme: { type: 'string', default: 'dark' },
+  defaultModel: { type: 'string', default: 'groq/llama3-70b-8192' },
+  stream: { type: 'boolean', default: true },
+  showTokens: { type: 'boolean', default: true },
+  saveHistory: { type: 'boolean', default: true },
+  initDir: { type: 'boolean', default: false },
+};
+
+const settings = new Conf({
+  projectName: 'clarity',
+  schema,
+  configName: 'settings',
+  cwd: paths.config,
+  defaults: {
+    theme: 'dark',
+    defaultModel: 'groq/llama3-70b-8192',
+    stream: true,
+    showTokens: true,
+    saveHistory: true,
+    initDir: false,
+  }
+});
+
+export default settings;

package/src/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { checkNodeVersion, checkDependencies, checkUpdates } from './utils/version-check.js';
+import { isTermux } from './utils/termux.js';
+import paths from './config/paths.js';
+import { hasAnyKeys } from './config/keys.js';
+import settings from './config/settings.js';
+import renderBanner from './ui/banner.js';
+import blocks from './ui/blocks.js';
+import { startChat } from './ui/chatbox.js';
+import agentManager from './agents/manager.js';
+import memory from './memory/store.js';
+import { mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+import readline from 'readline';
+
+checkNodeVersion();
+
+for (const dir of [paths.config, paths.data, paths.cache, paths.logs]) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+checkDependencies(process.cwd());
+checkUpdates();
+
+process.on('uncaughtException', (err) => {
+  blocks.error('Unexpected Error', err.message);
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+
+process.on('SIGINT', () => {
+  console.log();
+  blocks.info('Goodbye', 'Thanks for using CLARITY!');
+  process.exit(0);
+});
+
+process.on('exit', () => {
+  agentManager.save();
+});
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 && !hasAnyKeys()) {
+    renderBanner();
+    blocks.warn('No API Keys',
+      `No API keys found. Run 'clarity init' first.\n\nQuick start (free options):\n1. Get Groq key: https://console.groq.com\n2. Get Gemini key: https://aistudio.google.com\n\nThen: clarity /keys set groq YOUR_KEY`);
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question('Would you like to run the setup wizard now? (Y/n) ', async (answer) => {
+      rl.close();
+      if (answer.toLowerCase() !== 'n') {
+        const { default: commandRegistry } = await import('./commands/index.js');
+        await commandRegistry.init();
+      } else {
+        process.exit(0);
+      }
+    });
+    return;
+  }
+
+  if (args.length > 0) {
+    const input = args.join(' ');
+    if (input.startsWith('/')) {
+      const { default: commandRegistry } = await import('./commands/index.js');
+      const result = await commandRegistry.execute(input, {});
+      if (result?.exit) process.exit(0);
+      if (!result?.stay) process.exit(0);
+    } else {
+      const { default: commandRegistry } = await import('./commands/index.js');
+      const { default: chatbox } = await import('./ui/chatbox.js');
+      startChat();
+    }
+    return;
+  }
+
+  await agentManager.restore();
+  const { default: commandRegistry } = await import('./commands/index.js');
+  const { default: chatbox } = await import('./ui/chatbox.js');
+  startChat();
+}
+
+main().catch(err => {
+  blocks.error('Startup Error', err.message);
+  process.exit(1);
+});

package/src/memory/context.js

@@ -0,0 +1,38 @@
+import memory from './store.js';
+
+const contextManager = {
+  buildPrompt({ platform, arch, nodeVersion, cwd, isTermux, toolList, userMemory }) {
+    const parts = [
+      `You are CLARITY, an AI agent running in the user's terminal (possibly Termux on Android).`,
+      ``,
+      `You have access to tools: bash execution, file operations, web search, code execution, git, and package management.`,
+      ``,
+      `When the user asks you to do something that requires a tool, use it. Always show what you're doing.`,
+      ``,
+      `Keep responses concise and terminal-friendly. Use markdown for code blocks. Avoid very long prose.`,
+      ``,
+      `You are running on: ${platform} ${arch}, Node ${nodeVersion}.`,
+      `Current directory: ${cwd}`,
+      `Termux: ${isTermux}`,
+      `Available tools: ${toolList}`,
+      `User memory: ${userMemory}`,
+    ];
+    return parts.join('\n');
+  },
+
+  getSystemPrompt() {
+    const mem = memory.show();
+    const notes = mem.filter(m => m.role === 'system').map(m => m.content.replace('[Memory: ', '').replace(']', ''));
+    return {
+      platform: process.platform,
+      arch: process.arch,
+      nodeVersion: process.versions.node,
+      cwd: process.cwd(),
+      isTermux: !!process.env.PREFIX?.includes('com.termux'),
+      toolList: 'bash, files, web, search, code, git, pkg, system',
+      userMemory: notes.join('; ') || 'none',
+    };
+  }
+};
+
+export default contextManager;

package/src/memory/store.js

@@ -0,0 +1,54 @@
+import Conf from 'conf';
+import paths from '../config/paths.js';
+
+const MAX_CONTEXT = 10;
+
+const memoryStore = new Conf({
+  projectName: 'clarity',
+  configName: 'memory',
+  cwd: paths.data,
+  defaults: { conversations: [], context: [] }
+});
+
+const memory = {
+  add(conversation) {
+    const ctx = memoryStore.get('context') || [];
+    const lastMsg = conversation[conversation.length - 1];
+    if (lastMsg) ctx.push(lastMsg);
+    if (ctx.length > MAX_CONTEXT * 2) ctx.splice(0, 2);
+    memoryStore.set('context', ctx);
+  },
+
+  getContext() {
+    return memoryStore.get('context') || [];
+  },
+
+  clear() {
+    memoryStore.set('context', []);
+    memoryStore.set('conversations', []);
+  },
+
+  show() {
+    return this.getContext();
+  },
+
+  addNote(note) {
+    const ctx = memoryStore.get('context') || [];
+    ctx.push({ role: 'system', content: `[Memory: ${note}]` });
+    if (ctx.length > MAX_CONTEXT * 2) ctx.splice(0, 2);
+    memoryStore.set('context', ctx);
+  },
+
+  saveConversation(messages) {
+    const convs = memoryStore.get('conversations') || [];
+    convs.push({ id: Date.now(), messages: messages.slice(-20), timestamp: new Date().toISOString() });
+    if (convs.length > 50) convs.shift();
+    memoryStore.set('conversations', convs);
+  },
+
+  getConversations() {
+    return memoryStore.get('conversations') || [];
+  }
+};
+
+export default memory;

package/src/providers/claude.js

@@ -0,0 +1,61 @@
+const PROVIDER = {
+  name: 'anthropic',
+  free: false,
+  streaming: true,
+  models: ['claude-3-5-haiku-20241022', 'claude-3-5-sonnet-20241022'],
+  baseURL: 'https://api.anthropic.com/v1',
+};
+
+async function* sendMessage(apiKey, messages, model = 'claude-3-5-haiku-20241022', stream = true) {
+  const url = `${PROVIDER.baseURL}/messages`;
+  
+  const systemMsg = messages.filter(m => m.role === 'system');
+  const chatMessages = messages.filter(m => m.role !== 'system');
+  
+  const body = {
+    model,
+    max_tokens: 4096,
+    messages: chatMessages.map(m => ({ role: m.role, content: m.content })),
+    stream,
+  };
+  if (systemMsg.length > 0) body.system = systemMsg.map(m => m.content).join('\n');
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) throw new Error(`Anthropic API error: ${res.status} ${res.statusText}`);
+
+  if (!stream) {
+    const data = await res.json();
+    yield data.content[0].text;
+    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: ')) {
+        try {
+          const json = JSON.parse(line.slice(6));
+          if (json.type === 'content_block_delta' && json.delta?.text) {
+            yield json.delta.text;
+          }
+        } catch {}
+      }
+    }
+  }
+}
+
+export { PROVIDER, sendMessage };

package/src/providers/deepseek.js

@@ -0,0 +1,53 @@
+const PROVIDER = {
+  name: 'deepseek',
+  free: false,
+  cheap: true,
+  streaming: true,
+  models: ['deepseek-chat', 'deepseek-coder'],
+  baseURL: 'https://api.deepseek.com/v1',
+};
+
+async function* sendMessage(apiKey, messages, model = 'deepseek-chat', 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' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) throw new Error(`DeepSeek 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/providers/gemini.js

@@ -0,0 +1,48 @@
+const PROVIDER = {
+  name: 'gemini',
+  free: true,
+  streaming: true,
+  models: ['gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-2.0-flash-exp'],
+  baseURL: 'https://generativelanguage.googleapis.com/v1beta',
+};
+
+async function* sendMessage(apiKey, messages, model = 'gemini-1.5-flash', stream = true) {
+  const url = `${PROVIDER.baseURL}/models/${model}:streamGenerateContent?key=${apiKey}&alt=sse`;
+  
+  const contents = messages.map(m => ({
+    role: m.role === 'assistant' ? 'model' : m.role,
+    parts: [{ text: m.content }]
+  }));
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ contents }),
+  });
+
+  if (!res.ok) throw new Error(`Gemini API error: ${res.status} ${res.statusText}`);
+
+  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: ')) {
+        try {
+          const json = JSON.parse(line.slice(6));
+          const text = json.candidates?.[0]?.content?.parts?.[0]?.text;
+          if (text) yield text;
+        } catch {}
+      }
+    }
+  }
+}
+
+export { PROVIDER, sendMessage };

package/src/providers/groq.js

@@ -0,0 +1,52 @@
+const PROVIDER = {
+  name: 'groq',
+  free: true,
+  streaming: true,
+  models: ['llama3-70b-8192', 'llama3-8b-8192', 'mixtral-8x7b-32768', 'gemma2-9b-it'],
+  baseURL: 'https://api.groq.com/openai/v1',
+};
+
+async function* sendMessage(apiKey, messages, model = 'llama3-70b-8192', 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' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) throw new Error(`Groq 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/providers/index.js

@@ -0,0 +1,39 @@
+import * as groq from './groq.js';
+import * as gemini from './gemini.js';
+import * as deepseek from './deepseek.js';
+import * as openrouter from './openrouter.js';
+import * as openai from './openai.js';
+import * as claude from './claude.js';
+
+const providers = { groq, gemini, deepseek, openrouter, openai, anthropic: claude };
+
+const PRIORITY = ['groq', 'gemini', 'deepseek', 'openrouter', 'openai', 'anthropic'];
+
+const capabilities = {
+  groq: { free: true, streaming: true, models: ['llama3-70b-8192', 'llama3-8b-8192', 'mixtral-8x7b-32768', 'gemma2-9b-it'], baseURL: 'https://api.groq.com/openai/v1' },
+  gemini: { free: true, streaming: true, models: ['gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-2.0-flash-exp'], baseURL: 'https://generativelanguage.googleapis.com/v1beta' },
+  deepseek: { free: false, cheap: true, streaming: true, models: ['deepseek-chat', 'deepseek-coder'], baseURL: 'https://api.deepseek.com/v1' },
+  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' },
+  anthropic: { free: false, streaming: true, models: ['claude-3-5-haiku-20241022', 'claude-3-5-sonnet-20241022'], baseURL: 'https://api.anthropic.com/v1' },
+  openai: { free: false, streaming: true, models: ['gpt-4o-mini', 'gpt-4o', 'gpt-3.5-turbo'], baseURL: 'https://api.openai.com/v1' },
+};
+
+async function sendMessage(apiKey, messages, model, stream = true) {
+  const [providerName] = model.split('/');
+  const provider = providers[providerName];
+  if (!provider) throw new Error(`Unknown provider: ${providerName}`);
+  
+  const modelName = model.includes('/') ? model.slice(model.indexOf('/') + 1) : model;
+  return provider.sendMessage(apiKey, messages, modelName, stream);
+}
+
+function listModels(providerName) {
+  const cap = capabilities[providerName];
+  return cap ? cap.models : [];
+}
+
+function getPriorityProviders(configuredProviders) {
+  return PRIORITY.filter(p => configuredProviders.includes(p));
+}
+
+export { sendMessage, listModels, getPriorityProviders, capabilities, providers };

package/src/providers/openai.js

@@ -0,0 +1,52 @@
+const PROVIDER = {
+  name: 'openai',
+  free: false,
+  streaming: true,
+  models: ['gpt-4o-mini', 'gpt-4o', 'gpt-3.5-turbo'],
+  baseURL: 'https://api.openai.com/v1',
+};
+
+async function* sendMessage(apiKey, messages, model = 'gpt-4o-mini', 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' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) throw new Error(`OpenAI 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 };