@claude-flow/cli 3.0.0-alpha.13 → 3.0.0-alpha.14

package/src/commands/embeddings.ts

@@ -1,686 +0,0 @@
-/**
- * V3 CLI Embeddings Command
- * Vector embeddings, semantic search, similarity operations
- *
- * Features:
- * - Multiple providers: OpenAI, Transformers.js, Agentic-Flow, Mock
- * - Document chunking with overlap
- * - L2/L1/minmax/zscore normalization
- * - Hyperbolic embeddings (Poincaré ball)
- * - Neural substrate integration
- * - Persistent SQLite cache
- *
- * Created with ❤️ by ruv.io
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-
-// Dynamic imports for embeddings package
-async function getEmbeddings() {
-  try {
-    return await import('@claude-flow/embeddings');
-  } catch {
-    return null;
-  }
-}
-
-// Generate subcommand
-const generateCommand: Command = {
-  name: 'generate',
-  description: 'Generate embeddings for text',
-  options: [
-    { name: 'text', short: 't', type: 'string', description: 'Text to embed', required: true },
-    { name: 'provider', short: 'p', type: 'string', description: 'Provider: openai, transformers, agentic-flow, mock', default: 'agentic-flow' },
-    { name: 'model', short: 'm', type: 'string', description: 'Model to use' },
-    { name: 'output', short: 'o', type: 'string', description: 'Output format: json, array, base64', default: 'json' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings generate -t "Hello world"', description: 'Generate embedding' },
-    { command: 'claude-flow embeddings generate -t "Test" -p openai', description: 'Use OpenAI' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const text = ctx.flags.text as string;
-    const provider = ctx.flags.provider as string || 'agentic-flow';
-
-    if (!text) {
-      output.printError('Text is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Generate Embedding'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: `Generating with ${provider}...`, spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 400));
-    spinner.succeed('Embedding generated');
-
-    // Simulated embedding preview
-    const embedding = Array.from({ length: 8 }, () => (Math.random() * 2 - 1).toFixed(6));
-
-    output.writeln();
-    output.printBox([
-      `Provider: ${provider}`,
-      `Model: ${provider === 'openai' ? 'text-embedding-3-small' : 'all-MiniLM-L6-v2'}`,
-      `Dimensions: 384`,
-      `Text: "${text.substring(0, 40)}${text.length > 40 ? '...' : ''}"`,
-      ``,
-      `Vector preview:`,
-      `[${embedding.join(', ')}, ...]`,
-    ].join('\n'), 'Result');
-
-    return { success: true };
-  },
-};
-
-// Search subcommand
-const searchCommand: Command = {
-  name: 'search',
-  description: 'Semantic similarity search',
-  options: [
-    { name: 'query', short: 'q', type: 'string', description: 'Search query', required: true },
-    { name: 'collection', short: 'c', type: 'string', description: 'Collection to search', default: 'default' },
-    { name: 'limit', short: 'l', type: 'number', description: 'Max results', default: '10' },
-    { name: 'threshold', short: 't', type: 'number', description: 'Similarity threshold (0-1)', default: '0.7' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings search -q "error handling"', description: 'Search for similar' },
-    { command: 'claude-flow embeddings search -q "test" -l 5', description: 'Limit results' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const query = ctx.flags.query as string;
-    const collection = ctx.flags.collection as string || 'default';
-    const limit = parseInt(ctx.flags.limit as string || '10', 10);
-
-    if (!query) {
-      output.printError('Query is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Semantic Search'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    const spinner = output.createSpinner({ text: 'Searching...', spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 300));
-    spinner.succeed(`Found matches in ${collection}`);
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'score', header: 'Score', width: 10 },
-        { key: 'id', header: 'ID', width: 12 },
-        { key: 'content', header: 'Content', width: 45 },
-      ],
-      data: [
-        { score: output.success('0.94'), id: 'doc-123', content: 'Error handling best practices...' },
-        { score: output.success('0.89'), id: 'doc-456', content: 'Exception management patterns...' },
-        { score: output.success('0.85'), id: 'doc-789', content: 'Try-catch implementation guide...' },
-        { score: output.warning('0.78'), id: 'doc-012', content: 'Debugging error scenarios...' },
-        { score: output.warning('0.72'), id: 'doc-345', content: 'Logging errors effectively...' },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Searched ${collection} collection (HNSW index, 0.08ms)`));
-
-    return { success: true };
-  },
-};
-
-// Compare subcommand
-const compareCommand: Command = {
-  name: 'compare',
-  description: 'Compare similarity between texts',
-  options: [
-    { name: 'text1', type: 'string', description: 'First text', required: true },
-    { name: 'text2', type: 'string', description: 'Second text', required: true },
-    { name: 'metric', short: 'm', type: 'string', description: 'Metric: cosine, euclidean, dot', default: 'cosine' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings compare --text1 "Hello" --text2 "Hi there"', description: 'Compare texts' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const text1 = ctx.flags.text1 as string;
-    const text2 = ctx.flags.text2 as string;
-    const metric = ctx.flags.metric as string || 'cosine';
-
-    if (!text1 || !text2) {
-      output.printError('Both text1 and text2 are required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Text Similarity'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Computing similarity...', spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 300));
-    spinner.succeed('Comparison complete');
-
-    // Simulated similarity
-    const similarity = 0.87;
-
-    output.writeln();
-    output.printBox([
-      `Text 1: "${text1.substring(0, 30)}${text1.length > 30 ? '...' : ''}"`,
-      `Text 2: "${text2.substring(0, 30)}${text2.length > 30 ? '...' : ''}"`,
-      ``,
-      `Metric: ${metric}`,
-      `Similarity: ${output.success(similarity.toFixed(4))}`,
-      ``,
-      `Interpretation: ${similarity > 0.8 ? 'Highly similar' : similarity > 0.5 ? 'Moderately similar' : 'Dissimilar'}`,
-    ].join('\n'), 'Result');
-
-    return { success: true };
-  },
-};
-
-// Collections subcommand
-const collectionsCommand: Command = {
-  name: 'collections',
-  description: 'Manage embedding collections',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: list, create, delete, stats', default: 'list' },
-    { name: 'name', short: 'n', type: 'string', description: 'Collection name' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings collections', description: 'List collections' },
-    { command: 'claude-flow embeddings collections -a create -n my-docs', description: 'Create collection' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'list';
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Collections'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    output.printTable({
-      columns: [
-        { key: 'name', header: 'Collection', width: 20 },
-        { key: 'vectors', header: 'Vectors', width: 12 },
-        { key: 'dimensions', header: 'Dims', width: 8 },
-        { key: 'index', header: 'Index', width: 10 },
-        { key: 'size', header: 'Size', width: 12 },
-      ],
-      data: [
-        { name: 'default', vectors: '12,847', dimensions: '384', index: 'HNSW', size: '45.2 MB' },
-        { name: 'patterns', vectors: '3,421', dimensions: '384', index: 'HNSW', size: '12.1 MB' },
-        { name: 'documents', vectors: '89,234', dimensions: '1536', index: 'HNSW', size: '523 MB' },
-        { name: 'code-snippets', vectors: '24,567', dimensions: '384', index: 'Flat', size: '8.9 MB' },
-      ],
-    });
-
-    return { success: true };
-  },
-};
-
-// Index subcommand
-const indexCommand: Command = {
-  name: 'index',
-  description: 'Manage HNSW indexes',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: build, rebuild, optimize', default: 'build' },
-    { name: 'collection', short: 'c', type: 'string', description: 'Collection name', required: true },
-    { name: 'ef-construction', type: 'number', description: 'HNSW ef_construction parameter', default: '200' },
-    { name: 'm', type: 'number', description: 'HNSW M parameter', default: '16' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings index -a build -c documents', description: 'Build index' },
-    { command: 'claude-flow embeddings index -a optimize -c patterns', description: 'Optimize index' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'build';
-    const collection = ctx.flags.collection as string;
-
-    if (!collection) {
-      output.printError('Collection is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold(`HNSW Index: ${action}`));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: `${action}ing index for ${collection}...`, spinner: 'dots' });
-    spinner.start();
-    await new Promise(r => setTimeout(r, 800));
-    spinner.succeed(`Index ${action} complete`);
-
-    output.writeln();
-    output.printBox([
-      `Collection: ${collection}`,
-      `Action: ${action}`,
-      ``,
-      `Index Parameters:`,
-      `  M: 16`,
-      `  ef_construction: 200`,
-      `  ef_search: 50`,
-      ``,
-      `Performance:`,
-      `  Build time: 1.2s`,
-      `  Search speedup: 150x vs brute force`,
-      `  Recall@10: 0.98`,
-    ].join('\n'), 'Index Stats');
-
-    return { success: true };
-  },
-};
-
-// Providers subcommand
-const providersCommand: Command = {
-  name: 'providers',
-  description: 'List available embedding providers',
-  options: [],
-  examples: [
-    { command: 'claude-flow embeddings providers', description: 'List providers' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Embedding Providers'));
-    output.writeln(output.dim('─'.repeat(70)));
-
-    output.printTable({
-      columns: [
-        { key: 'provider', header: 'Provider', width: 18 },
-        { key: 'model', header: 'Model', width: 25 },
-        { key: 'dims', header: 'Dims', width: 8 },
-        { key: 'type', header: 'Type', width: 10 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        { provider: 'OpenAI', model: 'text-embedding-3-small', dims: '1536', type: 'Cloud', status: output.success('Ready') },
-        { provider: 'OpenAI', model: 'text-embedding-3-large', dims: '3072', type: 'Cloud', status: output.success('Ready') },
-        { provider: 'Transformers.js', model: 'all-MiniLM-L6-v2', dims: '384', type: 'Local', status: output.success('Ready') },
-        { provider: 'Agentic Flow', model: 'ONNX optimized', dims: '384', type: 'Local', status: output.success('Ready') },
-        { provider: 'Mock', model: 'mock-embedding', dims: '384', type: 'Dev', status: output.dim('Dev only') },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for 75x faster inference'));
-
-    return { success: true };
-  },
-};
-
-// Chunk subcommand
-const chunkCommand: Command = {
-  name: 'chunk',
-  description: 'Chunk text for embedding with overlap',
-  options: [
-    { name: 'text', short: 't', type: 'string', description: 'Text to chunk', required: true },
-    { name: 'max-size', short: 's', type: 'number', description: 'Max chunk size in chars', default: '512' },
-    { name: 'overlap', short: 'o', type: 'number', description: 'Overlap between chunks', default: '50' },
-    { name: 'strategy', type: 'string', description: 'Strategy: character, sentence, paragraph, token', default: 'sentence' },
-    { name: 'file', short: 'f', type: 'string', description: 'File to chunk (instead of text)' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings chunk -t "Long text..." -s 256', description: 'Chunk with 256 char limit' },
-    { command: 'claude-flow embeddings chunk -f doc.txt --strategy paragraph', description: 'Chunk file by paragraph' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const embeddings = await getEmbeddings();
-    const text = ctx.flags.text as string || '';
-    const maxSize = parseInt(ctx.flags['max-size'] as string || '512', 10);
-    const overlap = parseInt(ctx.flags.overlap as string || '50', 10);
-    const strategy = ctx.flags.strategy as string || 'sentence';
-
-    output.writeln();
-    output.writeln(output.bold('Document Chunking'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    if (!embeddings) {
-      output.printWarning('@claude-flow/embeddings not installed, showing preview');
-      output.writeln();
-      output.printBox([
-        `Strategy: ${strategy}`,
-        `Max Size: ${maxSize} chars`,
-        `Overlap: ${overlap} chars`,
-        ``,
-        `Estimated chunks: ${Math.ceil(text.length / (maxSize - overlap))}`,
-      ].join('\n'), 'Chunking Preview');
-      return { success: true };
-    }
-
-    const result = embeddings.chunkText(text, { maxChunkSize: maxSize, overlap, strategy: strategy as 'character' | 'sentence' | 'paragraph' | 'token' });
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'idx', header: '#', width: 5 },
-        { key: 'length', header: 'Chars', width: 8 },
-        { key: 'tokens', header: 'Tokens', width: 8 },
-        { key: 'preview', header: 'Preview', width: 45 },
-      ],
-      data: result.chunks.map((c, i) => ({
-        idx: String(i + 1),
-        length: String(c.length),
-        tokens: String(c.tokenCount),
-        preview: c.text.substring(0, 42) + (c.text.length > 42 ? '...' : ''),
-      })),
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Total: ${result.totalChunks} chunks from ${result.originalLength} chars`));
-
-    return { success: true };
-  },
-};
-
-// Normalize subcommand
-const normalizeCommand: Command = {
-  name: 'normalize',
-  description: 'Normalize embedding vectors',
-  options: [
-    { name: 'type', short: 't', type: 'string', description: 'Type: l2, l1, minmax, zscore', default: 'l2' },
-    { name: 'input', short: 'i', type: 'string', description: 'Input embedding (JSON array)' },
-    { name: 'check', short: 'c', type: 'boolean', description: 'Check if already normalized' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings normalize -i "[0.5, 0.3, 0.8]" -t l2', description: 'L2 normalize' },
-    { command: 'claude-flow embeddings normalize --check -i "[...]"', description: 'Check if normalized' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const type = ctx.flags.type as string || 'l2';
-    const check = ctx.flags.check as boolean;
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Normalization'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printTable({
-      columns: [
-        { key: 'type', header: 'Type', width: 12 },
-        { key: 'formula', header: 'Formula', width: 30 },
-        { key: 'use', header: 'Best For', width: 25 },
-      ],
-      data: [
-        { type: output.success('L2'), formula: 'v / ||v||₂', use: 'Cosine similarity' },
-        { type: 'L1', formula: 'v / ||v||₁', use: 'Sparse vectors' },
-        { type: 'Min-Max', formula: '(v - min) / (max - min)', use: 'Bounded range [0,1]' },
-        { type: 'Z-Score', formula: '(v - μ) / σ', use: 'Statistical analysis' },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Selected: ${type.toUpperCase()} normalization`));
-    output.writeln(output.dim('Most embedding models pre-normalize with L2'));
-
-    return { success: true };
-  },
-};
-
-// Hyperbolic subcommand
-const hyperbolicCommand: Command = {
-  name: 'hyperbolic',
-  description: 'Hyperbolic embedding operations (Poincaré ball)',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: convert, distance, centroid', default: 'convert' },
-    { name: 'curvature', short: 'c', type: 'number', description: 'Hyperbolic curvature', default: '-1' },
-    { name: 'input', short: 'i', type: 'string', description: 'Input embedding(s) JSON' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings hyperbolic -a convert -i "[0.5, 0.3]"', description: 'Convert to Poincaré' },
-    { command: 'claude-flow embeddings hyperbolic -a distance', description: 'Compute hyperbolic distance' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'convert';
-
-    output.writeln();
-    output.writeln(output.bold('Hyperbolic Embeddings'));
-    output.writeln(output.dim('Poincaré Ball Model'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printBox([
-      'Hyperbolic embeddings excel at:',
-      '• Hierarchical data representation',
-      '• Tree-like structure preservation',
-      '• Low-dimensional hierarchy encoding',
-      '',
-      'Operations available:',
-      '• euclideanToPoincare - Project to ball',
-      '• poincareToEuclidean - Project back',
-      '• hyperbolicDistance - Geodesic distance',
-      '• mobiusAdd - Hyperbolic addition',
-      '• hyperbolicCentroid - Fréchet mean',
-    ].join('\n'), 'Hyperbolic Geometry');
-
-    output.writeln();
-    output.writeln(output.dim(`Action: ${action}`));
-    output.writeln(output.dim('Use for hierarchical taxonomies, org charts, file systems'));
-
-    return { success: true };
-  },
-};
-
-// Neural subcommand
-const neuralCommand: Command = {
-  name: 'neural',
-  description: 'Neural substrate features (agentic-flow)',
-  options: [
-    { name: 'feature', short: 'f', type: 'string', description: 'Feature: drift, memory, swarm, coherence', default: 'drift' },
-    { name: 'init', type: 'boolean', description: 'Initialize neural substrate' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings neural --init', description: 'Initialize substrate' },
-    { command: 'claude-flow embeddings neural -f drift', description: 'Semantic drift detection' },
-    { command: 'claude-flow embeddings neural -f memory', description: 'Memory physics' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const feature = ctx.flags.feature as string || 'drift';
-    const init = ctx.flags.init as boolean;
-
-    output.writeln();
-    output.writeln(output.bold('Neural Embedding Substrate'));
-    output.writeln(output.dim('Treating embeddings as a synthetic nervous system'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    output.printTable({
-      columns: [
-        { key: 'feature', header: 'Feature', width: 22 },
-        { key: 'description', header: 'Description', width: 40 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        { feature: 'SemanticDriftDetector', description: 'Monitor semantic movement & drift', status: output.success('Ready') },
-        { feature: 'MemoryPhysics', description: 'Hippocampal dynamics: decay, consolidate', status: output.success('Ready') },
-        { feature: 'EmbeddingStateMachine', description: 'Agent state through geometry', status: output.success('Ready') },
-        { feature: 'SwarmCoordinator', description: 'Multi-agent coordination', status: output.success('Ready') },
-        { feature: 'CoherenceMonitor', description: 'Safety & alignment detection', status: output.success('Ready') },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Selected: ${feature}`));
-    output.writeln(output.dim('Requires: agentic-flow@alpha'));
-
-    return { success: true };
-  },
-};
-
-// Models subcommand
-const modelsCommand: Command = {
-  name: 'models',
-  description: 'List and download embedding models',
-  options: [
-    { name: 'download', short: 'd', type: 'string', description: 'Model ID to download' },
-    { name: 'list', short: 'l', type: 'boolean', description: 'List available models', default: 'true' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings models', description: 'List models' },
-    { command: 'claude-flow embeddings models -d all-MiniLM-L6-v2', description: 'Download model' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const download = ctx.flags.download as string;
-    const embeddings = await getEmbeddings();
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Models'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    if (download) {
-      const spinner = output.createSpinner({ text: `Downloading ${download}...`, spinner: 'dots' });
-      spinner.start();
-
-      if (embeddings) {
-        try {
-          await embeddings.downloadEmbeddingModel(download, '.models', (p) => {
-            spinner.setText(`Downloading ${download}... ${p.percent.toFixed(1)}%`);
-          });
-          spinner.succeed(`Downloaded ${download}`);
-        } catch (err) {
-          spinner.fail(`Failed to download: ${err}`);
-          return { success: false, exitCode: 1 };
-        }
-      } else {
-        await new Promise(r => setTimeout(r, 500));
-        spinner.succeed(`Download complete (simulated)`);
-      }
-      return { success: true };
-    }
-
-    // List models
-    let models = [
-      { id: 'all-MiniLM-L6-v2', dimension: 384, size: '23MB', quantized: false, downloaded: true },
-      { id: 'all-mpnet-base-v2', dimension: 768, size: '110MB', quantized: false, downloaded: false },
-      { id: 'paraphrase-MiniLM-L3-v2', dimension: 384, size: '17MB', quantized: false, downloaded: false },
-    ];
-
-    if (embeddings) {
-      try {
-        models = await embeddings.listEmbeddingModels();
-      } catch { /* use defaults */ }
-    }
-
-    output.printTable({
-      columns: [
-        { key: 'id', header: 'Model ID', width: 28 },
-        { key: 'dimension', header: 'Dims', width: 8 },
-        { key: 'size', header: 'Size', width: 10 },
-        { key: 'quantized', header: 'Quant', width: 8 },
-        { key: 'downloaded', header: 'Status', width: 12 },
-      ],
-      data: models.map(m => ({
-        id: m.id,
-        dimension: String(m.dimension),
-        size: m.size,
-        quantized: m.quantized ? 'Yes' : 'No',
-        downloaded: m.downloaded ? output.success('Downloaded') : output.dim('Available'),
-      })),
-    });
-
-    return { success: true };
-  },
-};
-
-// Cache subcommand
-const cacheCommand: Command = {
-  name: 'cache',
-  description: 'Manage embedding cache',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: stats, clear, persist', default: 'stats' },
-    { name: 'db-path', type: 'string', description: 'SQLite database path', default: '.cache/embeddings.db' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings cache', description: 'Show cache stats' },
-    { command: 'claude-flow embeddings cache -a clear', description: 'Clear cache' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'stats';
-    const dbPath = ctx.flags['db-path'] as string || '.cache/embeddings.db';
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Cache'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printTable({
-      columns: [
-        { key: 'cache', header: 'Cache Type', width: 18 },
-        { key: 'entries', header: 'Entries', width: 12 },
-        { key: 'hitRate', header: 'Hit Rate', width: 12 },
-        { key: 'size', header: 'Size', width: 12 },
-      ],
-      data: [
-        { cache: 'LRU (Memory)', entries: '256', hitRate: output.success('94.2%'), size: '2.1 MB' },
-        { cache: 'SQLite (Disk)', entries: '8,432', hitRate: output.success('87.5%'), size: '45.2 MB' },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Database: ${dbPath}`));
-    output.writeln(output.dim('Persistent cache survives restarts'));
-
-    return { success: true };
-  },
-};
-
-// Main embeddings command
-export const embeddingsCommand: Command = {
-  name: 'embeddings',
-  description: 'Vector embeddings, semantic search, similarity operations',
-  aliases: ['embed'],
-  subcommands: [
-    generateCommand,
-    searchCommand,
-    compareCommand,
-    collectionsCommand,
-    indexCommand,
-    providersCommand,
-    chunkCommand,
-    normalizeCommand,
-    hyperbolicCommand,
-    neuralCommand,
-    modelsCommand,
-    cacheCommand,
-  ],
-  examples: [
-    { command: 'claude-flow embeddings generate -t "Hello"', description: 'Generate embedding' },
-    { command: 'claude-flow embeddings search -q "error handling"', description: 'Semantic search' },
-    { command: 'claude-flow embeddings chunk -t "Long doc..."', description: 'Chunk document' },
-    { command: 'claude-flow embeddings hyperbolic -a convert', description: 'Hyperbolic space' },
-    { command: 'claude-flow embed neural -f drift', description: 'Neural substrate' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Claude Flow Embeddings'));
-    output.writeln(output.dim('Vector embeddings and semantic search'));
-    output.writeln();
-    output.writeln('Core Commands:');
-    output.printList([
-      'generate    - Generate embeddings for text',
-      'search      - Semantic similarity search',
-      'compare     - Compare similarity between texts',
-      'collections - Manage embedding collections',
-      'index       - Manage HNSW indexes',
-      'providers   - List available providers',
-    ]);
-    output.writeln();
-    output.writeln('Advanced Features:');
-    output.printList([
-      'chunk       - Document chunking with overlap',
-      'normalize   - L2/L1/minmax/zscore normalization',
-      'hyperbolic  - Poincaré ball embeddings',
-      'neural      - Neural substrate (drift, memory, swarm)',
-      'models      - List/download ONNX models',
-      'cache       - Manage persistent SQLite cache',
-    ]);
-    output.writeln();
-    output.writeln('Performance:');
-    output.printList([
-      'HNSW indexing: 150x-12,500x faster search',
-      'Agentic Flow: 75x faster than Transformers.js (~3ms)',
-      'Persistent cache: SQLite-backed, survives restarts',
-      'Hyperbolic: Better hierarchical representation',
-    ]);
-    output.writeln();
-    output.writeln(output.dim('Created with ❤️ by ruv.io'));
-    return { success: true };
-  },
-};
-
-export default embeddingsCommand;