@zoebuildsai/trace 1.5.0

package/src/cliff-detection.ts

@@ -0,0 +1,232 @@
+/**
+ * Cliff Detection for Trace
+ * Warn about breaking changes before checkout/merge
+ */
+
+export interface CliffWarning {
+  type: 'breaking-change' | 'api-removal' | 'security-issue' | 'performance-regression';
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  description: string;
+  affectedFiles: string[];
+  suggestion: string;
+}
+
+export interface CliffAnalysis {
+  hasCliffs: boolean;
+  warnings: CliffWarning[];
+  safeToUpdate: boolean;
+  riskScore: number; // 0-100
+}
+
+export class CliffDetection {
+  // Common breaking change patterns
+  private static readonly BREAKING_PATTERNS = [
+    { pattern: /export (class|interface|type) \w+/g, label: 'Public API definition' },
+    { pattern: /async (function|\w+\()/g, label: 'Async function signature' },
+    { pattern: /constructor\(/g, label: 'Class constructor' },
+    { pattern: /throw new Error/g, label: 'Error throwing' },
+  ];
+
+  // API removal patterns
+  private static readonly REMOVAL_PATTERNS = [
+    { pattern: /deprecated/i, label: 'Deprecated API' },
+    { pattern: /removed in v\d+/i, label: 'Removal notice' },
+    { pattern: /no longer supported/i, label: 'Unsupported feature' },
+  ];
+
+  // Security issue patterns
+  private static readonly SECURITY_PATTERNS = [
+    { pattern: /TODO.*security/i, label: 'Security TODO' },
+    { pattern: /FIXME.*auth/i, label: 'Auth issue' },
+    { pattern: /vulnerable|exploit|vulnerability/i, label: 'Known vulnerability' },
+  ];
+
+  /**
+   * Analyze cliff risks between two versions
+   */
+  static analyzeCliff(
+    oldFiles: Map<string, string>,
+    newFiles: Map<string, string>
+  ): CliffAnalysis {
+    const warnings: CliffWarning[] = [];
+    let riskScore = 0;
+
+    // Check for removed files (major breaking change)
+    for (const [file] of oldFiles) {
+      if (!newFiles.has(file)) {
+        warnings.push({
+          type: 'breaking-change',
+          severity: 'high',
+          description: `File removed: ${file}`,
+          affectedFiles: [file],
+          suggestion: `Check if ${file} is still needed. If yes, restore from previous version.`,
+        });
+        riskScore += 25;
+      }
+    }
+
+    // Check for breaking changes in files
+    for (const [file, newContent] of newFiles) {
+      const oldContent = oldFiles.get(file);
+      if (!oldContent) continue; // New file, not a breaking change
+
+      const oldCliffs = this.findBreakingPatterns(oldContent, file);
+      const newCliffs = this.findBreakingPatterns(newContent, file);
+
+      // Check if breaking patterns were removed
+      if (oldCliffs.length > newCliffs.length) {
+        warnings.push({
+          type: 'api-removal',
+          severity: 'high',
+          description: `Public API removed from ${file}`,
+          affectedFiles: [file],
+          suggestion: `Review what was removed. Update code that depends on removed APIs.`,
+        });
+        riskScore += 20;
+      }
+
+      // Check for security issues
+      const securityWarnings = this.findSecurityIssues(newContent, file);
+      warnings.push(...securityWarnings);
+      riskScore += securityWarnings.length * 15;
+
+      // Check for performance regressions
+      if (this.hasPerformanceRegression(oldContent, newContent)) {
+        warnings.push({
+          type: 'performance-regression',
+          severity: 'medium',
+          description: `Potential performance regression in ${file}`,
+          affectedFiles: [file],
+          suggestion: `Run benchmarks before deploying to production.`,
+        });
+        riskScore += 10;
+      }
+    }
+
+    // Cap risk score at 100
+    riskScore = Math.min(riskScore, 100);
+
+    return {
+      hasCliffs: warnings.length > 0,
+      warnings,
+      safeToUpdate: warnings.filter(w => w.severity === 'critical').length === 0,
+      riskScore,
+    };
+  }
+
+  /**
+   * Find breaking patterns in code
+   */
+  private static findBreakingPatterns(content: string, file: string): string[] {
+    const patterns: string[] = [];
+
+    for (const { pattern, label } of this.BREAKING_PATTERNS) {
+      const matches = content.match(pattern);
+      if (matches) {
+        for (const match of matches) {
+          patterns.push(`${label}: ${match}`);
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Find security issues
+   */
+  private static findSecurityIssues(content: string, file: string): CliffWarning[] {
+    const warnings: CliffWarning[] = [];
+
+    for (const { pattern, label } of this.SECURITY_PATTERNS) {
+      if (pattern.test(content)) {
+        warnings.push({
+          type: 'security-issue',
+          severity: 'critical',
+          description: `${label} detected in ${file}`,
+          affectedFiles: [file],
+          suggestion: `Fix security issue before deploying.`,
+        });
+      }
+    }
+
+    return warnings;
+  }
+
+  /**
+   * Detect performance regressions
+   */
+  private static hasPerformanceRegression(oldContent: string, newContent: string): boolean {
+    const oldLoops = (oldContent.match(/for|while|forEach|map|reduce/g) || []).length;
+    const newLoops = (newContent.match(/for|while|forEach|map|reduce/g) || []).length;
+
+    // Significant increase in loops might indicate regression
+    if (newLoops > oldLoops * 2) {
+      return true;
+    }
+
+    // Check for new synchronous operations
+    if (newContent.includes('sync') && !oldContent.includes('sync')) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Get risk level from score
+   */
+  static getRiskLevel(score: number): 'safe' | 'caution' | 'warning' | 'dangerous' {
+    if (score < 20) return 'safe';
+    if (score < 50) return 'caution';
+    if (score < 80) return 'warning';
+    return 'dangerous';
+  }
+
+  /**
+   * Format warnings for human review
+   */
+  static formatWarnings(analysis: CliffAnalysis): string {
+    let output = `\n🏔️  CLIFF DETECTION REPORT\n`;
+    output += `Risk Level: ${this.getRiskLevel(analysis.riskScore).toUpperCase()} (${analysis.riskScore}/100)\n`;
+    output += `Safe to update: ${analysis.safeToUpdate ? '✅ YES' : '❌ NO'}\n\n`;
+
+    if (analysis.warnings.length === 0) {
+      output += `No breaking changes detected. Safe to update. 🎉\n`;
+      return output;
+    }
+
+    output += `${analysis.warnings.length} warning(s) found:\n`;
+    for (let i = 0; i < analysis.warnings.length; i++) {
+      const w = analysis.warnings[i];
+      output += `\n${i + 1}. [${w.severity.toUpperCase()}] ${w.type}\n`;
+      output += `   Description: ${w.description}\n`;
+      output += `   Files: ${w.affectedFiles.join(', ')}\n`;
+      output += `   Action: ${w.suggestion}\n`;
+    }
+
+    return output;
+  }
+
+  /**
+   * Pre-checkout warning
+   */
+  static checkBeforeCheckout(
+    currentFiles: Map<string, string>,
+    targetFiles: Map<string, string>
+  ): CliffAnalysis {
+    return this.analyzeCliff(currentFiles, targetFiles);
+  }
+
+  /**
+   * Pre-merge warning
+   */
+  static checkBeforeMerge(
+    baseFiles: Map<string, string>,
+    mergeFiles: Map<string, string>
+  ): CliffAnalysis {
+    return this.analyzeCliff(baseFiles, mergeFiles);
+  }
+}
+
+export default CliffDetection;

package/src/commands.ts

@@ -0,0 +1,267 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Storage } from './storage';
+import { Differ } from './diff';
+import { IndexCache } from './index-cache';
+import {
+  CommitObject,
+  TreeObject,
+  FileEntry,
+  StatusResult,
+  CommitOptions,
+  LogEntry,
+  CheckoutOptions,
+  DiffOptions,
+} from './types';
+
+export class TraceCommands {
+  private storage: Storage;
+  private differ: Differ;
+  private indexCache: IndexCache;
+  private currentCommit: string | null = null;
+
+  constructor(basePath: string = path.join(process.env.HOME || '', '.openclaw/memory-git')) {
+    this.storage = new Storage(basePath);
+    this.differ = new Differ(this.storage);
+    this.indexCache = new IndexCache(this.storage);
+    this.loadCurrentCommit();
+  }
+
+  private loadCurrentCommit(): void {
+    const ref = this.storage.loadRef('HEAD');
+    this.currentCommit = ref;
+  }
+
+  /**
+   * memory commit <message>
+   */
+  commit(message: string, author: string = 'agent', metadata?: Record<string, unknown>): string {
+    const startTime = Date.now();
+
+    // Load current commit (parent)
+    let parent: CommitObject | null = null;
+    if (this.currentCommit) {
+      parent = this.storage.loadCommit(this.currentCommit);
+    }
+
+    // Create tree for new commit
+    const files = this.readWorkingDirectory(parent?.tree);
+    const tree: TreeObject = {
+      files,
+      hash: '',
+    };
+
+    // Hash tree content
+    tree.hash = this.storage.hash(JSON.stringify(this.serializeTree(tree)));
+
+    // Create commit object
+    const commit: CommitObject = {
+      hash: '',
+      message,
+      timestamp: Date.now(),
+      author,
+      parent: this.currentCommit,
+      tree,
+      metadata,
+    };
+
+    // Hash commit
+    const commitContent = JSON.stringify({
+      message: commit.message,
+      timestamp: commit.timestamp,
+      author: commit.author,
+      parent: commit.parent,
+      tree: commit.tree.hash,
+    });
+    commit.hash = this.storage.hash(commitContent);
+
+    // Save to storage
+    this.storage.saveCommit(commit);
+    this.storage.saveRef('HEAD', commit.hash);
+    this.currentCommit = commit.hash;
+
+    const elapsed = Date.now() - startTime;
+    console.log(`[commit] ${commit.hash.slice(0, 8)} - ${elapsed}ms`);
+
+    return commit.hash;
+  }
+
+  /**
+   * memory log [--limit N]
+   */
+  log(limit?: number): LogEntry[] {
+    if (!this.currentCommit) {
+      return [];
+    }
+
+    const history = this.storage.getHistory(this.currentCommit);
+    const entries: LogEntry[] = history.map(c => ({
+      hash: c.hash,
+      shortHash: c.hash.slice(0, 8),
+      message: c.message,
+      timestamp: c.timestamp,
+      author: c.author,
+    }));
+
+    if (limit && limit > 0) {
+      return entries.slice(0, limit);
+    }
+
+    return entries;
+  }
+
+  /**
+   * memory diff <commit1> <commit2>
+   */
+  diff(hash1: string, hash2: string, options?: DiffOptions): string {
+    const commit1 = this.storage.loadCommit(hash1);
+    const commit2 = this.storage.loadCommit(hash2);
+
+    if (!commit1 || !commit2) {
+      throw new Error('One or both commits not found');
+    }
+
+    const result = this.differ.diff(commit1.tree, commit2.tree, options);
+    return this.differ.format(result);
+  }
+
+  /**
+   * memory checkout <commit>
+   */
+  checkout(hash: string, options?: CheckoutOptions): void {
+    const startTime = Date.now();
+    const commit = this.storage.loadCommit(hash);
+
+    if (!commit) {
+      throw new Error(`Commit ${hash} not found`);
+    }
+
+    // Restore files from commit
+    commit.tree.files.forEach(entry => {
+      if (entry.mode === 'file') {
+        // In production: read from blob storage
+        const filePath = path.join(process.env.HOME || '', '.openclaw/memory', entry.path);
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, `[blob:${entry.hash}]`);
+      }
+    });
+
+    this.storage.saveRef('HEAD', hash);
+    this.currentCommit = hash;
+    this.indexCache.invalidate(hash);
+
+    const elapsed = Date.now() - startTime;
+    console.log(`[checkout] ${hash.slice(0, 8)} - ${elapsed}ms`);
+  }
+
+  /**
+   * memory status
+   */
+  status(): StatusResult {
+    if (!this.currentCommit) {
+      return {
+        modified: [],
+        added: [],
+        deleted: [],
+        untracked: [],
+        clean: true,
+      };
+    }
+
+    const currentCommit = this.storage.loadCommit(this.currentCommit);
+    if (!currentCommit) {
+      throw new Error('Current commit not found');
+    }
+
+    const workingTree = this.readWorkingDirectory();
+    const diff = this.differ.diff(currentCommit.tree, workingTree);
+
+    return {
+      modified: Array.from(diff.modified.keys()),
+      added: Array.from(diff.added.keys()),
+      deleted: Array.from(diff.deleted.keys()),
+      untracked: this.findUntracked(currentCommit.tree, workingTree),
+      clean: diff.stats.totalChanges === 0,
+    };
+  }
+
+  /**
+   * Get current HEAD commit
+   */
+  getCurrentCommit(): CommitObject | null {
+    if (!this.currentCommit) {
+      return null;
+    }
+    return this.storage.loadCommit(this.currentCommit);
+  }
+
+  /**
+   * Read working directory and create tree
+   */
+  private readWorkingDirectory(baseTree?: TreeObject): Map<string, FileEntry> {
+    const memoryDir = path.join(process.env.HOME || '', '.openclaw/memory');
+    const files = new Map<string, FileEntry>();
+
+    if (!fs.existsSync(memoryDir)) {
+      return files;
+    }
+
+    const walk = (dir: string, prefix: string = ''): void => {
+      const entries = fs.readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const relativePath = path.join(prefix, entry).replace(/\\/g, '/');
+
+        if (fs.statSync(fullPath).isDirectory()) {
+          walk(fullPath, relativePath);
+        } else {
+          const stat = fs.statSync(fullPath);
+          const content = fs.readFileSync(fullPath);
+          const hash = this.storage.hash(content);
+
+          files.set(relativePath, {
+            path: relativePath,
+            hash,
+            size: stat.size,
+            mode: 'file',
+            lastModified: stat.mtime.getTime(),
+          });
+        }
+      }
+    };
+
+    walk(memoryDir);
+    return files;
+  }
+
+  /**
+   * Find untracked files
+   */
+  private findUntracked(committedTree: TreeObject, workingTree: Map<string, FileEntry>): string[] {
+    const untracked: string[] = [];
+    workingTree.forEach((entry, path) => {
+      if (!committedTree.files.has(path)) {
+        untracked.push(path);
+      }
+    });
+    return untracked;
+  }
+
+  /**
+   * Serialize tree for hashing
+   */
+  private serializeTree(tree: TreeObject): Record<string, unknown> {
+    const files: Record<string, unknown> = {};
+    tree.files.forEach((entry, path) => {
+      files[path] = {
+        hash: entry.hash,
+        size: entry.size,
+        mode: entry.mode,
+      };
+    });
+    return { files };
+  }
+}