@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/commands/memory.ts

@@ -1,1063 +0,0 @@
-/**
- * V3 CLI Memory Command
- * Memory operations for AgentDB integration
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { select, confirm, input } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-
-// Memory backends
-const BACKENDS = [
-  { value: 'agentdb', label: 'AgentDB', hint: 'Vector database with HNSW indexing (150x-12,500x faster)' },
-  { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
-  { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
-  { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
-];
-
-// Store command
-const storeCommand: Command = {
-  name: 'store',
-  description: 'Store data in memory',
-  options: [
-    {
-      name: 'key',
-      short: 'k',
-      description: 'Storage key/namespace',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'value',
-      short: 'v',
-      description: 'Value to store',
-      type: 'string'
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Memory namespace',
-      type: 'string',
-      default: 'default'
-    },
-    {
-      name: 'ttl',
-      description: 'Time to live in seconds',
-      type: 'number'
-    },
-    {
-      name: 'tags',
-      description: 'Comma-separated tags',
-      type: 'string'
-    },
-    {
-      name: 'vector',
-      description: 'Store as vector embedding',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory store -k "api/auth" -v "JWT implementation"', description: 'Store text' },
-    { command: 'claude-flow memory store -k "pattern/singleton" --vector', description: 'Store vector' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const key = ctx.flags.key as string;
-    let value = ctx.flags.value as string || ctx.args[0];
-    const namespace = ctx.flags.namespace as string;
-    const ttl = ctx.flags.ttl as number;
-    const tags = ctx.flags.tags ? (ctx.flags.tags as string).split(',') : [];
-    const asVector = ctx.flags.vector as boolean;
-
-    if (!key) {
-      output.printError('Key is required. Use --key or -k');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!value && ctx.interactive) {
-      value = await input({
-        message: 'Enter value to store:',
-        validate: (v) => v.length > 0 || 'Value is required'
-      });
-    }
-
-    if (!value) {
-      output.printError('Value is required. Use --value or -v');
-      return { success: false, exitCode: 1 };
-    }
-
-    const storeData = {
-      key,
-      namespace,
-      value,
-      ttl,
-      tags,
-      asVector,
-      storedAt: new Date().toISOString(),
-      size: Buffer.byteLength(value, 'utf8')
-    };
-
-    output.printInfo(`Storing in ${namespace}/${key}...`);
-
-    if (asVector) {
-      output.writeln(output.dim('  Generating embedding vector...'));
-      output.writeln(output.dim('  Indexing with HNSW (M=16, ef=200)...'));
-    }
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'property', header: 'Property', width: 15 },
-        { key: 'val', header: 'Value', width: 40 }
-      ],
-      data: [
-        { property: 'Key', val: key },
-        { property: 'Namespace', val: namespace },
-        { property: 'Size', val: `${storeData.size} bytes` },
-        { property: 'TTL', val: ttl ? `${ttl}s` : 'None' },
-        { property: 'Tags', val: tags.length > 0 ? tags.join(', ') : 'None' },
-        { property: 'Vector', val: asVector ? 'Yes' : 'No' }
-      ]
-    });
-
-    output.writeln();
-    output.printSuccess('Data stored successfully');
-
-    return { success: true, data: storeData };
-  }
-};
-
-// Retrieve command
-const retrieveCommand: Command = {
-  name: 'retrieve',
-  aliases: ['get'],
-  description: 'Retrieve data from memory',
-  options: [
-    {
-      name: 'key',
-      short: 'k',
-      description: 'Storage key',
-      type: 'string'
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Memory namespace',
-      type: 'string',
-      default: 'default'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const key = ctx.flags.key as string || ctx.args[0];
-    const namespace = ctx.flags.namespace as string;
-
-    if (!key) {
-      output.printError('Key is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    // Simulated retrieval
-    const data = {
-      key,
-      namespace,
-      value: 'JWT implementation with refresh tokens and secure storage',
-      metadata: {
-        storedAt: '2024-01-04T10:30:00Z',
-        accessCount: 15,
-        lastAccessed: new Date().toISOString(),
-        size: 56,
-        tags: ['auth', 'security', 'api']
-      }
-    };
-
-    if (ctx.flags.format === 'json') {
-      output.printJson(data);
-      return { success: true, data };
-    }
-
-    output.writeln();
-    output.printBox(
-      [
-        `Namespace: ${data.namespace}`,
-        `Key: ${data.key}`,
-        `Size: ${data.metadata.size} bytes`,
-        `Access Count: ${data.metadata.accessCount}`,
-        `Tags: ${data.metadata.tags.join(', ')}`,
-        '',
-        output.bold('Value:'),
-        data.value
-      ].join('\n'),
-      'Memory Entry'
-    );
-
-    return { success: true, data };
-  }
-};
-
-// Search command
-const searchCommand: Command = {
-  name: 'search',
-  description: 'Search memory with semantic/vector search',
-  options: [
-    {
-      name: 'query',
-      short: 'q',
-      description: 'Search query',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Memory namespace',
-      type: 'string'
-    },
-    {
-      name: 'limit',
-      short: 'l',
-      description: 'Maximum results',
-      type: 'number',
-      default: 10
-    },
-    {
-      name: 'threshold',
-      description: 'Similarity threshold (0-1)',
-      type: 'number',
-      default: 0.7
-    },
-    {
-      name: 'type',
-      short: 't',
-      description: 'Search type (semantic, keyword, hybrid)',
-      type: 'string',
-      default: 'semantic',
-      choices: ['semantic', 'keyword', 'hybrid']
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory search -q "authentication patterns"', description: 'Semantic search' },
-    { command: 'claude-flow memory search -q "JWT" -t keyword', description: 'Keyword search' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const query = ctx.flags.query as string || ctx.args[0];
-    const namespace = ctx.flags.namespace as string;
-    const limit = ctx.flags.limit as number;
-    const threshold = ctx.flags.threshold as number;
-    const searchType = ctx.flags.type as string;
-
-    if (!query) {
-      output.printError('Query is required. Use --query or -q');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Searching: "${query}" (${searchType})`);
-    output.writeln();
-
-    // Simulated search results
-    const results = [
-      { key: 'auth/jwt-impl', score: 0.95, namespace: 'patterns', preview: 'JWT implementation with RS256...' },
-      { key: 'auth/session', score: 0.88, namespace: 'patterns', preview: 'Session-based auth with Redis...' },
-      { key: 'security/tokens', score: 0.82, namespace: 'security', preview: 'Token management strategies...' },
-      { key: 'api/middleware', score: 0.76, namespace: 'code', preview: 'Auth middleware implementation...' }
-    ].filter(r => r.score >= threshold).slice(0, limit);
-
-    if (ctx.flags.format === 'json') {
-      output.printJson({ query, searchType, results });
-      return { success: true, data: results };
-    }
-
-    // Performance stats
-    output.writeln(output.dim(`  HNSW search: ${Math.random() * 2 + 0.5 | 0}.${Math.random() * 100 | 0}ms (150x faster than linear)`));
-    output.writeln();
-
-    output.printTable({
-      columns: [
-        { key: 'key', header: 'Key', width: 20 },
-        { key: 'score', header: 'Score', width: 8, align: 'right', format: (v) => Number(v).toFixed(2) },
-        { key: 'namespace', header: 'Namespace', width: 12 },
-        { key: 'preview', header: 'Preview', width: 35 }
-      ],
-      data: results
-    });
-
-    output.writeln();
-    output.printInfo(`Found ${results.length} results`);
-
-    return { success: true, data: results };
-  }
-};
-
-// List command
-const listCommand: Command = {
-  name: 'list',
-  aliases: ['ls'],
-  description: 'List memory entries',
-  options: [
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Filter by namespace',
-      type: 'string'
-    },
-    {
-      name: 'tags',
-      short: 't',
-      description: 'Filter by tags (comma-separated)',
-      type: 'string'
-    },
-    {
-      name: 'limit',
-      short: 'l',
-      description: 'Maximum entries',
-      type: 'number',
-      default: 20
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const namespace = ctx.flags.namespace as string;
-    const limit = ctx.flags.limit as number;
-
-    // Simulated entries
-    const entries = [
-      { key: 'auth/jwt-impl', namespace: 'patterns', size: '2.1 KB', tags: ['auth'], updated: '2h ago' },
-      { key: 'auth/session', namespace: 'patterns', size: '1.4 KB', tags: ['auth'], updated: '3h ago' },
-      { key: 'api/routes', namespace: 'code', size: '856 B', tags: ['api'], updated: '1d ago' },
-      { key: 'db/schema', namespace: 'code', size: '3.2 KB', tags: ['db'], updated: '2d ago' },
-      { key: 'patterns/singleton', namespace: 'patterns', size: '512 B', tags: ['design'], updated: '5d ago' }
-    ].filter(e => !namespace || e.namespace === namespace).slice(0, limit);
-
-    if (ctx.flags.format === 'json') {
-      output.printJson(entries);
-      return { success: true, data: entries };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Memory Entries'));
-    output.writeln();
-
-    output.printTable({
-      columns: [
-        { key: 'key', header: 'Key', width: 25 },
-        { key: 'namespace', header: 'Namespace', width: 12 },
-        { key: 'size', header: 'Size', width: 10, align: 'right' },
-        { key: 'tags', header: 'Tags', width: 12 },
-        { key: 'updated', header: 'Updated', width: 10 }
-      ],
-      data: entries
-    });
-
-    output.writeln();
-    output.printInfo(`Showing ${entries.length} entries`);
-
-    return { success: true, data: entries };
-  }
-};
-
-// Delete command
-const deleteCommand: Command = {
-  name: 'delete',
-  aliases: ['rm'],
-  description: 'Delete memory entry',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Skip confirmation',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const key = ctx.args[0];
-    const force = ctx.flags.force as boolean;
-
-    if (!key) {
-      output.printError('Key is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!force && ctx.interactive) {
-      const confirmed = await confirm({
-        message: `Delete memory entry "${key}"?`,
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    output.printInfo(`Deleting ${key}...`);
-    output.printSuccess(`Deleted ${key}`);
-
-    return { success: true, data: { key, deleted: true } };
-  }
-};
-
-// Stats command
-const statsCommand: Command = {
-  name: 'stats',
-  description: 'Show memory statistics',
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const stats = {
-      backend: 'hybrid',
-      entries: {
-        total: 1234,
-        vectors: 567,
-        text: 667
-      },
-      storage: {
-        total: '45.6 MB',
-        vectors: '32.1 MB',
-        metadata: '13.5 MB'
-      },
-      performance: {
-        avgSearchTime: '1.2ms',
-        hnswIndexSize: '28.4 MB',
-        cacheHitRate: '87.3%',
-        vectorDimension: 1536
-      },
-      namespaces: [
-        { name: 'patterns', entries: 234, size: '8.2 MB' },
-        { name: 'code', entries: 456, size: '15.4 MB' },
-        { name: 'security', entries: 123, size: '4.1 MB' },
-        { name: 'default', entries: 421, size: '17.9 MB' }
-      ]
-    };
-
-    if (ctx.flags.format === 'json') {
-      output.printJson(stats);
-      return { success: true, data: stats };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Memory Statistics'));
-    output.writeln();
-
-    output.writeln(output.bold('Overview'));
-    output.printTable({
-      columns: [
-        { key: 'metric', header: 'Metric', width: 20 },
-        { key: 'value', header: 'Value', width: 15, align: 'right' }
-      ],
-      data: [
-        { metric: 'Backend', value: stats.backend },
-        { metric: 'Total Entries', value: stats.entries.total.toLocaleString() },
-        { metric: 'Vector Entries', value: stats.entries.vectors.toLocaleString() },
-        { metric: 'Text Entries', value: stats.entries.text.toLocaleString() },
-        { metric: 'Total Storage', value: stats.storage.total }
-      ]
-    });
-
-    output.writeln();
-    output.writeln(output.bold('Performance (AgentDB)'));
-    output.printTable({
-      columns: [
-        { key: 'metric', header: 'Metric', width: 20 },
-        { key: 'value', header: 'Value', width: 15, align: 'right' }
-      ],
-      data: [
-        { metric: 'Avg Search Time', value: stats.performance.avgSearchTime },
-        { metric: 'HNSW Index Size', value: stats.performance.hnswIndexSize },
-        { metric: 'Cache Hit Rate', value: stats.performance.cacheHitRate },
-        { metric: 'Vector Dimension', value: stats.performance.vectorDimension }
-      ]
-    });
-
-    output.writeln();
-    output.writeln(output.bold('Namespaces'));
-    output.printTable({
-      columns: [
-        { key: 'name', header: 'Name', width: 15 },
-        { key: 'entries', header: 'Entries', width: 10, align: 'right' },
-        { key: 'size', header: 'Size', width: 12, align: 'right' }
-      ],
-      data: stats.namespaces
-    });
-
-    output.writeln();
-    output.printInfo('V3 Performance: 150x-12,500x faster search with HNSW indexing');
-
-    return { success: true, data: stats };
-  }
-};
-
-// Configure command
-const configureCommand: Command = {
-  name: 'configure',
-  aliases: ['config'],
-  description: 'Configure memory backend',
-  options: [
-    {
-      name: 'backend',
-      short: 'b',
-      description: 'Memory backend',
-      type: 'string',
-      choices: BACKENDS.map(b => b.value)
-    },
-    {
-      name: 'path',
-      description: 'Storage path',
-      type: 'string'
-    },
-    {
-      name: 'cache-size',
-      description: 'Cache size in MB',
-      type: 'number'
-    },
-    {
-      name: 'hnsw-m',
-      description: 'HNSW M parameter',
-      type: 'number',
-      default: 16
-    },
-    {
-      name: 'hnsw-ef',
-      description: 'HNSW ef parameter',
-      type: 'number',
-      default: 200
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    let backend = ctx.flags.backend as string;
-
-    if (!backend && ctx.interactive) {
-      backend = await select({
-        message: 'Select memory backend:',
-        options: BACKENDS,
-        default: 'hybrid'
-      });
-    }
-
-    const config = {
-      backend: backend || 'hybrid',
-      path: ctx.flags.path || './data/memory',
-      cacheSize: ctx.flags.cacheSize || 256,
-      hnsw: {
-        m: ctx.flags.hnswM || 16,
-        ef: ctx.flags.hnswEf || 200
-      }
-    };
-
-    output.writeln();
-    output.printInfo('Memory Configuration');
-    output.writeln();
-
-    output.printTable({
-      columns: [
-        { key: 'setting', header: 'Setting', width: 20 },
-        { key: 'value', header: 'Value', width: 25 }
-      ],
-      data: [
-        { setting: 'Backend', value: config.backend },
-        { setting: 'Storage Path', value: config.path },
-        { setting: 'Cache Size', value: `${config.cacheSize} MB` },
-        { setting: 'HNSW M', value: config.hnsw.m },
-        { setting: 'HNSW ef', value: config.hnsw.ef }
-      ]
-    });
-
-    output.writeln();
-    output.printSuccess('Memory configuration updated');
-
-    return { success: true, data: config };
-  }
-};
-
-// Cleanup command
-const cleanupCommand: Command = {
-  name: 'cleanup',
-  description: 'Clean up stale and expired memory entries',
-  options: [
-    {
-      name: 'dry-run',
-      short: 'd',
-      description: 'Show what would be deleted',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'older-than',
-      short: 'o',
-      description: 'Delete entries older than (e.g., "7d", "30d")',
-      type: 'string'
-    },
-    {
-      name: 'expired-only',
-      short: 'e',
-      description: 'Only delete expired TTL entries',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'low-quality',
-      short: 'l',
-      description: 'Delete low quality patterns (threshold)',
-      type: 'number'
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Clean specific namespace only',
-      type: 'string'
-    },
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Skip confirmation',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory cleanup --dry-run', description: 'Preview cleanup' },
-    { command: 'claude-flow memory cleanup --older-than 30d', description: 'Delete entries older than 30 days' },
-    { command: 'claude-flow memory cleanup --expired-only', description: 'Clean expired entries' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const dryRun = ctx.flags.dryRun as boolean;
-    const force = ctx.flags.force as boolean;
-
-    if (dryRun) {
-      output.writeln(output.warning('DRY RUN - No changes will be made'));
-    }
-
-    output.printInfo('Analyzing memory for cleanup...');
-
-    try {
-      const result = await callMCPTool<{
-        dryRun: boolean;
-        candidates: {
-          expired: number;
-          stale: number;
-          lowQuality: number;
-          total: number;
-        };
-        deleted: {
-          entries: number;
-          vectors: number;
-          patterns: number;
-        };
-        freed: {
-          bytes: number;
-          formatted: string;
-        };
-        duration: number;
-      }>('memory/cleanup', {
-        dryRun,
-        olderThan: ctx.flags.olderThan,
-        expiredOnly: ctx.flags.expiredOnly,
-        lowQualityThreshold: ctx.flags.lowQuality,
-        namespace: ctx.flags.namespace,
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('Cleanup Analysis'));
-      output.printTable({
-        columns: [
-          { key: 'category', header: 'Category', width: 20 },
-          { key: 'count', header: 'Count', width: 15, align: 'right' }
-        ],
-        data: [
-          { category: 'Expired (TTL)', count: result.candidates.expired },
-          { category: 'Stale (unused)', count: result.candidates.stale },
-          { category: 'Low Quality', count: result.candidates.lowQuality },
-          { category: output.bold('Total'), count: output.bold(String(result.candidates.total)) }
-        ]
-      });
-
-      if (!dryRun && result.candidates.total > 0 && !force) {
-        const confirmed = await confirm({
-          message: `Delete ${result.candidates.total} entries (${result.freed.formatted})?`,
-          default: false
-        });
-
-        if (!confirmed) {
-          output.printInfo('Cleanup cancelled');
-          return { success: true, data: result };
-        }
-      }
-
-      if (!dryRun) {
-        output.writeln();
-        output.printSuccess(`Cleaned ${result.deleted.entries} entries`);
-        output.printList([
-          `Vectors removed: ${result.deleted.vectors}`,
-          `Patterns removed: ${result.deleted.patterns}`,
-          `Space freed: ${result.freed.formatted}`,
-          `Duration: ${result.duration}ms`
-        ]);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Cleanup error: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Compress command
-const compressCommand: Command = {
-  name: 'compress',
-  description: 'Compress and optimize memory storage',
-  options: [
-    {
-      name: 'level',
-      short: 'l',
-      description: 'Compression level (fast, balanced, max)',
-      type: 'string',
-      choices: ['fast', 'balanced', 'max'],
-      default: 'balanced'
-    },
-    {
-      name: 'target',
-      short: 't',
-      description: 'Target (vectors, text, patterns, all)',
-      type: 'string',
-      choices: ['vectors', 'text', 'patterns', 'all'],
-      default: 'all'
-    },
-    {
-      name: 'quantize',
-      short: 'q',
-      description: 'Enable vector quantization (reduces memory 4-32x)',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'bits',
-      description: 'Quantization bits (4, 8, 16)',
-      type: 'number',
-      default: 8
-    },
-    {
-      name: 'rebuild-index',
-      short: 'r',
-      description: 'Rebuild HNSW index after compression',
-      type: 'boolean',
-      default: true
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory compress', description: 'Balanced compression' },
-    { command: 'claude-flow memory compress --quantize --bits 4', description: '4-bit quantization (32x reduction)' },
-    { command: 'claude-flow memory compress -l max -t vectors', description: 'Max compression on vectors' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const level = ctx.flags.level as string || 'balanced';
-    const target = ctx.flags.target as string || 'all';
-    const quantize = ctx.flags.quantize as boolean;
-    const bits = ctx.flags.bits as number || 8;
-    const rebuildIndex = ctx.flags.rebuildIndex as boolean ?? true;
-
-    output.writeln();
-    output.writeln(output.bold('Memory Compression'));
-    output.writeln(output.dim(`Level: ${level}, Target: ${target}, Quantize: ${quantize ? `${bits}-bit` : 'no'}`));
-    output.writeln();
-
-    const spinner = output.createSpinner({ text: 'Analyzing current storage...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const result = await callMCPTool<{
-        before: {
-          totalSize: string;
-          vectorsSize: string;
-          textSize: string;
-          patternsSize: string;
-          indexSize: string;
-        };
-        after: {
-          totalSize: string;
-          vectorsSize: string;
-          textSize: string;
-          patternsSize: string;
-          indexSize: string;
-        };
-        compression: {
-          ratio: number;
-          bytesSaved: number;
-          formattedSaved: string;
-          quantizationApplied: boolean;
-          indexRebuilt: boolean;
-        };
-        performance: {
-          searchLatencyBefore: number;
-          searchLatencyAfter: number;
-          searchSpeedup: string;
-        };
-        duration: number;
-      }>('memory/compress', {
-        level,
-        target,
-        quantize,
-        bits,
-        rebuildIndex,
-      });
-
-      spinner.succeed('Compression complete');
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('Storage Comparison'));
-      output.printTable({
-        columns: [
-          { key: 'category', header: 'Category', width: 15 },
-          { key: 'before', header: 'Before', width: 12, align: 'right' },
-          { key: 'after', header: 'After', width: 12, align: 'right' },
-          { key: 'saved', header: 'Saved', width: 12, align: 'right' }
-        ],
-        data: [
-          { category: 'Vectors', before: result.before.vectorsSize, after: result.after.vectorsSize, saved: '-' },
-          { category: 'Text', before: result.before.textSize, after: result.after.textSize, saved: '-' },
-          { category: 'Patterns', before: result.before.patternsSize, after: result.after.patternsSize, saved: '-' },
-          { category: 'Index', before: result.before.indexSize, after: result.after.indexSize, saved: '-' },
-          { category: output.bold('Total'), before: result.before.totalSize, after: result.after.totalSize, saved: output.success(result.compression.formattedSaved) }
-        ]
-      });
-
-      output.writeln();
-      output.printBox(
-        [
-          `Compression Ratio: ${result.compression.ratio.toFixed(2)}x`,
-          `Space Saved: ${result.compression.formattedSaved}`,
-          `Quantization: ${result.compression.quantizationApplied ? `Yes (${bits}-bit)` : 'No'}`,
-          `Index Rebuilt: ${result.compression.indexRebuilt ? 'Yes' : 'No'}`,
-          `Duration: ${(result.duration / 1000).toFixed(1)}s`
-        ].join('\n'),
-        'Results'
-      );
-
-      if (result.performance) {
-        output.writeln();
-        output.writeln(output.bold('Performance Impact'));
-        output.printList([
-          `Search latency: ${result.performance.searchLatencyBefore.toFixed(2)}ms → ${result.performance.searchLatencyAfter.toFixed(2)}ms`,
-          `Speedup: ${output.success(result.performance.searchSpeedup)}`
-        ]);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      spinner.fail('Compression failed');
-      if (error instanceof MCPClientError) {
-        output.printError(`Compression error: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Export command
-const exportCommand: Command = {
-  name: 'export',
-  description: 'Export memory to file',
-  options: [
-    {
-      name: 'output',
-      short: 'o',
-      description: 'Output file path',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'format',
-      short: 'f',
-      description: 'Export format (json, csv, binary)',
-      type: 'string',
-      choices: ['json', 'csv', 'binary'],
-      default: 'json'
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Export specific namespace',
-      type: 'string'
-    },
-    {
-      name: 'include-vectors',
-      description: 'Include vector embeddings',
-      type: 'boolean',
-      default: true
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory export -o ./backup.json', description: 'Export all to JSON' },
-    { command: 'claude-flow memory export -o ./data.csv -f csv', description: 'Export to CSV' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const outputPath = ctx.flags.output as string;
-    const format = ctx.flags.format as string || 'json';
-
-    if (!outputPath) {
-      output.printError('Output path is required. Use --output or -o');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Exporting memory to ${outputPath}...`);
-
-    try {
-      const result = await callMCPTool<{
-        outputPath: string;
-        format: string;
-        exported: {
-          entries: number;
-          vectors: number;
-          patterns: number;
-        };
-        fileSize: string;
-      }>('memory/export', {
-        outputPath,
-        format,
-        namespace: ctx.flags.namespace,
-        includeVectors: ctx.flags.includeVectors ?? true,
-      });
-
-      output.printSuccess(`Exported to ${result.outputPath}`);
-      output.printList([
-        `Entries: ${result.exported.entries}`,
-        `Vectors: ${result.exported.vectors}`,
-        `Patterns: ${result.exported.patterns}`,
-        `File size: ${result.fileSize}`
-      ]);
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Export error: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Import command
-const importCommand: Command = {
-  name: 'import',
-  description: 'Import memory from file',
-  options: [
-    {
-      name: 'input',
-      short: 'i',
-      description: 'Input file path',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'merge',
-      short: 'm',
-      description: 'Merge with existing (skip duplicates)',
-      type: 'boolean',
-      default: true
-    },
-    {
-      name: 'namespace',
-      short: 'n',
-      description: 'Import into specific namespace',
-      type: 'string'
-    }
-  ],
-  examples: [
-    { command: 'claude-flow memory import -i ./backup.json', description: 'Import from file' },
-    { command: 'claude-flow memory import -i ./data.json -n archive', description: 'Import to namespace' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const inputPath = ctx.flags.input as string || ctx.args[0];
-
-    if (!inputPath) {
-      output.printError('Input path is required. Use --input or -i');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.printInfo(`Importing memory from ${inputPath}...`);
-
-    try {
-      const result = await callMCPTool<{
-        inputPath: string;
-        imported: {
-          entries: number;
-          vectors: number;
-          patterns: number;
-        };
-        skipped: number;
-        duration: number;
-      }>('memory/import', {
-        inputPath,
-        merge: ctx.flags.merge ?? true,
-        namespace: ctx.flags.namespace,
-      });
-
-      output.printSuccess(`Imported from ${result.inputPath}`);
-      output.printList([
-        `Entries: ${result.imported.entries}`,
-        `Vectors: ${result.imported.vectors}`,
-        `Patterns: ${result.imported.patterns}`,
-        `Skipped (duplicates): ${result.skipped}`,
-        `Duration: ${result.duration}ms`
-      ]);
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Import error: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Main memory command
-export const memoryCommand: Command = {
-  name: 'memory',
-  description: 'Memory management commands',
-  subcommands: [storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand],
-  options: [],
-  examples: [
-    { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },
-    { command: 'claude-flow memory search -q "auth patterns"', description: 'Search memory' },
-    { command: 'claude-flow memory stats', description: 'Show statistics' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Memory Management Commands'));
-    output.writeln();
-    output.writeln('Usage: claude-flow memory <subcommand> [options]');
-    output.writeln();
-    output.writeln('Subcommands:');
-    output.printList([
-      `${output.highlight('store')}      - Store data in memory`,
-      `${output.highlight('retrieve')}   - Retrieve data from memory`,
-      `${output.highlight('search')}     - Semantic/vector search`,
-      `${output.highlight('list')}       - List memory entries`,
-      `${output.highlight('delete')}     - Delete memory entry`,
-      `${output.highlight('stats')}      - Show statistics`,
-      `${output.highlight('configure')}  - Configure backend`
-    ]);
-
-    return { success: true };
-  }
-};
-
-export default memoryCommand;