k0ntext 3.3.0 → 3.3.1

package/src/cli/repl/tui/panels/indexing.ts

@@ -0,0 +1,324 @@
+/**
+ * Indexing Progress Visualization
+ *
+ * Real-time progress display for indexing operations
+ */
+
+import chalk from 'chalk';
+import { K0NTEXT_THEME } from '../theme.js';
+import ora, { Ora } from 'ora';
+
+/**
+ * Indexing progress state
+ */
+interface IndexingProgress {
+  total: number;
+  processed: number;
+  currentFile?: string;
+  stage: 'discovering' | 'indexing_docs' | 'indexing_code' | 'indexing_tools' | 'generating_embeddings' | 'complete';
+  startTime: number;
+  errors: string[];
+}
+
+/**
+ * Indexing statistics
+ */
+interface IndexingStats {
+  docsIndexed: number;
+  codeIndexed: number;
+  configsIndexed: number;
+  embeddingsGenerated: number;
+  filesSkipped: number;
+  duration: number;
+}
+
+/**
+ * Indexing Progress Visualizer
+ */
+export class IndexingProgressVisualizer {
+  private progress: IndexingProgress;
+  private stats: IndexingStats;
+  private spinner: Ora | null = null;
+
+  constructor() {
+    this.progress = {
+      total: 0,
+      processed: 0,
+      stage: 'discovering',
+      startTime: Date.now(),
+      errors: []
+    };
+
+    this.stats = {
+      docsIndexed: 0,
+      codeIndexed: 0,
+      configsIndexed: 0,
+      embeddingsGenerated: 0,
+      filesSkipped: 0,
+      duration: 0
+    };
+  }
+
+  /**
+   * Start a new indexing operation
+   */
+  start(totalFiles: number): void {
+    this.progress = {
+      total: totalFiles,
+      processed: 0,
+      stage: 'discovering',
+      startTime: Date.now(),
+      errors: []
+    };
+
+    this.stats = {
+      docsIndexed: 0,
+      codeIndexed: 0,
+      configsIndexed: 0,
+      embeddingsGenerated: 0,
+      filesSkipped: 0,
+      duration: 0
+    };
+
+    this.spinner = ora('Preparing to index...').start();
+  }
+
+  /**
+   * Update progress
+   */
+  update(stage: IndexingProgress['stage'], updates: {
+    processed?: number;
+    currentFile?: string;
+    error?: string;
+  }): void {
+    this.progress.stage = stage;
+
+    if (updates.processed !== undefined) {
+      this.progress.processed = updates.processed;
+    }
+
+    if (updates.currentFile) {
+      this.progress.currentFile = updates.currentFile;
+    }
+
+    if (updates.error) {
+      this.progress.errors.push(updates.error);
+    }
+
+    this.render();
+  }
+
+  /**
+   * Render current progress
+   */
+  private render(): void {
+    if (!this.spinner) return;
+
+    const percentage = Math.min(100, Math.round((this.progress.processed / this.progress.total) * 100));
+    const elapsed = Date.now() - this.progress.startTime;
+    const eta = this.progress.processed > 0
+      ? (elapsed / this.progress.processed) * (this.progress.total - this.progress.processed)
+      : 0;
+
+    // Update spinner text
+    const stageEmoji = {
+      discovering: '🔍',
+      indexing_docs: '📄',
+      indexing_code: '💻',
+      indexing_tools: '⚙️',
+      generating_embeddings: '🧠',
+      complete: '✓'
+    }[this.progress.stage];
+
+    let spinnerText = `${stageEmoji} ${this.getStageName(this.progress.stage)}: ${percentage}%`;
+
+    if (this.progress.currentFile) {
+      const fileName = this.progress.currentFile.split('/').pop()!;
+      spinnerText += ` (${K0NTEXT_THEME.dim(fileName.slice(0, 30))}${this.progress.currentFile.length > 30 ? '...' : ''})`;
+    }
+
+    if (eta > 1000) {
+      const etaText = this.formatDuration(eta);
+      spinnerText += ` ${K0NTEXT_THEME.dim(`ETA: ${etaText}`)}`;
+    }
+
+    this.spinner.text = spinnerText;
+
+    // Show detailed progress on intervals
+    if (this.progress.processed % 50 === 0 || this.progress.stage === 'complete') {
+      this.showDetailedProgress();
+    }
+  }
+
+  /**
+   * Get stage name
+   */
+  private getStageName(stage: IndexingProgress['stage']): string {
+    const names = {
+      discovering: 'Discovering files',
+      indexing_docs: 'Indexing documents',
+      indexing_code: 'Indexing code',
+      indexing_tools: 'Indexing configs',
+      generating_embeddings: 'Generating embeddings',
+      complete: 'Complete'
+    };
+    return names[stage];
+  }
+
+  /**
+   * Show detailed progress panel
+   */
+  showDetailedProgress(): void {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push(K0NTEXT_THEME.header('━━━ Indexing Progress ━━━'));
+
+    // Progress bar
+    lines.push(`  Progress: ${this.renderProgressBar()}`);
+    lines.push(`  Stage: ${this.getStageName(this.progress.stage)}`);
+    lines.push('');
+
+    // Stats
+    lines.push(K0NTEXT_THEME.header('━━━ Statistics ━──'));
+    lines.push(`  Documents Indexed:  ${K0NTEXT_THEME.cyan(this.stats.docsIndexed.toString())}`);
+    lines.push(`  Code Files Indexed:  ${K0NTEXT_THEME.cyan(this.stats.codeIndexed.toString())}`);
+    lines.push(`  Configs Indexed:     ${K0NTEXT_THEME.cyan(this.stats.configsIndexed.toString())}`);
+    lines.push(`  Embeddings:         ${K0NTEXT_THEME.cyan(this.stats.embeddingsGenerated.toString())}`);
+    lines.push(`  Files Skipped:      ${this.stats.filesSkipped > 0 ? K0NTEXT_THEME.warning(this.stats.filesSkipped.toString()) : K0NTEXT_THEME.dim('0')}`);
+    lines.push('');
+
+    // Errors
+    if (this.progress.errors.length > 0) {
+      lines.push(K0NTEXT_THEME.header('━━━ Errors ━──'));
+      for (const error of this.progress.errors.slice(-5)) {
+        lines.push(`  ${K0NTEXT_THEME.error('✖')} ${error}`);
+      }
+      lines.push('');
+    }
+
+    // Clear and render
+    console.log(lines.join('\n'));
+  }
+
+  /**
+   * Render progress bar
+   */
+  private renderProgressBar(): string {
+    const percentage = Math.min(100, Math.round((this.progress.processed / this.progress.total) * 100));
+    const width = 30;
+    const filled = Math.floor((percentage / 100) * width);
+
+    const bar = K0NTEXT_THEME.primary('█'.repeat(filled)) + K0NTEXT_THEME.dim('░'.repeat(width - filled));
+    const pct = K0NTEXT_THEME.primary(`${percentage.toString().padStart(3)}%`);
+    const counts = `${this.progress.processed}/${this.progress.total}`;
+
+    return `${bar} ${pct} (${K0NTEXT_THEME.dim(counts)})`;
+  }
+
+  /**
+   * Format duration
+   */
+  private formatDuration(ms: number): string {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+
+  /**
+   * Complete indexing
+   */
+  complete(stats: Partial<IndexingStats>): void {
+    this.progress.stage = 'complete';
+    this.progress.processed = this.progress.total;
+
+    this.stats = {
+      docsIndexed: stats.docsIndexed || 0,
+      codeIndexed: stats.codeIndexed || 0,
+      configsIndexed: stats.configsIndexed || 0,
+      embeddingsGenerated: stats.embeddingsGenerated || 0,
+      filesSkipped: stats.filesSkipped || 0,
+      duration: Date.now() - this.progress.startTime
+    };
+
+    if (this.spinner) {
+      this.spinner.succeed('Indexing complete!');
+    }
+
+    this.showFinalStats();
+  }
+
+  /**
+   * Show final statistics
+   */
+  showFinalStats(): void {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push(K0NTEXT_THEME.success('━━━ Indexing Complete ━━━'));
+    lines.push('');
+
+    lines.push(`  ${K0NTEXT_THEME.header('Files Processed:')}`);
+    lines.push(`    Documents:    ${K0NTEXT_THEME.cyan(this.stats.docsIndexed.toString())}`);
+    lines.push(`    Code Files:   ${K0NTEXT_THEME.cyan(this.stats.codeIndexed.toString())}`);
+    lines.push(`    Configs:      ${K0NTEXT_THEME.cyan(this.stats.configsIndexed.toString())}`);
+    lines.push(`    Total:        ${K0NTEXT_THEME.primary((this.stats.docsIndexed + this.stats.codeIndexed + this.stats.configsIndexed).toString())}`);
+    lines.push('');
+
+    if (this.stats.embeddingsGenerated > 0) {
+      lines.push(`  ${K0NTEXT_THEME.header('Embeddings:')}`);
+      lines.push(`    Generated:   ${K0NTEXT_THEME.cyan(this.stats.embeddingsGenerated.toString())}`);
+      lines.push('');
+    }
+
+    if (this.stats.filesSkipped > 0) {
+      lines.push(`  ${K0NTEXT_THEME.warning('⚠ Files Skipped:')}`);
+      lines.push(`    ${this.stats.filesSkipped} files hit limit (use --max-files to increase)`);
+      lines.push('');
+    }
+
+    lines.push(`  ${K0NTEXT_THEME.header('Time:')}`);
+    lines.push(`    Duration:    ${K0NTEXT_THEME.formatTimestamp(new Date(Date.now() - this.stats.duration))}`);
+    lines.push('');
+
+    console.log(lines.join('\n'));
+  }
+
+  /**
+   * Cancel indexing
+   */
+  cancel(): void {
+    if (this.spinner) {
+      this.spinner.warn('Indexing cancelled');
+    }
+
+    console.log('');
+    console.log(K0NTEXT_THEME.info('Indexing was cancelled.'));
+    console.log(K0NTEXT_THEME.dim('Partial results may have been saved.'));
+  }
+
+  /**
+   * Format a timestamp relative to now
+   */
+  private formatTimestamp(ms: number): string {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s ago`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s ago`;
+    } else {
+      return `${seconds}s ago`;
+    }
+  }
+}

