clarity-ai 1.0.0

package/src/ui/prompt.js

@@ -0,0 +1,49 @@
+import readline from 'readline';
+import { createReadStream, createWriteStream, existsSync } from 'fs';
+import paths from '../config/paths.js';
+import c from './colors.js';
+
+const HISTORY_FILE = paths.history;
+const MAX_HISTORY = 500;
+
+let history = [];
+
+function loadHistory() {
+  try {
+    if (existsSync(HISTORY_FILE)) {
+      const data = require('fs').readFileSync(HISTORY_FILE, 'utf8');
+      history = data.split('\n').filter(Boolean).slice(-MAX_HISTORY);
+    }
+  } catch {}
+}
+
+function saveHistory() {
+  try {
+    const dir = require('path').dirname(HISTORY_FILE);
+    if (!existsSync(dir)) require('fs').mkdirSync(dir, { recursive: true });
+    require('fs').writeFileSync(HISTORY_FILE, history.slice(-MAX_HISTORY).join('\n'));
+  } catch {}
+}
+
+function addToHistory(line) {
+  if (line && line !== history[history.length - 1]) {
+    history.push(line);
+    if (history.length > MAX_HISTORY) history = history.slice(-MAX_HISTORY);
+    saveHistory();
+  }
+}
+
+function createPrompt(onselect) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    history: history,
+    historySize: MAX_HISTORY,
+    terminal: true,
+    prompt: c.user('┃ you › '),
+  });
+
+  return rl;
+}
+
+export { createPrompt, loadHistory, addToHistory, history };

package/src/ui/spinner.js

@@ -0,0 +1,43 @@
+import ora from 'ora';
+import { isTermux } from '../utils/termux.js';
+
+const useUnicode = !isTermux() || process.env.TERMUX_VERSION !== undefined;
+const spinnerFrames = useUnicode
+  ? ['⣾','⣽','⣻','⢿','⡿','⣟','⣯','⣷']
+  : ['|','/','-','\\'];
+
+let spinner = null;
+
+const spin = {
+  start(text) {
+    if (spinner) spinner.stop();
+    spinner = ora({ text, spinner: { frames: spinnerFrames, interval: 80 } }).start();
+    return spin;
+  },
+  stop() {
+    if (spinner) { spinner.stop(); spinner = null; }
+    return spin;
+  },
+  succeed(text) {
+    if (spinner) { spinner.succeed(text); spinner = null; }
+    return spin;
+  },
+  fail(text) {
+    if (spinner) { spinner.fail(text); spinner = null; }
+    return spin;
+  },
+  info(text) {
+    if (spinner) { spinner.info(text); spinner = null; }
+    return spin;
+  },
+  warn(text) {
+    if (spinner) { spinner.warn(text); spinner = null; }
+    return spin;
+  },
+  update(text) {
+    if (spinner) spinner.text = text;
+    return spin;
+  }
+};
+
+export default spin;

package/src/utils/logger.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import { isTermux } from './termux.js';
+
+const logLevels = { debug: 0, info: 1, warn: 2, error: 3 };
+let currentLevel = 'info';
+
+function setLevel(level) {
+  if (logLevels[level] !== undefined) currentLevel = level;
+}
+
+function shouldLog(level) {
+  return logLevels[level] >= logLevels[currentLevel];
+}
+
+function timestamp() {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19);
+}
+
+function debug(...args) {
+  if (!shouldLog('debug')) return;
+  console.error(chalk.dim(`[${timestamp()}] [DEBUG]`), ...args);
+}
+
+function info(...args) {
+  if (!shouldLog('info')) return;
+  console.error(chalk.hex('#44aaff')(`[${timestamp()}] [INFO]`), ...args);
+}
+
+function warn(...args) {
+  if (!shouldLog('warn')) return;
+  console.error(chalk.hex('#ffcc00')(`[${timestamp()}] [WARN]`), ...args);
+}
+
+function error(...args) {
+  if (!shouldLog('error')) return;
+  console.error(chalk.hex('#ff4466')(`[${timestamp()}] [ERROR]`), ...args);
+}
+
+const logger = { setLevel, debug, info, warn, error };
+export default logger;

