k0ntext 3.3.0 → 3.3.1

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

@@ -0,0 +1,458 @@
+/**
+ * Drift Detection Panel
+ *
+ * Enhanced drift detection with detailed analysis and visualization
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { K0NTEXT_THEME } from '../theme.js';
+import { DatabaseClient } from '../../../../db/client.js';
+
+/**
+ * Drift type
+ */
+export type DriftType = 'file_dates' | 'structure' | 'git_diff';
+
+/**
+ * Drift severity
+ */
+export type DriftSeverity = 'low' | 'medium' | 'high' | 'critical';
+
+/**
+ * File drift information
+ */
+interface FileDrift {
+  filePath: string;
+  fileType: 'doc' | 'code' | 'config';
+  lastModified: Date;
+  lastIndexed: Date;
+  daysSince: number;
+  severity: DriftSeverity;
+}
+
+/**
+ * Structure drift information
+ */
+interface StructureDrift {
+  addedFiles: string[];
+  removedFiles: string[];
+  severity: DriftSeverity;
+}
+
+/**
+ * Git drift information
+ */
+interface GitDrift {
+  committedChanges: number;
+  uncommittedChanges: string[];
+  severity: DriftSeverity;
+}
+
+/**
+ * Combined drift report
+ */
+export interface DriftReport {
+  fileDrifts: FileDrift[];
+  structureDrift: StructureDrift | null;
+  gitDrift: GitDrift | null;
+  overallSeverity: DriftSeverity;
+  summary: string;
+}
+
+/**
+ * Drift Detection Panel
+ */
+export class DriftDetectionPanel {
+  private projectRoot: string;
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Run complete drift analysis
+   */
+  async analyze(): Promise<DriftReport> {
+    const [fileDrifts, structureDrift, gitDrift] = await Promise.all([
+      this.analyzeFileDates(),
+      this.analyzeStructure(),
+      this.analyzeGitDiff()
+    ]);
+
+    // Determine overall severity
+    const severities: DriftSeverity[] = [
+      this.getDriftSeverity(fileDrifts),
+      structureDrift?.severity || 'low',
+      gitDrift?.severity || 'low'
+    ];
+
+    const overallSeverity: DriftSeverity = severities.includes('critical')
+      ? 'critical'
+      : severities.includes('high')
+        ? 'high'
+        : severities.includes('medium')
+          ? 'medium'
+          : 'low';
+
+    const summary = this.generateSummary(fileDrifts, structureDrift, gitDrift);
+
+    return {
+      fileDrifts,
+      structureDrift,
+      gitDrift,
+      overallSeverity,
+      summary
+    };
+  }
+
+  /**
+   * Analyze file date drifts
+   */
+  private async analyzeFileDates(): Promise<FileDrift[]> {
+    const drifts: FileDrift[] = [];
+    const thresholdDays = 7; // Files not updated in 7 days are considered drifted
+
+    try {
+      const db = new DatabaseClient(this.projectRoot);
+      const items = db.getAllItems();
+
+      const now = new Date();
+
+      for (const item of items) {
+        if (!item.updatedAt) continue;
+
+        const lastIndexed = new Date(item.updatedAt);
+        const daysSince = Math.floor((now.getTime() - lastIndexed.getTime()) / (1000 * 60 * 60 * 24));
+
+        // Only include items that are drifted (> 7 days old)
+        if (daysSince <= thresholdDays) continue;
+
+        // Determine file type from item type
+        let fileType: 'doc' | 'code' | 'config' = 'doc';
+        if (item.type === 'code' || item.type === 'command' || item.type === 'commit') {
+          fileType = 'code';
+        } else if (item.type === 'config' || item.type === 'tool_config') {
+          fileType = 'config';
+        } else {
+          fileType = 'doc';
+        }
+
+        // Determine severity based on days since update
+        let severity: DriftSeverity = 'medium';
+        if (daysSince > 30) {
+          severity = 'critical';
+        } else if (daysSince > 14) {
+          severity = 'high';
+        } else {
+          severity = 'medium';
+        }
+
+        drifts.push({
+          filePath: item.filePath || item.id,
+          fileType,
+          lastModified: lastIndexed,
+          lastIndexed,
+          daysSince,
+          severity
+        });
+      }
+
+      db.close();
+    } catch (error) {
+      // If database is not available, return empty array
+      console.error('Failed to analyze file dates:', error);
+    }
+
+    return drifts;
+  }
+
+  /**
+   * Analyze structure changes
+   */
+  private async analyzeStructure(): Promise<StructureDrift | null> {
+    const addedFiles: string[] = [];
+    const removedFiles: string[] = [];
+
+    // Check for .k0ntext directory
+    const k0ntextDir = path.join(this.projectRoot, '.k0ntext');
+    if (!fs.existsSync(k0ntextDir)) {
+      return null;
+    }
+
+    // Could scan for untracked files
+    // This is a simplified implementation
+
+    let severity: DriftSeverity = 'low';
+    const totalChanges = addedFiles.length + removedFiles.length;
+
+    if (totalChanges > 50) severity = 'critical';
+    else if (totalChanges > 20) severity = 'high';
+    else if (totalChanges > 5) severity = 'medium';
+
+    return {
+      addedFiles,
+      removedFiles,
+      severity
+    };
+  }
+
+  /**
+   * Analyze git diff for changes
+   */
+  private async analyzeGitDiff(): Promise<GitDrift | null> {
+    const gitDir = path.join(this.projectRoot, '.git');
+    if (!fs.existsSync(gitDir)) {
+      return null;
+    }
+
+    // Check for uncommitted changes
+    const uncommittedChanges: string[] = [];
+
+    try {
+      // Use git diff to check for changes
+      const { execSync } = require('child_process');
+
+      // Check for modified files
+      const modified = execSync('git diff --name-only', {
+        cwd: this.projectRoot,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      }) as string;
+
+      if (modified.trim()) {
+        uncommittedChanges.push(...modified.trim().split('\n').filter(Boolean));
+      }
+
+      // Check for untracked files
+      const untracked = execSync('git ls-files --others --exclude-standard', {
+        cwd: this.projectRoot,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      }) as string;
+
+      if (untracked.trim()) {
+        uncommittedChanges.push(...untracked.trim().split('\n').filter(Boolean));
+      }
+
+      // Get commit count
+      const commitCountStr = execSync('git rev-list --count HEAD', {
+        cwd: this.projectRoot,
+        encoding: 'utf-8',
+        stdio: 'pipe'
+      }) as string;
+
+      const commitCount = parseInt(commitCountStr.trim() || '0');
+
+      let severity: DriftSeverity = 'low';
+      const totalChanges = uncommittedChanges.length;
+
+      if (totalChanges > 20) severity = 'critical';
+      else if (totalChanges > 10) severity = 'high';
+      else if (totalChanges > 5) severity = 'medium';
+
+      return {
+        committedChanges: commitCount,
+        uncommittedChanges,
+        severity
+      };
+    } catch {
+      // Git not available or error
+      return null;
+    }
+  }
+
+  /**
+   * Get drift severity from file drifts
+   */
+  private getDriftSeverity(drifts: FileDrift[]): DriftSeverity {
+    if (drifts.length === 0) return 'low';
+
+    const criticalDrifts = drifts.filter(d => d.severity === 'critical').length;
+    const highDrifts = drifts.filter(d => d.severity === 'high').length;
+    const mediumDrifts = drifts.filter(d => d.severity === 'medium').length;
+
+    if (criticalDrifts > 5) return 'critical';
+    if (criticalDrifts > 2 || highDrifts > 10) return 'high';
+    if (mediumDrifts > 10 || highDrifts > 3) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Generate summary text
+   */
+  private generateSummary(
+    fileDrifts: FileDrift[],
+    structureDrift: StructureDrift | null,
+    gitDrift: GitDrift | null
+  ): string {
+    const parts: string[] = [];
+
+    const fileCount = fileDrifts.length;
+    const structChanges = structureDrift ? structureDrift.addedFiles.length + structureDrift.removedFiles.length : 0;
+    const gitChanges = gitDrift ? gitDrift.uncommittedChanges.length : 0;
+
+    if (fileCount === 0 && structChanges === 0 && gitChanges === 0) {
+      return 'All context files are up to date with your codebase.';
+    }
+
+    if (fileCount > 0) {
+      parts.push(`${fileCount} files may be outdated`);
+    }
+
+    if (structChanges > 0) {
+      parts.push(`${structChanges} structural changes detected`);
+    }
+
+    if (gitChanges > 0) {
+      parts.push(`${gitChanges} uncommitted changes`);
+    }
+
+    return parts.join(', ') || 'No drift detected';
+  }
+
+  /**
+   * Display drift report
+   */
+  displayReport(report: DriftReport): string {
+    const lines: string[] = [];
+
+    lines.push('');
+    lines.push(K0NTEXT_THEME.header('━━━ Documentation Drift Analysis ━━━'));
+    lines.push('');
+
+    // Overall severity
+    const severityEmoji = {
+      critical: K0NTEXT_THEME.error('🔴 Critical'),
+      high: K0NTEXT_THEME.warning('🟠 High'),
+      medium: K0NTEXT_THEME.warning('🟡 Medium'),
+      low: K0NTEXT_THEME.success('🟢 Good')
+    }[report.overallSeverity];
+
+    lines.push(`  Overall Status:  ${severityEmoji}`);
+    lines.push(`  Summary:         ${report.summary}`);
+    lines.push('');
+
+    // File drifts
+    if (report.fileDrifts.length > 0) {
+      lines.push(K0NTEXT_THEME.header('━━━ File Date Drifts ━──'));
+
+      const bySeverity = this.groupBySeverity(report.fileDrifts);
+
+      for (const [severity, drifts] of Object.entries(bySeverity)) {
+        if (drifts.length === 0) continue;
+
+        const severityLabel = {
+          critical: '🔴 Critical',
+          high: '🟠 High',
+          medium: '🟡 Medium',
+          low: '🟢 Low'
+        }[severity as DriftSeverity];
+
+        lines.push(`  ${severityLabel} (${drifts.length} files):`);
+
+        for (const drift of drifts.slice(0, 5)) {
+          const icon = this.getFileTypeIcon(drift.fileType);
+          const days = drift.daysSince;
+          lines.push(`    ${icon} ${K0NTEXT_THEME.dim(drift.filePath)}`);
+          lines.push(`       ${K0NTEXT_THEME.dim(`not updated in ${days} days`)}`);
+        }
+
+        if (drifts.length > 5) {
+          lines.push(`    ${K0NTEXT_THEME.dim(`... and ${drifts.length - 5} more`)}`);
+        }
+
+        lines.push('');
+      }
+    }
+
+    // Structure drifts
+    if (report.structureDrift) {
+      lines.push(K0NTEXT_THEME.header('━━━ Structure Changes ━──'));
+
+      if (report.structureDrift.addedFiles.length > 0) {
+        lines.push(`  ${K0NTEXT_THEME.success('+')} New files: ${report.structureDrift.addedFiles.length}`);
+        for (const file of report.structureDrift.addedFiles.slice(0, 5)) {
+          lines.push(`    ${K0NTEXT_THEME.dim(file)}`);
+        }
+        if (report.structureDrift.addedFiles.length > 5) {
+          lines.push(`    ${K0NTEXT_THEME.dim('... and more')}`);
+        }
+        lines.push('');
+      }
+
+      if (report.structureDrift.removedFiles.length > 0) {
+        lines.push(`  ${K0NTEXT_THEME.error('-')} Removed files: ${report.structureDrift.removedFiles.length}`);
+        for (const file of report.structureDrift.removedFiles.slice(0, 5)) {
+          lines.push(`    ${K0NTEXT_THEME.dim(file)}`);
+        }
+        if (report.structureDrift.removedFiles.length > 5) {
+          lines.push(`    ${K0NTEXT_THEME.dim('... and more')}`);
+        }
+        lines.push('');
+      }
+    }
+
+    // Git drifts
+    if (report.gitDrift) {
+      lines.push(K0NTEXT_THEME.header('━━━ Git Changes ━──'));
+
+      if (report.gitDrift.uncommittedChanges.length > 0) {
+        lines.push(`  Uncommitted changes: ${report.gitDrift.uncommittedChanges.length}`);
+
+        for (const file of report.gitDrift.uncommittedChanges.slice(0, 5)) {
+          const status = file.includes('(new file)') ? 'new' : 'modified';
+          const statusIcon = status === 'new' ? K0NTEXT_THEME.success('+') : K0NTEXT_THEME.warning('~');
+          lines.push(`    ${statusIcon} ${K0NTEXT_THEME.dim(file)}`);
+        }
+        if (report.gitDrift.uncommittedChanges.length > 5) {
+          lines.push(`    ${K0NTEXT_THEME.dim('... and more')}`);
+        }
+        lines.push('');
+      }
+    }
+
+    // Recommendations
+    lines.push(K0NTEXT_THEME.header('━━━ Recommendations ━━━'));
+
+    if (report.overallSeverity === 'critical' || report.overallSeverity === 'high') {
+      lines.push(`  ${K0NTEXT_THEME.warning('⚠ Urgent action recommended:')}`);
+      lines.push(`    ${K0NTEXT_THEME.cyan('•')} Run ${K0NTEXT_THEME.highlight('index')} to update your context`);
+      lines.push(`    ${K0NTEXT_THEME.cyan('•')} Commit your changes to keep tracking in sync`);
+    } else if (report.overallSeverity === 'medium') {
+      lines.push(`  ${K0NTEXT_THEME.info('ℹ Consider updating soon:')}`);
+      lines.push(`    ${K0NTEXT_THEME.cyan('•')} Run ${K0NTEXT_THEME.highlight('index')} to refresh context`);
+    } else {
+      lines.push(`  ${K0NTEXT_THEME.success('✓ Your context is up to date!')}`);
+    }
+
+    lines.push('');
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Group drifts by severity
+   */
+  private groupBySeverity(drifts: FileDrift[]): Record<string, FileDrift[]> {
+    return {
+      critical: drifts.filter(d => d.severity === 'critical'),
+      high: drifts.filter(d => d.severity === 'high'),
+      medium: drifts.filter(d => d.severity === 'medium'),
+      low: drifts.filter(d => d.severity === 'low')
+    };
+  }
+
+  /**
+   * Get file type icon
+   */
+  private getFileTypeIcon(type: 'doc' | 'code' | 'config'): string {
+    const icons = {
+      doc: '📄',
+      code: '💻',
+      config: '⚙️'
+    };
+    return icons[type] || '📄';
+  }
+}