@zoebuildsai/trace 1.5.0

package/src/index-cache.ts

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { IndexCache as IndexCacheType, CachedFile } from './types';
+import { Storage } from './storage';
+
+export class IndexCache {
+  private cache: Map<string, IndexCacheType> = new Map();
+  private storage: Storage;
+  private cacheDir: string;
+  private ttl: number;
+
+  constructor(storage: Storage, cacheDir: string = path.join(process.env.HOME || '', '.openclaw/memory-git/.cache'), ttl: number = 5000) {
+    this.storage = storage;
+    this.cacheDir = cacheDir;
+    this.ttl = ttl;
+    this.ensureDir();
+  }
+
+  private ensureDir(): void {
+    if (!fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Load or create cache entry
+   */
+  getOrCreate(commitHash: string): IndexCacheType {
+    if (!this.cache.has(commitHash)) {
+      this.cache.set(commitHash, {
+        timestamp: Date.now(),
+        files: new Map(),
+        currentCommit: commitHash,
+      });
+    }
+    return this.cache.get(commitHash)!;
+  }
+
+  /**
+   * Check if cache is still valid
+   */
+  isValid(commitHash: string): boolean {
+    const cached = this.cache.get(commitHash);
+    if (!cached) return false;
+    return Date.now() - cached.timestamp < this.ttl;
+  }
+
+  /**
+   * Mark file as cached
+   */
+  markFile(commitHash: string, filePath: string, hash: string, modified: boolean = false): void {
+    const cacheEntry = this.getOrCreate(commitHash);
+    cacheEntry.files.set(filePath, {
+      path: filePath,
+      hash,
+      lastSeen: Date.now(),
+      modified,
+    });
+  }
+
+  /**
+   * Get cached file info
+   */
+  getFile(commitHash: string, filePath: string): CachedFile | null {
+    const cacheEntry = this.cache.get(commitHash);
+    if (!cacheEntry) return null;
+    return cacheEntry.files.get(filePath) || null;
+  }
+
+  /**
+   * Invalidate cache for commit
+   */
+  invalidate(commitHash: string): void {
+    this.cache.delete(commitHash);
+  }
+
+  /**
+   * Clear all expired entries
+   */
+  prune(): void {
+    const now = Date.now();
+    for (const [hash, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.ttl) {
+        this.cache.delete(hash);
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Trace - Agent-native version control with remote sync
+ */
+
+export { Storage } from './storage';
+export { Differ } from './diff';
+export { IndexCache } from './index-cache';
+export { TraceCommands } from './commands';
+export { AutoCommitter } from './auto-commit';
+export { TagManager } from './tags';
+export { TraceSync } from './sync';
+
+export type {
+  CommitObject,
+  TreeObject,
+  FileEntry,
+  DiffResult,
+  DiffChange,
+  DiffStats,
+  LineDiff,
+  StatusResult,
+  LogEntry,
+  CommitOptions,
+  CheckoutOptions,
+  DiffOptions,
+  IndexCache as IndexCacheType,
+  CachedFile,
+  AutoCommitMetadata,
+  TagInfo,
+  BranchInfo,
+} from './types';
+
+// Default export
+import { TraceCommands } from './commands';
+
+const defaultInstance = new TraceCommands();
+
+export default defaultInstance;

package/src/merge-engine.ts

@@ -0,0 +1,143 @@
+/**
+ * Merge Engine for Trace
+ * Intelligent 3-way merge for multi-agent conflict resolution
+ */
+
+export interface FileMerge {
+  path: string;
+  baseVersion: string;
+  theirVersion: string;
+  ourVersion: string;
+  mergedContent?: string;
+  conflicts?: ConflictHunk[];
+  strategy: 'auto' | 'theirs' | 'ours' | 'manual';
+}
+
+export interface ConflictHunk {
+  startLine: number;
+  endLine: number;
+  ours: string[];
+  theirs: string[];
+}
+
+export class MergeEngine {
+  /**
+   * 3-way merge: base, ours, theirs
+   */
+  static merge(base: string, ours: string, theirs: string, strategy: 'auto' | 'theirs' | 'ours' = 'auto'): FileMerge {
+    const baseLine = base.split('\n');
+    const ourLines = ours.split('\n');
+    const theirLines = theirs.split('\n');
+
+    const conflicts = this.findConflicts(baseLine, ourLines, theirLines);
+
+    let mergedContent = ours;
+    let resolvedStrategy = strategy;
+
+    if (conflicts.length === 0) {
+      // No conflicts, merge is clean
+      mergedContent = this.applyDiff(baseLine, theirLines, ourLines);
+      resolvedStrategy = 'auto';
+    } else {
+      switch (strategy) {
+        case 'auto':
+          resolvedStrategy = 'manual'; // Can't auto-resolve with conflicts
+          break;
+        case 'theirs':
+          mergedContent = theirs;
+          break;
+        case 'ours':
+          mergedContent = ours;
+          break;
+        case 'manual':
+          // Return conflicts for manual resolution
+          break;
+      }
+    }
+
+    return {
+      path: '',
+      baseVersion: '',
+      theirVersion: '',
+      ourVersion: '',
+      mergedContent,
+      conflicts: conflicts.length > 0 ? conflicts : undefined,
+      strategy: resolvedStrategy,
+    };
+  }
+
+  /**
+   * Find conflicting hunks (lines that differ between versions)
+   */
+  private static findConflicts(
+    base: string[],
+    ours: string[],
+    theirs: string[]
+  ): ConflictHunk[] {
+    const conflicts: ConflictHunk[] = [];
+
+    // Simple conflict detection: find regions where ours differs from base AND theirs differs from base
+    for (let i = 0; i < Math.max(base.length, ours.length, theirs.length); i++) {
+      const baseLine = base[i] || '';
+      const ourLine = ours[i] || '';
+      const theirLine = theirs[i] || '';
+
+      // Conflict if both sides changed the same line differently
+      if (baseLine !== ourLine && baseLine !== theirLine && ourLine !== theirLine) {
+        conflicts.push({
+          startLine: i,
+          endLine: i + 1,
+          ours: [ourLine],
+          theirs: [theirLine],
+        });
+      }
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * Apply diff to base (simplified)
+   */
+  private static applyDiff(base: string[], target: string[], reference: string[]): string {
+    // If one side didn't change from base, take the other side's changes
+    let result = [...base];
+
+    // If reference (ours) is same as base, take target (theirs)
+    if (base.length === reference.length && base.every((l, i) => l === reference[i])) {
+      result = target;
+    }
+
+    return result.join('\n');
+  }
+
+  /**
+   * Resolve conflict: choose winner based on strategy
+   */
+  static resolveHunk(hunk: ConflictHunk, strategy: 'theirs' | 'ours'): string[] {
+    return strategy === 'theirs' ? hunk.theirs : hunk.ours;
+  }
+
+  /**
+   * Check if merge is clean (no conflicts)
+   */
+  static isClean(merge: FileMerge): boolean {
+    return !merge.conflicts || merge.conflicts.length === 0;
+  }
+
+  /**
+   * Get merge quality score (0-100)
+   */
+  static getQualityScore(merge: FileMerge): number {
+    if (this.isClean(merge)) return 100;
+
+    const conflictCount = merge.conflicts?.length || 0;
+    const totalLines = merge.ourVersion.split('\n').length;
+
+    // Score based on conflict density
+    const conflictDensity = conflictCount / totalLines;
+    return Math.max(0, 100 - conflictDensity * 500);
+  }
+}
+
+export default MergeEngine;

package/src/message-search.ts

@@ -0,0 +1,370 @@
+/**
+ * Message Search for Trace
+ * Full-text search across commit history
+ */
+
+export interface SearchResult {
+  commitHash: string;
+  author: string;
+  timestamp: number;
+  message: string;
+  matchedFields: string[];
+  relevanceScore: number;
+}
+
+export interface SearchQuery {
+  text?: string;
+  author?: string;
+  dateAfter?: number;
+  dateBefore?: number;
+  type?: 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore' | 'security';
+  files?: string[];
+  limit?: number;
+}
+
+export class MessageSearch {
+  private commits: Map<
+    string,
+    {
+      hash: string;
+      message: string;
+      author: string;
+      timestamp: number;
+      files: string[];
+      type: string;
+    }
+  > = new Map();
+
+  private index: Map<string, Set<string>> = new Map(); // word -> commit hashes
+  private authorIndex: Map<string, Set<string>> = new Map(); // author -> commit hashes
+  private typeIndex: Map<string, Set<string>> = new Map(); // type -> commit hashes
+  private fileIndex: Map<string, Set<string>> = new Map(); // file -> commit hashes
+
+  /**
+   * Index commit for search
+   */
+  indexCommit(
+    hash: string,
+    message: string,
+    author: string,
+    timestamp: number,
+    files: string[] = [],
+    type: string = 'chore'
+  ): void {
+    this.commits.set(hash, {
+      hash,
+      message,
+      author,
+      timestamp,
+      files,
+      type,
+    });
+
+    // Index words from message
+    const words = this.tokenize(message);
+    for (const word of words) {
+      if (!this.index.has(word)) {
+        this.index.set(word, new Set());
+      }
+      this.index.get(word)!.add(hash);
+    }
+
+    // Index author
+    if (!this.authorIndex.has(author)) {
+      this.authorIndex.set(author, new Set());
+    }
+    this.authorIndex.get(author)!.add(hash);
+
+    // Index type
+    if (!this.typeIndex.has(type)) {
+      this.typeIndex.set(type, new Set());
+    }
+    this.typeIndex.get(type)!.add(hash);
+
+    // Index files
+    for (const file of files) {
+      if (!this.fileIndex.has(file)) {
+        this.fileIndex.set(file, new Set());
+      }
+      this.fileIndex.get(file)!.add(hash);
+    }
+  }
+
+  /**
+   * Search commits
+   */
+  search(query: SearchQuery): SearchResult[] {
+    let results = new Set<string>();
+    let firstFilter = true;
+
+    // Text search
+    if (query.text) {
+      const words = this.tokenize(query.text);
+      for (const word of words) {
+        const matches = this.index.get(word) || new Set();
+        if (firstFilter) {
+          results = new Set(matches);
+          firstFilter = false;
+        } else {
+          // Intersect with results
+          results = new Set([...results].filter(r => matches.has(r)));
+        }
+      }
+    }
+
+    // Author filter
+    if (query.author) {
+      const authorMatches = this.authorIndex.get(query.author) || new Set();
+      if (firstFilter) {
+        results = new Set(authorMatches);
+        firstFilter = false;
+      } else {
+        results = new Set([...results].filter(r => authorMatches.has(r)));
+      }
+    }
+
+    // Type filter
+    if (query.type) {
+      const typeMatches = this.typeIndex.get(query.type) || new Set();
+      if (firstFilter) {
+        results = new Set(typeMatches);
+        firstFilter = false;
+      } else {
+        results = new Set([...results].filter(r => typeMatches.has(r)));
+      }
+    }
+
+    // File filter
+    if (query.files && query.files.length > 0) {
+      const fileMatches = new Set<string>();
+      for (const file of query.files) {
+        const matches = this.fileIndex.get(file) || new Set();
+        matches.forEach(m => fileMatches.add(m));
+      }
+      
+      if (firstFilter) {
+        results = fileMatches;
+        firstFilter = false;
+      } else {
+        results = new Set([...results].filter(r => fileMatches.has(r)));
+      }
+    }
+
+    // Date range filter
+    const filtered = Array.from(results)
+      .map(hash => this.commits.get(hash)!)
+      .filter(commit => {
+        if (query.dateAfter && commit.timestamp < query.dateAfter) return false;
+        if (query.dateBefore && commit.timestamp > query.dateBefore) return false;
+        return true;
+      });
+
+    // Score and sort
+    const scored = filtered.map(commit => ({
+      commitHash: commit.hash,
+      author: commit.author,
+      timestamp: commit.timestamp,
+      message: commit.message,
+      matchedFields: this.getMatchedFields(commit, query),
+      relevanceScore: this.calculateScore(commit, query),
+    }));
+
+    scored.sort((a, b) => b.relevanceScore - a.relevanceScore);
+
+    const limit = query.limit || 20;
+    return scored.slice(0, limit);
+  }
+
+  /**
+   * Tokenize message for indexing
+   */
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^\w\s#-]/g, '')
+      .split(/\s+/)
+      .filter(word => word.length > 2 && !this.isStopword(word));
+  }
+
+  /**
+   * Check if word is stopword
+   */
+  private isStopword(word: string): boolean {
+    const stopwords = new Set([
+      'the', 'a', 'an', 'and', 'or', 'but', 'is', 'was', 'are',
+      'been', 'be', 'have', 'has', 'had', 'do', 'does', 'did',
+      'will', 'would', 'could', 'should', 'may', 'might', 'can',
+      'for', 'with', 'to', 'of', 'in', 'on', 'at', 'by', 'from',
+    ]);
+    return stopwords.has(word);
+  }
+
+  /**
+   * Get matched fields for a commit
+   */
+  private getMatchedFields(commit: any, query: SearchQuery): string[] {
+    const matched: string[] = [];
+
+    if (query.text) {
+      const words = this.tokenize(query.text);
+      if (words.some(w => commit.message.toLowerCase().includes(w))) {
+        matched.push('message');
+      }
+    }
+
+    if (query.author && commit.author === query.author) {
+      matched.push('author');
+    }
+
+    if (query.type && commit.type === query.type) {
+      matched.push('type');
+    }
+
+    return matched;
+  }
+
+  /**
+   * Calculate relevance score
+   */
+  private calculateScore(commit: any, query: SearchQuery): number {
+    let score = 0;
+
+    // Text relevance (count matching words)
+    if (query.text) {
+      const words = this.tokenize(query.text);
+      const messageWords = this.tokenize(commit.message);
+      const matches = words.filter(w => messageWords.includes(w)).length;
+      score += matches * 10;
+    }
+
+    // Exact type match
+    if (query.type && commit.type === query.type) {
+      score += 5;
+    }
+
+    // Exact author match
+    if (query.author && commit.author === query.author) {
+      score += 3;
+    }
+
+    // Recency (more recent = higher score)
+    const ageInDays = (Date.now() - commit.timestamp) / (1000 * 60 * 60 * 24);
+    score += Math.max(0, 2 - ageInDays / 30); // Decay over month
+
+    return score;
+  }
+
+  /**
+   * Search by regex pattern
+   */
+  searchByPattern(pattern: RegExp, limit: number = 20): SearchResult[] {
+    const matches: SearchResult[] = [];
+
+    for (const [hash, commit] of this.commits) {
+      if (pattern.test(commit.message)) {
+        matches.push({
+          commitHash: hash,
+          author: commit.author,
+          timestamp: commit.timestamp,
+          message: commit.message,
+          matchedFields: ['message'],
+          relevanceScore: 1.0,
+        });
+      }
+
+      if (matches.length >= limit) break;
+    }
+
+    return matches;
+  }
+
+  /**
+   * Get commits by author
+   */
+  getByAuthor(author: string, limit: number = 20): SearchResult[] {
+    const hashes = this.authorIndex.get(author) || new Set();
+    return Array.from(hashes)
+      .slice(0, limit)
+      .map(hash => {
+        const commit = this.commits.get(hash)!;
+        return {
+          commitHash: hash,
+          author: commit.author,
+          timestamp: commit.timestamp,
+          message: commit.message,
+          matchedFields: ['author'],
+          relevanceScore: 1.0,
+        };
+      });
+  }
+
+  /**
+   * Get commits by type
+   */
+  getByType(type: string, limit: number = 20): SearchResult[] {
+    const hashes = this.typeIndex.get(type) || new Set();
+    return Array.from(hashes)
+      .slice(0, limit)
+      .map(hash => {
+        const commit = this.commits.get(hash)!;
+        return {
+          commitHash: hash,
+          author: commit.author,
+          timestamp: commit.timestamp,
+          message: commit.message,
+          matchedFields: ['type'],
+          relevanceScore: 1.0,
+        };
+      });
+  }
+
+  /**
+   * Get commits that touched file
+   */
+  getByFile(file: string, limit: number = 20): SearchResult[] {
+    const hashes = this.fileIndex.get(file) || new Set();
+    return Array.from(hashes)
+      .slice(0, limit)
+      .map(hash => {
+        const commit = this.commits.get(hash)!;
+        return {
+          commitHash: hash,
+          author: commit.author,
+          timestamp: commit.timestamp,
+          message: commit.message,
+          matchedFields: ['file'],
+          relevanceScore: 1.0,
+        };
+      });
+  }
+
+  /**
+   * Get search stats
+   */
+  getStats(): {
+    totalIndexedCommits: number;
+    uniqueAuthors: number;
+    uniqueFiles: number;
+    uniqueWords: number;
+  } {
+    return {
+      totalIndexedCommits: this.commits.size,
+      uniqueAuthors: this.authorIndex.size,
+      uniqueFiles: this.fileIndex.size,
+      uniqueWords: this.index.size,
+    };
+  }
+
+  /**
+   * Clear index (for testing)
+   */
+  clearIndex(): void {
+    this.commits.clear();
+    this.index.clear();
+    this.authorIndex.clear();
+    this.typeIndex.clear();
+    this.fileIndex.clear();
+  }
+}
+
+export default MessageSearch;