package/src/utils/markdown.js

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import cliTable3 from 'cli-table3';
+import stripAnsi from 'strip-ansi';
+import wrapAnsi from 'wrap-ansi';
+
+marked.use(markedTerminal({
+  heading: chalk.bold.hex('#f0f0ff'),
+  code: chalk.hex('#aaffcc'),
+  blockquote: chalk.dim,
+  hr: chalk.dim('─'),
+  strong: chalk.bold.hex('#f0f0ff'),
+  em: chalk.dim.italic,
+  link: chalk.hex('#00d2ff').underline,
+  listitem: chalk.hex('#7b2ff7'),
+  table: cliTable3,
+  tableOptions: { style: { head: ['#00d2ff'], border: ['#555577'] } }
+}));
+
+function renderMarkdown(text) {
+  return marked.parse(text);
+}
+
+export { renderMarkdown };

package/src/utils/termux.js

@@ -0,0 +1,38 @@
+function isTermux() {
+  return process.env.PREFIX?.includes('com.termux') ||
+         process.env.TERMUX_VERSION !== undefined ||
+         process.env.HOME?.includes('com.termux');
+}
+
+function getTermuxInfo() {
+  return {
+    isTermux: isTermux(),
+    version: process.env.TERMUX_VERSION || 'unknown',
+    prefix: process.env.PREFIX || '/usr',
+    home: process.env.HOME,
+    storage: process.env.HOME ? `${process.env.HOME}/storage` : null
+  };
+}
+
+async function openURL(url) {
+  if (isTermux()) {
+    const { execSync } = await import('child_process');
+    execSync(`termux-open-url "${url}"`);
+  } else {
+    const { default: open } = await import('open');
+    await open(url);
+  }
+}
+
+function hasTermuxAPI() {
+  if (!isTermux()) return false;
+  try {
+    const { execSync } = require('child_process');
+    execSync('which termux-notification', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export { isTermux, getTermuxInfo, openURL, hasTermuxAPI };

package/src/utils/version-check.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import semver from 'semver';
+import { isTermux } from './termux.js';
+
+const MIN_NODE = '18.0.0';
+
+function checkNodeVersion() {
+  const current = process.versions.node;
+  if (!semver.satisfies(current, `>=${MIN_NODE}`)) {
+    console.error(boxen(
+      chalk.hex('#ff4466').bold(`[ERROR] Node.js ${MIN_NODE}+ required. You have v${current}\n`) +
+      chalk.hex('#ffcc00')(isTermux() ? 'Termux: pkg install nodejs-lts' : 'Install Node.js 18+ from https://nodejs.org'),
+      { padding: 1, borderColor: 'red', borderStyle: 'round' }
+    ));
+    process.exit(1);
+  }
+}
+
+async function checkDependencies(pkgDir) {
+  const { readFileSync, existsSync } = await import('fs');
+  const { resolve } = await import('path');
+  const pkgPath = resolve(pkgDir, 'package.json');
+  if (!existsSync(pkgPath)) return true;
+  
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  const deps = { ...pkg.dependencies, ...pkg.peerDependencies };
+  const missing = [];
+  
+  for (const dep of Object.keys(deps || {})) {
+    try {
+      await import(dep);
+    } catch {
+      missing.push(dep);
+    }
+  }
+  
+  if (missing.length > 0) {
+    console.warn(boxen(
+      chalk.hex('#ffcc00').bold('Missing dependencies: ') + missing.join(', ') + '\n' +
+      chalk.dim('Auto-installing...'),
+      { padding: 1, borderColor: 'yellow', borderStyle: 'round' }
+    ));
+    const { execSync } = await import('child_process');
+    execSync('npm install', { cwd: pkgDir, stdio: 'inherit' });
+  }
+  return true;
+}
+
+async function checkUpdates() {
+  try {
+    const pkg = await import('../../package.json', { assert: { type: 'json' } });
+    const current = pkg.default.version;
+    const res = await fetch('https://registry.npmjs.org/clarity-ai/latest');
+    const data = await res.json();
+    if (data.version && semver.gt(data.version, current)) {
+      console.log(boxen(
+        chalk.hex('#00d2ff').bold(`clarity-ai v${current} → v${data.version}\n`) +
+        chalk.hex('#7b2ff7')('Run: npm install -g clarity-ai'),
+        { padding: 1, borderColor: 'cyan', borderStyle: 'round' }
+      ));
+    }
+  } catch {}
+}
+
+export { checkNodeVersion, checkDependencies, checkUpdates };