ex-brain 0.1.0 → 0.2.0

package/src/utils/progress.ts

@@ -0,0 +1,171 @@
+/**
+ * Progress indicator with spinner animation for long-running operations.
+ */
+
+export interface ProgressIndicator {
+  start(message: string): void;
+  update(message: string): void;
+  succeed(message?: string): void;
+  fail(message?: string): void;
+  stop(): void;
+}
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL = 80;
+
+/**
+ * Create a progress indicator with spinner animation.
+ * @param stream Output stream (default: process.stderr)
+ */
+export function createProgress(stream: NodeJS.WritableStream = process.stderr): ProgressIndicator {
+  let frameIndex = 0;
+  let interval: Timer | null = null;
+  let currentMessage = '';
+  let isRunning = false;
+
+  function clearLine() {
+    stream.write('\r\x1b[K');
+  }
+
+  function render() {
+    if (!isRunning) return;
+    const frame = SPINNER_FRAMES[frameIndex];
+    clearLine();
+    stream.write(`\x1b[36m${frame}\x1b[0m ${currentMessage}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+  }
+
+  function start(message: string) {
+    if (isRunning) stop();
+    currentMessage = message;
+    isRunning = true;
+    frameIndex = 0;
+    render();
+    interval = setInterval(render, SPINNER_INTERVAL);
+  }
+
+  function update(message: string) {
+    currentMessage = message;
+    if (!isRunning) {
+      start(message);
+    }
+  }
+
+  function stop() {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    if (isRunning) {
+      clearLine();
+      isRunning = false;
+    }
+  }
+
+  function succeed(message?: string) {
+    stop();
+    const text = message || currentMessage;
+    stream.write(`\x1b[32m✓\x1b[0m ${text}\n`);
+  }
+
+  function fail(message?: string) {
+    stop();
+    const text = message || currentMessage;
+    stream.write(`\x1b[31m✗\x1b[0m ${text}\n`);
+  }
+
+  return { start, update, succeed, fail, stop };
+}
+
+/**
+ * Simple spinner for async operations.
+ * Usage: const done = spinner.start('Processing...'); await task(); done('Done');
+ */
+export function spinner(stream: NodeJS.WritableStream = process.stderr) {
+  const progress = createProgress(stream);
+  
+  return {
+    start(message: string) {
+      progress.start(message);
+      return (finalMessage?: string) => {
+        progress.succeed(finalMessage);
+      };
+    },
+    fail(message: string) {
+      progress.fail(message);
+    },
+  };
+}
+
+/**
+ * Progress bar for batch operations.
+ */
+export function progressBar(total: number, stream: NodeJS.WritableStream = process.stderr) {
+  let current = 0;
+  let lastPercent = -1;
+
+  function render(label: string) {
+    const percent = Math.floor((current / total) * 100);
+    if (percent === lastPercent) return;
+    lastPercent = percent;
+
+    const barWidth = 30;
+    const filled = Math.floor((current / total) * barWidth);
+    const empty = barWidth - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+
+    stream.write(`\r\x1b[K${label} [${bar}] ${percent}% (${current}/${total})`);
+  }
+
+  return {
+    start(label: string) {
+      current = 0;
+      lastPercent = -1;
+      render(label);
+    },
+    increment(label: string) {
+      current++;
+      render(label);
+    },
+    done(label: string) {
+      current = total;
+      render(label);
+      stream.write('\n');
+    },
+  };
+}
+
+/**
+ * Format duration in human-readable form.
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Measure and report operation duration.
+ */
+export async function withProgress<T>(
+  message: string,
+  fn: () => Promise<T>,
+  stream: NodeJS.WritableStream = process.stderr
+): Promise<T> {
+  const progress = createProgress(stream);
+  const start = Date.now();
+  
+  progress.start(message);
+  
+  try {
+    const result = await fn();
+    const duration = formatDuration(Date.now() - start);
+    progress.succeed(`${message} (${duration})`);
+    return result;
+  } catch (error) {
+    progress.fail(`${message} - failed`);
+    throw error;
+  }
+}

package/src/utils/query-sanitizer.ts

@@ -0,0 +1,63 @@
+/**
+ * Sanitize query strings for seekdb to prevent JSON parse errors.
+ * 
+ * seekdb's internal parser has issues with certain characters:
+ * - Single quotes break JSON string parsing
+ * - Control characters may crash the native module
+ * - Special characters need proper escaping
+ */
+
+/**
+ * Sanitize a search query string for safe use with seekdb.
+ * Removes or replaces characters that cause parse errors.
+ */
+export function sanitizeQuery(query: string): string {
+  if (!query || typeof query !== 'string') {
+    return '';
+  }
+  
+  return query
+    // Remove problematic characters that break JSON parsing
+    .replace(/'/g, '')           // Remove single quotes (main issue)
+    .replace(/"/g, '')           // Remove double quotes
+    .replace(/\\/g, '')          // Remove backslashes
+    .replace(/\x00/g, '')        // Remove null bytes
+    
+    // Replace control characters with spaces
+    .replace(/\n/g, ' ')         // Replace newlines
+    .replace(/\r/g, ' ')         // Replace carriage returns
+    .replace(/\t/g, ' ')         // Replace tabs
+    
+    // Collapse multiple spaces into one
+    .replace(/\s+/g, ' ')
+    
+    // Trim leading/trailing whitespace
+    .trim();
+}
+
+/**
+ * Fallback search using SQL LIKE when vector search fails.
+ * More robust but less accurate than vector search.
+ */
+export function safeSearchPattern(query: string): string {
+  const sanitized = sanitizeQuery(query);
+  
+  // For SQL LIKE, we need to escape % and _ wildcards
+  return sanitized
+    .replace(/%/g, '\\%')
+    .replace(/_/g, '\\_');
+}
+
+/**
+ * Validate that a query string is safe for seekdb operations.
+ * Returns true if the query is safe, false otherwise.
+ */
+export function isQuerySafe(query: string): boolean {
+  if (!query || query.length === 0) {
+    return false;
+  }
+  
+  // Check for characters that cause parse errors
+  const dangerousChars = /['"\\\x00]/;
+  return !dangerousChars.test(query);
+}