@zoebuildsai/trace 1.5.0

package/src/stage-area.ts

@@ -0,0 +1,324 @@
+/**
+ * Stage Area for Trace
+ * Smart partial commits (like git add, but agent-native)
+ */
+
+export interface StagedChange {
+  path: string;
+  type: 'add' | 'modify' | 'delete';
+  oldContent?: string;
+  newContent?: string;
+  timestamp: number;
+}
+
+export interface CommitProposal {
+  stagedChanges: StagedChange[];
+  message: string;
+  type: 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore';
+  timestamp: number;
+}
+
+export class StageArea {
+  private staged: Map<string, StagedChange> = new Map();
+  private workingDirectory: Map<string, string> = new Map();
+  private lastCommit: Map<string, string> = new Map();
+
+  /**
+   * Stage a change
+   */
+  stageChange(
+    path: string,
+    type: 'add' | 'modify' | 'delete',
+    oldContent?: string,
+    newContent?: string
+  ): StagedChange {
+    const change: StagedChange = {
+      path,
+      type,
+      oldContent,
+      newContent,
+      timestamp: Date.now(),
+    };
+
+    this.staged.set(path, change);
+    return change;
+  }
+
+  /**
+   * Stage multiple changes at once
+   */
+  stageMultiple(changes: StagedChange[]): void {
+    for (const change of changes) {
+      this.staged.set(change.path, change);
+    }
+  }
+
+  /**
+   * Auto-stage all changes (git add .)
+   */
+  stageAll(workingDir: Map<string, string>): StagedChange[] {
+    const changes: StagedChange[] = [];
+
+    // Find modified/added files
+    for (const [path, content] of workingDir) {
+      const oldContent = this.lastCommit.get(path);
+      if (oldContent === undefined) {
+        // New file
+        changes.push({
+          path,
+          type: 'add',
+          newContent: content,
+          timestamp: Date.now(),
+        });
+      } else if (oldContent !== content) {
+        // Modified file
+        changes.push({
+          path,
+          type: 'modify',
+          oldContent,
+          newContent: content,
+          timestamp: Date.now(),
+        });
+      }
+    }
+
+    // Find deleted files
+    for (const [path] of this.lastCommit) {
+      if (!workingDir.has(path)) {
+        changes.push({
+          path,
+          type: 'delete',
+          oldContent: this.lastCommit.get(path),
+          timestamp: Date.now(),
+        });
+      }
+    }
+
+    this.stageMultiple(changes);
+    return changes;
+  }
+
+  /**
+   * Unstage a file
+   */
+  unstageFile(path: string): boolean {
+    return this.staged.delete(path);
+  }
+
+  /**
+   * Unstage all
+   */
+  unstageAll(): void {
+    this.staged.clear();
+  }
+
+  /**
+   * Get staged changes
+   */
+  getStagedChanges(): StagedChange[] {
+    return Array.from(this.staged.values());
+  }
+
+  /**
+   * Check if file is staged
+   */
+  isStaged(path: string): boolean {
+    return this.staged.has(path);
+  }
+
+  /**
+   * Get staging status
+   */
+  getStatus(): {
+    staged: number;
+    unstaged: number;
+    untracked: number;
+  } {
+    let unstaged = 0;
+    let untracked = 0;
+
+    for (const [path, content] of this.workingDirectory) {
+      if (this.staged.has(path)) continue; // Already staged
+
+      const lastContent = this.lastCommit.get(path);
+      if (lastContent === undefined) {
+        untracked++;
+      } else if (lastContent !== content) {
+        unstaged++;
+      }
+    }
+
+    return {
+      staged: this.staged.size,
+      unstaged,
+      untracked,
+    };
+  }
+
+  /**
+   * Create commit from staged changes
+   */
+  createCommit(message: string, type: 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore' = 'chore'): CommitProposal {
+    if (this.staged.size === 0) {
+      throw new Error('No staged changes to commit');
+    }
+
+    return {
+      stagedChanges: Array.from(this.staged.values()),
+      message,
+      type,
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Smart stage by semantic type
+   * Stage only 'feat:' changes for feature commit, etc.
+   */
+  stageByType(commitType: 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore'): StagedChange[] {
+    const patterns: Record<string, RegExp[]> = {
+      feature: [/^(src|lib)\/.+\.(ts|js)$/, /feat:/i],
+      fix: [/^(src|lib)\/.+\.(ts|js)$/, /fix:/i],
+      docs: [/\.md$/, /^docs\//],
+      test: [/\.test\.(ts|js)$/, /test:/i],
+      refactor: [/^(src|lib)\/.+\.(ts|js)$/],
+      chore: [/^(\.|\w+\.json|\.yml)/, /chore:/i],
+    };
+
+    const relevantPatterns = patterns[commitType] || [];
+    const staged: StagedChange[] = [];
+
+    for (const change of this.staged.values()) {
+      if (relevantPatterns.some(p => p.test(change.path))) {
+        staged.push(change);
+      }
+    }
+
+    return staged;
+  }
+
+  /**
+   * Discard staged changes (reset before commit)
+   */
+  discardStaged(): void {
+    this.staged.clear();
+  }
+
+  /**
+   * Update working directory reference
+   */
+  updateWorkingDirectory(files: Map<string, string>): void {
+    this.workingDirectory = new Map(files);
+  }
+
+  /**
+   * Record commit (update lastCommit reference)
+   */
+  recordCommit(files: Map<string, string>): void {
+    this.lastCommit = new Map(files);
+    this.staged.clear();
+  }
+
+  /**
+   * Diff staged vs last commit
+   */
+  getDiff(): Map<string, { old?: string; new?: string }> {
+    const diff = new Map<string, { old?: string; new?: string }>();
+
+    for (const change of this.staged.values()) {
+      diff.set(change.path, {
+        old: change.oldContent,
+        new: change.newContent,
+      });
+    }
+
+    return diff;
+  }
+
+  /**
+   * Get staging stats
+   */
+  getStats(): {
+    stagedFiles: number;
+    addedFiles: number;
+    modifiedFiles: number;
+    deletedFiles: number;
+    estimatedSize: number;
+  } {
+    const changes = Array.from(this.staged.values());
+    let estimatedSize = 0;
+
+    const addedFiles = changes.filter(c => c.type === 'add').length;
+    const modifiedFiles = changes.filter(c => c.type === 'modify').length;
+    const deletedFiles = changes.filter(c => c.type === 'delete').length;
+
+    for (const change of changes) {
+      if (change.newContent) {
+        estimatedSize += change.newContent.length;
+      }
+    }
+
+    return {
+      stagedFiles: changes.length,
+      addedFiles,
+      modifiedFiles,
+      deletedFiles,
+      estimatedSize,
+    };
+  }
+
+  /**
+   * Detect type from staged changes
+   */
+  detectCommitType(): 'feature' | 'fix' | 'docs' | 'test' | 'refactor' | 'chore' {
+    const changes = Array.from(this.staged.values());
+
+    // Check file patterns
+    const testFiles = changes.filter(c => /\.test\.(ts|js)$/.test(c.path)).length;
+    const docFiles = changes.filter(c => /\.md$/.test(c.path)).length;
+    const srcFiles = changes.filter(c => /^(src|lib)\/.+\.(ts|js)$/.test(c.path)).length;
+
+    if (testFiles > srcFiles) return 'test';
+    if (docFiles > 0 && srcFiles === 0) return 'docs';
+    if (srcFiles > 0) return 'feature'; // Default to feature for code changes
+
+    return 'chore';
+  }
+
+  /**
+   * Validate commit (all files present, no conflicts)
+   */
+  validateCommit(): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (this.staged.size === 0) {
+      errors.push('No staged changes');
+      return { valid: false, errors };
+    }
+
+    // Check for conflicting changes (e.g., add + delete same file)
+    const pathCounts = new Map<string, number>();
+    for (const change of this.staged.values()) {
+      pathCounts.set(change.path, (pathCounts.get(change.path) || 0) + 1);
+    }
+
+    for (const [path, count] of pathCounts) {
+      if (count > 1) {
+        errors.push(`File ${path} has multiple staged changes`);
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Clear stage (for testing)
+   */
+  clear(): void {
+    this.staged.clear();
+    this.workingDirectory.clear();
+    this.lastCommit.clear();
+  }
+}
+
+export default StageArea;

package/src/stash.ts

@@ -0,0 +1,278 @@
+/**
+ * Stash for Trace
+ * Temporary work storage (save WIP without committing)
+ */
+
+export interface StashedWork {
+  id: string;
+  description: string;
+  timestamp: number;
+  files: Map<string, string>;
+  branch: string;
+  author: string;
+}
+
+export interface StashEntry {
+  id: string;
+  description: string;
+  timestamp: number;
+  branch: string;
+  author: string;
+  fileCount: number;
+}
+
+export class Stash {
+  private stashes: Map<string, StashedWork> = new Map();
+  private stashStack: string[] = []; // LIFO stack for pop
+  private authorStashes: Map<string, string[]> = new Map(); // author -> [stash IDs]
+
+  /**
+   * Stash current work
+   */
+  stash(
+    files: Map<string, string>,
+    description: string,
+    branch: string,
+    author: string
+  ): StashedWork {
+    const id = this.generateStashId();
+    const stashed: StashedWork = {
+      id,
+      description,
+      timestamp: Date.now(),
+      files: new Map(files),
+      branch,
+      author,
+    };
+
+    this.stashes.set(id, stashed);
+    this.stashStack.push(id);
+
+    if (!this.authorStashes.has(author)) {
+      this.authorStashes.set(author, []);
+    }
+    this.authorStashes.get(author)!.push(id);
+
+    return stashed;
+  }
+
+  /**
+   * Pop stash (apply and remove most recent)
+   */
+  pop(): StashedWork | undefined {
+    if (this.stashStack.length === 0) {
+      return undefined;
+    }
+
+    const id = this.stashStack.pop()!;
+    const stashed = this.stashes.get(id);
+
+    if (stashed) {
+      // Remove from author tracking
+      const authorStashes = this.authorStashes.get(stashed.author) || [];
+      this.authorStashes.set(
+        stashed.author,
+        authorStashes.filter(s => s !== id)
+      );
+
+      this.stashes.delete(id);
+    }
+
+    return stashed;
+  }
+
+  /**
+   * Apply stash without removing (like git stash apply)
+   */
+  apply(stashId: string): StashedWork | undefined {
+    return this.stashes.get(stashId);
+  }
+
+  /**
+   * List all stashes
+   */
+  list(): StashEntry[] {
+    return Array.from(this.stashes.values()).map(s => ({
+      id: s.id,
+      description: s.description,
+      timestamp: s.timestamp,
+      branch: s.branch,
+      author: s.author,
+      fileCount: s.files.size,
+    }));
+  }
+
+  /**
+   * Get stashes for author
+   */
+  getByAuthor(author: string): StashEntry[] {
+    const ids = this.authorStashes.get(author) || [];
+    return ids
+      .map(id => this.stashes.get(id))
+      .filter((s): s is StashedWork => s !== undefined)
+      .map(s => ({
+        id: s.id,
+        description: s.description,
+        timestamp: s.timestamp,
+        branch: s.branch,
+        author: s.author,
+        fileCount: s.files.size,
+      }));
+  }
+
+  /**
+   * Get stashes for branch
+   */
+  getByBranch(branch: string): StashEntry[] {
+    return Array.from(this.stashes.values())
+      .filter(s => s.branch === branch)
+      .map(s => ({
+        id: s.id,
+        description: s.description,
+        timestamp: s.timestamp,
+        branch: s.branch,
+        author: s.author,
+        fileCount: s.files.size,
+      }));
+  }
+
+  /**
+   * Drop stash (delete without applying)
+   */
+  drop(stashId: string): boolean {
+    const stashed = this.stashes.get(stashId);
+    if (!stashed) {
+      return false;
+    }
+
+    this.stashes.delete(stashId);
+    this.stashStack = this.stashStack.filter(id => id !== stashId);
+
+    const authorStashes = this.authorStashes.get(stashed.author) || [];
+    this.authorStashes.set(
+      stashed.author,
+      authorStashes.filter(s => s !== stashId)
+    );
+
+    return true;
+  }
+
+  /**
+   * Clear all stashes
+   */
+  clearAll(): void {
+    this.stashes.clear();
+    this.stashStack = [];
+    this.authorStashes.clear();
+  }
+
+  /**
+   * Get stash details
+   */
+  getStash(stashId: string): StashedWork | undefined {
+    return this.stashes.get(stashId);
+  }
+
+  /**
+   * Check if stash exists
+   */
+  hasStash(stashId: string): boolean {
+    return this.stashes.has(stashId);
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): {
+    totalStashes: number;
+    oldestStash?: StashEntry;
+    newestStash?: StashEntry;
+    totalFiles: number;
+  } {
+    const entries = this.list();
+    if (entries.length === 0) {
+      return { totalStashes: 0, totalFiles: 0 };
+    }
+
+    const oldest = entries.reduce((a, b) => (a.timestamp < b.timestamp ? a : b));
+    const newest = entries.reduce((a, b) => (a.timestamp > b.timestamp ? a : b));
+
+    const totalFiles = Array.from(this.stashes.values()).reduce(
+      (sum, s) => sum + s.files.size,
+      0
+    );
+
+    return {
+      totalStashes: entries.length,
+      oldestStash: oldest,
+      newestStash: newest,
+      totalFiles,
+    };
+  }
+
+  /**
+   * Auto-stash before checkout (safety)
+   */
+  autoStashIfDirty(
+    files: Map<string, string>,
+    lastCommit: Map<string, string>,
+    branch: string,
+    author: string
+  ): StashedWork | null {
+    // Check if working directory is dirty
+    let isDirty = false;
+
+    for (const [path, content] of files) {
+      if (lastCommit.get(path) !== content) {
+        isDirty = true;
+        break;
+      }
+    }
+
+    // Check for new files
+    if (!isDirty) {
+      for (const path of files.keys()) {
+        if (!lastCommit.has(path)) {
+          isDirty = true;
+          break;
+        }
+      }
+    }
+
+    if (isDirty) {
+      return this.stash(files, `Auto-stash before checkout (${branch})`, branch, author);
+    }
+
+    return null;
+  }
+
+  /**
+   * Format stash list for display
+   */
+  static formatList(entries: StashEntry[]): string {
+    if (entries.length === 0) {
+      return 'No stashes found.';
+    }
+
+    let output = `\n📦 STASHES (${entries.length} total):\n`;
+
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      output += `${i}. stash@{${i}} (${entry.id.substring(0, 7)})\n`;
+      output += `   Description: ${entry.description}\n`;
+      output += `   Author: ${entry.author} | Branch: ${entry.branch}\n`;
+      output += `   Files: ${entry.fileCount} | Created: ${new Date(entry.timestamp).toISOString()}\n`;
+    }
+
+    return output;
+  }
+
+  /**
+   * Generate stash ID
+   */
+  private generateStashId(): string {
+    return `stash-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  }
+}
+
+export default Stash;

package/src/storage.ts

@@ -0,0 +1,131 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { CommitObject, TreeObject, FileEntry } from './types';
+
+export class Storage {
+  private basePath: string;
+  private objectsDir: string;
+  private refsDir: string;
+
+  constructor(basePath: string = path.join(process.env.HOME || '', '.openclaw/memory-git')) {
+    this.basePath = basePath;
+    this.objectsDir = path.join(basePath, 'objects');
+    this.refsDir = path.join(basePath, 'refs');
+    this.ensureDirectories();
+  }
+
+  private ensureDirectories(): void {
+    [this.basePath, this.objectsDir, this.refsDir].forEach(dir => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+  }
+
+  /**
+   * Compute SHA-256 hash of content
+   */
+  hash(content: string | Buffer): string {
+    const buffer = typeof content === 'string' ? Buffer.from(content, 'utf-8') : content;
+    return crypto.createHash('sha256').update(buffer).digest('hex');
+  }
+
+  /**
+   * Save commit object to storage
+   */
+  saveCommit(commit: CommitObject): void {
+    const commitPath = path.join(this.objectsDir, `${commit.hash}.json`);
+    fs.writeFileSync(commitPath, JSON.stringify(commit, this.replaceMapValues, 2));
+  }
+
+  /**
+   * Load commit object from storage
+   */
+  loadCommit(hash: string): CommitObject | null {
+    const commitPath = path.join(this.objectsDir, `${hash}.json`);
+    if (!fs.existsSync(commitPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(commitPath, 'utf-8');
+    const commit = JSON.parse(content) as CommitObject;
+    const filesRecord = commit.tree.files as unknown as Record<string, FileEntry>;
+    commit.tree.files = new Map(Object.entries(filesRecord));
+    return commit;
+  }
+
+  /**
+   * Save reference (branch/tag)
+   */
+  saveRef(name: string, hash: string): void {
+    const refPath = path.join(this.refsDir, name);
+    fs.mkdirSync(path.dirname(refPath), { recursive: true });
+    fs.writeFileSync(refPath, hash);
+  }
+
+  /**
+   * Load reference
+   */
+  loadRef(name: string): string | null {
+    const refPath = path.join(this.refsDir, name);
+    if (!fs.existsSync(refPath)) {
+      return null;
+    }
+    return fs.readFileSync(refPath, 'utf-8').trim();
+  }
+
+  /**
+   * List all commits
+   */
+  listCommits(): string[] {
+    if (!fs.existsSync(this.objectsDir)) {
+      return [];
+    }
+    return fs
+      .readdirSync(this.objectsDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.replace('.json', ''));
+  }
+
+  /**
+   * Delete commit
+   */
+  deleteCommit(hash: string): void {
+    const commitPath = path.join(this.objectsDir, `${hash}.json`);
+    if (fs.existsSync(commitPath)) {
+      fs.unlinkSync(commitPath);
+    }
+  }
+
+  /**
+   * Get commit history chain
+   */
+  getHistory(startHash: string): CommitObject[] {
+    const history: CommitObject[] = [];
+    let current: CommitObject | null = this.loadCommit(startHash);
+
+    while (current !== null) {
+      history.push(current);
+      if (current.parent === null) {
+        break;
+      }
+      current = this.loadCommit(current.parent);
+    }
+
+    return history;
+  }
+
+  /**
+   * Helper to serialize Maps as objects for JSON
+   */
+  private replaceMapValues(key: string, value: unknown): unknown {
+    if (value instanceof Map) {
+      const obj: Record<string, unknown> = {};
+      value.forEach((v, k) => {
+        obj[k] = v;
+      });
+      return obj;
+    }
+    return value;
+  }
+}