package/src/cli/repl/tui/panels/search.ts

@@ -0,0 +1,272 @@
+/**
+ * Advanced Search Panel
+ *
+ * Enhanced search with filtering, sorting, and detailed results
+ */
+
+import chalk from 'chalk';
+import { K0NTEXT_THEME } from '../theme.js';
+import type { ContextItem } from '../../../../db/client.js';
+import type { ContextType } from '../../../../db/schema.js';
+
+/**
+ * Search filter options
+ */
+export interface SearchFilters {
+  type?: ContextType;
+  sortBy?: 'relevance' | 'name' | 'date' | 'size';
+  sortOrder?: 'asc' | 'desc';
+  limit?: number;
+}
+
+/**
+ * Enhanced search result with metadata
+ */
+export interface EnhancedSearchResult {
+  item: ContextItem;
+  score?: number;
+  highlights: string[];
+}
+
+/**
+ * Advanced Search Panel
+ */
+export class AdvancedSearchPanel {
+  /**
+   * Display advanced search results with formatting
+   */
+  displayResults(results: EnhancedSearchResult[], query: string, filters: SearchFilters): string {
+    const lines: string[] = [];
+
+    // Header with query and filters
+    lines.push('');
+    lines.push(K0NTEXT_THEME.header(`━━━ Search Results: "${query}" ━━━`));
+
+    if (filters.type) {
+      lines.push(`  ${K0NTEXT_THEME.dim('Filter:')} ${K0NTEXT_THEME.cyan(filters.type)}`);
+    }
+    if (filters.sortBy) {
+      lines.push(`  ${K0NTEXT_THEME.dim('Sorted by:')} ${K0NTEXT_THEME.cyan(filters.sortBy)} ${K0NTEXT_THEME.dim('(')}${filters.sortOrder}${K0NTEXT_THEME.dim(')')}`);
+    }
+    lines.push(`  ${K0NTEXT_THEME.dim('Found:')} ${K0NTEXT_THEME.highlight(results.length.toString())} results`);
+    lines.push('');
+
+    // Type legend
+    lines.push(K0NTEXT_THEME.dim('Types:  📄=doc 💻=code ⚙️=config 📋=workflow 🤖=agent 🔧=command'));
+    lines.push('');
+
+    // Display results
+    for (let i = 0; i < Math.min(results.length, filters.limit || 20); i++) {
+      const { item, score, highlights } = results[i];
+
+      // Type emoji
+      const typeEmoji = this.getTypeEmoji(item.type);
+      const relevance = score !== undefined ? ` ${K0NTEXT_THEME.dim(`(${Math.round(score * 100)}%)`)}` : '';
+
+      lines.push(`${K0NTEXT_THEME.primary(`${i + 1}.`)} ${typeEmoji} ${K0NTEXT_THEME.highlight(item.name)}${relevance}`);
+
+      if (item.filePath) {
+        lines.push(`     ${K0NTEXT_THEME.dim(item.filePath)}`);
+      }
+
+      // Show content preview
+      if (item.content) {
+        const preview = this.getContentPreview(item.content, query);
+        if (preview) {
+          lines.push(`     ${K0NTEXT_THEME.dim(preview)}`);
+        }
+      }
+
+      // Show metadata
+      if (item.metadata) {
+        const meta = this.formatMetadata(item.metadata as Record<string, unknown>);
+        if (meta) {
+          lines.push(`     ${K0NTEXT_THEME.dim(meta)}`);
+        }
+      }
+
+      lines.push('');
+    }
+
+    if (results.length > (filters.limit || 20)) {
+      const remaining = results.length - (filters.limit || 20);
+      lines.push(K0NTEXT_THEME.dim(`     ... and ${remaining} more results`));
+      lines.push('');
+    }
+
+    // Search tips
+    lines.push(K0NTEXT_THEME.header('━━━ Search Tips ━━━'));
+    lines.push(`  ${K0NTEXT_THEME.cyan('•')} Use ${K0NTEXT_THEME.highlight('search <query> --type <type>')} to filter`);
+    lines.push(`  ${K0NTEXT_THEME.cyan('•')} Use ${K0NTEXT_THEME.highlight('search <query> --sort <field>')} to sort`);
+    lines.push(`  ${K0NTEXT_THEME.cyan('•')} Use ${K0NTEXT_THEME.highlight('search <query> --limit <n>')} for more results`);
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Get emoji for context type
+   */
+  private getTypeEmoji(type: ContextType): string {
+    const emojis: Record<string, string> = {
+      doc: '📄',
+      code: '💻',
+      tool_config: '⚙️',
+      workflow: '📋',
+      agent: '🤖',
+      command: '🔧',
+      commit: '📝',
+      knowledge: '🧠',
+      config: '⚙️'
+    };
+    return emojis[type] || '📄';
+  }
+
+  /**
+   * Get content preview with highlighted query terms
+   */
+  private getContentPreview(content: string, query: string): string {
+    const maxLength = 100;
+    const preview = content.slice(0, maxLength);
+
+    // Highlight query terms
+    const terms = query.toLowerCase().split(/\s+/).filter(t => t.length > 2);
+    let highlighted = preview;
+
+    for (const term of terms) {
+      const regex = new RegExp(`(${this.escapeRegex(term)})`, 'gi');
+      highlighted = highlighted.replace(regex, K0NTEXT_THEME.highlight('$1'));
+    }
+
+    return highlighted + (content.length > maxLength ? '...' : '');
+  }
+
+  /**
+   * Escape special regex characters
+   */
+  private escapeRegex(string: string): string {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  /**
+   * Format metadata for display
+   */
+  private formatMetadata(metadata: Record<string, unknown>): string | null {
+    const parts: string[] = [];
+
+    if (metadata.size !== undefined) {
+      parts.push(K0NTEXT_THEME.formatFileSize(Number(metadata.size)));
+    }
+
+    if (metadata.module) {
+      parts.push(`module:${metadata.module}`);
+    }
+
+    if (metadata.tool) {
+      parts.push(`tool:${metadata.tool}`);
+    }
+
+    return parts.length > 0 ? parts.join(' • ') : null;
+  }
+
+  /**
+   * Sort results by various criteria
+   */
+  sortResults(results: EnhancedSearchResult[], sortBy: 'relevance' | 'name' | 'date' | 'size', order: 'asc' | 'desc'): EnhancedSearchResult[] {
+    return results.sort((a, b) => {
+      let comparison = 0;
+
+      switch (sortBy) {
+        case 'relevance':
+          comparison = (b.score || 0) - (a.score || 0);
+          break;
+        case 'name':
+          comparison = a.item.name.localeCompare(b.item.name);
+          break;
+        case 'date':
+          const aDate = a.item.updatedAt ? new Date(a.item.updatedAt).getTime() : 0;
+          const bDate = b.item.updatedAt ? new Date(b.item.updatedAt).getTime() : 0;
+          comparison = bDate - aDate;
+          break;
+        case 'size':
+          const aSize = (a.item.metadata as Record<string, unknown>)?.size || 0;
+          const bSize = (b.item.metadata as Record<string, unknown>)?.size || 0;
+          comparison = Number(bSize) - Number(aSize);
+          break;
+      }
+
+      return order === 'desc' ? -comparison : comparison;
+    });
+  }
+
+  /**
+   * Filter results by type
+   */
+  filterByType(results: EnhancedSearchResult[], type: ContextType): EnhancedSearchResult[] {
+    return results.filter(r => r.item.type === type);
+  }
+
+  /**
+   * Parse search flags from command arguments
+   */
+  parseSearchFlags(args: string[]): SearchFilters {
+    const filters: SearchFilters = {};
+
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+
+      switch (arg) {
+        case '--type':
+        case '-t':
+          filters.type = (args[++i] || 'all') as ContextType;
+          break;
+        case '--sort':
+        case '-s':
+          filters.sortBy = (args[++i] || 'relevance') as SearchFilters['sortBy'];
+          break;
+        case '--order':
+        case '-o':
+          filters.sortOrder = (args[++i] || 'desc') as SearchFilters['sortOrder'];
+          break;
+        case '--limit':
+        case '-l':
+          filters.limit = Number(args[++i]) || 20;
+          break;
+      }
+    }
+
+    return filters;
+  }
+
+  /**
+   * Show search help
+   */
+  showSearchHelp(): string {
+    const lines = [
+      '',
+      K0NTEXT_THEME.header('━━━ Advanced Search Help ━━━'),
+      '',
+      '  Usage:',
+      '    search <query> [options]',
+      '',
+      '  Options:',
+      '    --type, -t <type>    Filter by type (doc, code, tool_config, workflow, agent, command)',
+      '    --sort, -s <field>  Sort by (relevance, name, date, size)',
+      '    --order, -o <dir>   Sort order (asc, desc)',
+      '    --limit, -l <n>     Max results (default: 20)',
+      '',
+      '  Examples:',
+      '    search auth --type code',
+      '    search "user login" --sort date --order desc',
+      '    search config --limit 50',
+      '',
+      '  Shortcuts:',
+      '    s <query>           Alias for search',
+      '    f <query>           Search and filter',
+      '    ?                  Show this help',
+      ''
+    ];
+
+    return lines.join('\n');
+  }
+}