@zoebuildsai/trace 1.5.0

package/tests/phase2-integration.test.ts

@@ -0,0 +1,370 @@
+/**
+ * Phase 2 Integration Tests
+ * 
+ * Full workflow tests combining auto-commit and tags:
+ * - Auto-commit + tags workflow
+ * - Manual + auto-commits mixed
+ * - Branching with auto-commits
+ * - Tag-based workflows
+ * - Complex state transitions
+ */
+
+import { AutoCommitter } from '../src/auto-commit';
+import { TagManager } from '../src/tags';
+import { TraceCommands } from '../src/commands';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('Phase 2 Integration - Auto-Commit + Tags', () => {
+  let testDir: string;
+  let homeDir: string;
+  let memoryDir: string;
+  let commands: TraceCommands;
+  let autoCommitter: AutoCommitter;
+  let tagManager: TagManager;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-phase2-'));
+    homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'home-'));
+    process.env.HOME = homeDir;
+    memoryDir = path.join(homeDir, '.openclaw/memory');
+    fs.mkdirSync(memoryDir, { recursive: true });
+    
+    commands = new TraceCommands(testDir);
+    autoCommitter = new AutoCommitter(commands, memoryDir);
+    tagManager = new TagManager(commands, testDir);
+  });
+
+  afterEach(() => {
+    if (autoCommitter) {
+      autoCommitter.stop();
+    }
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+    if (fs.existsSync(homeDir)) {
+      fs.rmSync(homeDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Auto-commit + manual commits', () => {
+    it('should handle mixed auto and manual commits', () => {
+      const file = path.join(memoryDir, 'mixed.md');
+      fs.writeFileSync(file, 'start');
+
+      autoCommitter.start({ interval: 100 });
+
+      // Manual commit
+      const manualHash = commands.commit('manual commit 1');
+
+      // Modify file
+      fs.writeFileSync(file, 'auto change 1');
+
+      // Manual commit
+      commands.commit('manual commit 2');
+
+      const log = commands.log(10);
+      expect(log.length).toBeGreaterThanOrEqual(3);
+      
+      const hasManual = log.some(entry => 
+        entry.message === 'manual commit 1' || 
+        entry.message === 'manual commit 2'
+      );
+      expect(hasManual).toBe(true);
+
+      autoCommitter.stop();
+    });
+
+    it('should distinguish auto from manual in history', () => {
+      const file = path.join(memoryDir, 'distinguish.md');
+      
+      autoCommitter.start({ interval: 100 });
+
+      // Manual
+      commands.commit('manual work');
+
+      // Change file
+      fs.writeFileSync(file, 'auto work');
+
+      const log = commands.log(10);
+      const manualEntry = log.find(e => e.message === 'manual work');
+      
+      expect(manualEntry).toBeDefined();
+
+      autoCommitter.stop();
+    });
+
+    it('should allow tagging both auto and manual commits', () => {
+      const file = path.join(memoryDir, 'tag-both.md');
+      fs.writeFileSync(file, 'start');
+
+      autoCommitter.start({ interval: 100 });
+
+      // Tag manual
+      commands.commit('manual checkpoint');
+      tagManager.create('manual-tag');
+
+      // Change and auto-commit
+      fs.writeFileSync(file, 'changed');
+
+      // Tag 
+      tagManager.create('auto-tag');
+
+      const tags = tagManager.list();
+      expect(tags.length).toBeGreaterThanOrEqual(2);
+      expect(tags.map(t => t.name)).toContain('manual-tag');
+      expect(tags.map(t => t.name)).toContain('auto-tag');
+
+      autoCommitter.stop();
+    });
+  });
+
+  describe('Tag-based workflow', () => {
+    it('should support snapshot-based development', () => {
+      const file = path.join(memoryDir, 'snapshot.md');
+      fs.writeFileSync(file, 'v1');
+
+      autoCommitter.start({ interval: 100 });
+
+      // Create snapshots
+      commands.commit('v1');
+      tagManager.create('v1-initial');
+
+      fs.writeFileSync(file, 'v2-experiment');
+      commands.commit('v2');
+      tagManager.create('v2-experiment');
+
+      // List all experiments
+      const tags = tagManager.list();
+      expect(tags.length).toBeGreaterThanOrEqual(2);
+
+      // Verify tags exist
+      expect(tagManager.get('v1-initial')).toBeDefined();
+      expect(tagManager.get('v2-experiment')).toBeDefined();
+
+      autoCommitter.stop();
+    });
+
+    it('should support milestone tracking', () => {
+      const file = path.join(memoryDir, 'milestones.md');
+      fs.writeFileSync(file, 'start');
+
+      autoCommitter.start({ interval: 100 });
+
+      const milestones = [
+        { name: 'm1-learning', description: 'Learned basics' },
+        { name: 'm2-integration', description: 'Integrated systems' },
+        { name: 'm3-optimization', description: 'Optimized performance' },
+      ];
+
+      for (const m of milestones) {
+        fs.writeFileSync(file, m.name);
+        commands.commit(m.name);
+        tagManager.create(m.name, { description: m.description });
+      }
+
+      const tags = tagManager.list();
+      expect(tags.length).toBeGreaterThanOrEqual(milestones.length);
+
+      autoCommitter.stop();
+    });
+  });
+
+  describe('Error handling & recovery', () => {
+    it('should handle permission errors gracefully', () => {
+      const file = path.join(memoryDir, 'readonly.md');
+      fs.writeFileSync(file, 'content');
+
+      autoCommitter.start({ interval: 100 });
+
+      // Make file readonly
+      fs.chmodSync(file, 0o444);
+
+      // Try to modify - auto-commit should handle it
+      try {
+        fs.writeFileSync(file, 'new', { flag: 'w' });
+      } catch (e) {
+        // Expected to fail
+      }
+
+      // Auto-committer should still be running
+      expect(autoCommitter.isRunning_()).toBe(true);
+
+      fs.chmodSync(file, 0o644);
+      autoCommitter.stop();
+    });
+
+    it('should recover from corrupt tag files', () => {
+      tagManager.create('good-tag');
+
+      // Corrupt a tag file
+      const tagsDir = path.join(testDir, 'refs', 'tags');
+      const badFile = path.join(tagsDir, 'bad-tag');
+      fs.writeFileSync(badFile, 'invalid json data');
+
+      // Should still work
+      const newManager = new TagManager(commands, testDir);
+      const tags = newManager.list();
+
+      expect(tags.find(t => t.name === 'good-tag')).toBeDefined();
+    });
+
+    it('should handle cleanup on error', () => {
+      autoCommitter.start({ interval: 100 });
+
+      const file = path.join(memoryDir, 'cleanup.md');
+      fs.writeFileSync(file, 'test');
+
+      autoCommitter.stop();
+
+      // Verify no dangling processes
+      expect(autoCommitter.isRunning_()).toBe(false);
+    });
+  });
+
+  describe('Complex state transitions', () => {
+    it('should handle: create → tag → modify → tag → restore', () => {
+      const file = path.join(memoryDir, 'complex.md');
+      fs.writeFileSync(file, 'v1');
+
+      autoCommitter.start({ interval: 100 });
+
+      commands.commit('v1');
+      tagManager.create('v1-stable');
+
+      fs.writeFileSync(file, 'v2-beta');
+      commands.commit('v2');
+      tagManager.create('v2-beta');
+
+      fs.writeFileSync(file, 'v3-alpha');
+      commands.commit('v3');
+      tagManager.create('v3-alpha');
+
+      // Restore to v2
+      tagManager.checkout('v2-beta');
+
+      const currentCommit = commands.getCurrentCommit();
+      expect(currentCommit?.message).toBe('v2');
+
+      // Forward to v3
+      tagManager.checkout('v3-alpha');
+      const currentCommit2 = commands.getCurrentCommit();
+      expect(currentCommit2?.message).toBe('v3');
+
+      autoCommitter.stop();
+    });
+
+    it('should track changes across sessions', () => {
+      const file = path.join(memoryDir, 'multi-session.md');
+      fs.writeFileSync(file, 'session 1');
+
+      // Session 1
+      autoCommitter.start({ interval: 100 });
+
+      fs.writeFileSync(file, 'session 2');
+      commands.commit('session 2');
+      tagManager.create('end-of-session');
+
+      // Stop watching
+      autoCommitter.stop();
+
+      // Session 2: restart
+      const ac2 = new AutoCommitter(commands, memoryDir);
+      ac2.start({ interval: 100 });
+
+      fs.writeFileSync(file, 'session 3');
+      commands.commit('session 3');
+
+      const log = commands.log(20);
+      expect(log.length).toBeGreaterThanOrEqual(3);
+
+      ac2.stop();
+    });
+
+    it('should support rollback via tags', () => {
+      const work = path.join(memoryDir, 'work.md');
+      fs.writeFileSync(work, '1');
+
+      autoCommitter.start({ interval: 100 });
+
+      commands.commit('checkpoint 1');
+      tagManager.create('checkpoint-good');
+
+      fs.writeFileSync(work, '2');
+      fs.writeFileSync(path.join(memoryDir, 'newfile'), 'bad');
+      commands.commit('checkpoint 2');
+
+      // Rollback
+      tagManager.checkout('checkpoint-good');
+
+      const current = commands.getCurrentCommit();
+      expect(current?.message).toBe('checkpoint 1');
+
+      autoCommitter.stop();
+    });
+  });
+
+  describe('Initialization and setup', () => {
+    it('should initialize auto-committer', () => {
+      autoCommitter.start({ interval: 200 });
+      expect(autoCommitter.isRunning_()).toBe(true);
+      expect(autoCommitter.getInterval()).toBe(200);
+      autoCommitter.stop();
+    });
+
+    it('should initialize tag manager', () => {
+      const tags = tagManager.list();
+      expect(tags).toBeDefined();
+      expect(Array.isArray(tags)).toBe(true);
+    });
+
+    it('should work with both systems together', () => {
+      autoCommitter.start({ interval: 100 });
+
+      const file = path.join(memoryDir, 'work.md');
+      fs.writeFileSync(file, 'initial');
+      commands.commit('initial');
+
+      tagManager.create('start');
+
+      fs.writeFileSync(file, 'modified');
+      commands.commit('modified');
+
+      tagManager.create('modified-tag');
+
+      const tags = tagManager.list();
+      expect(tags.length).toBeGreaterThanOrEqual(2);
+
+      autoCommitter.stop();
+    });
+  });
+
+  describe('Performance under reasonable load', () => {
+    it('should handle tag creation quickly', () => {
+      for (let i = 0; i < 10; i++) {
+        const file = path.join(memoryDir, `file${i}.md`);
+        fs.writeFileSync(file, `content ${i}`);
+        commands.commit(`commit ${i}`);
+        const tag = tagManager.create(`tag-${i}`);
+        expect(tag).toBeDefined();
+      }
+
+      const tags = tagManager.list();
+      expect(tags.length).toBe(10);
+    });
+
+    it('should maintain 100+ commits', () => {
+      const file = path.join(memoryDir, 'many.md');
+      fs.writeFileSync(file, 'start');
+
+      for (let i = 0; i < 20; i++) {
+        fs.writeFileSync(file, `content ${i}`);
+        commands.commit(`commit ${i}`);
+      }
+
+      const log = commands.log(100);
+      expect(log.length).toBeGreaterThanOrEqual(20);
+    });
+  });
+});

package/tests/storage.test.ts

@@ -0,0 +1,167 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Storage } from '../src/storage';
+import { CommitObject, TreeObject } from '../src/types';
+
+describe('Storage', () => {
+  let tmpDir: string;
+  let storage: Storage;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-'));
+    storage = new Storage(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should hash content consistently', () => {
+    const content = 'test content';
+    const hash1 = storage.hash(content);
+    const hash2 = storage.hash(content);
+    expect(hash1).toBe(hash2);
+    expect(hash1.length).toBe(64); // SHA-256 = 64 hex chars
+  });
+
+  it('should save and load commit', () => {
+    const tree: TreeObject = {
+      files: new Map(),
+      hash: 'tree123',
+    };
+
+    const commit: CommitObject = {
+      hash: 'commit123',
+      message: 'test commit',
+      timestamp: 1000,
+      author: 'test',
+      parent: null,
+      tree,
+    };
+
+    storage.saveCommit(commit);
+    const loaded = storage.loadCommit('commit123');
+
+    expect(loaded).not.toBeNull();
+    expect(loaded!.message).toBe('test commit');
+    expect(loaded!.author).toBe('test');
+  });
+
+  it('should return null for non-existent commit', () => {
+    const loaded = storage.loadCommit('nonexistent');
+    expect(loaded).toBeNull();
+  });
+
+  it('should save and load refs', () => {
+    storage.saveRef('main', 'commit123');
+    const ref = storage.loadRef('main');
+    expect(ref).toBe('commit123');
+  });
+
+  it('should list all commits', () => {
+    const tree: TreeObject = { files: new Map(), hash: 'tree1' };
+    const commit1: CommitObject = {
+      hash: 'c1',
+      message: 'msg1',
+      timestamp: 1000,
+      author: 'test',
+      parent: null,
+      tree,
+    };
+    const commit2: CommitObject = {
+      hash: 'c2',
+      message: 'msg2',
+      timestamp: 2000,
+      author: 'test',
+      parent: 'c1',
+      tree,
+    };
+
+    storage.saveCommit(commit1);
+    storage.saveCommit(commit2);
+
+    const commits = storage.listCommits();
+    expect(commits).toContain('c1');
+    expect(commits).toContain('c2');
+    expect(commits.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should delete commit', () => {
+    const tree: TreeObject = { files: new Map(), hash: 'tree1' };
+    const commit: CommitObject = {
+      hash: 'commit-to-delete',
+      message: 'test',
+      timestamp: 1000,
+      author: 'test',
+      parent: null,
+      tree,
+    };
+
+    storage.saveCommit(commit);
+    expect(storage.loadCommit('commit-to-delete')).not.toBeNull();
+
+    storage.deleteCommit('commit-to-delete');
+    expect(storage.loadCommit('commit-to-delete')).toBeNull();
+  });
+
+  it('should get history chain', () => {
+    const tree: TreeObject = { files: new Map(), hash: 'tree1' };
+    const c1: CommitObject = {
+      hash: 'c1',
+      message: 'first',
+      timestamp: 1000,
+      author: 'test',
+      parent: null,
+      tree,
+    };
+    const c2: CommitObject = {
+      hash: 'c2',
+      message: 'second',
+      timestamp: 2000,
+      author: 'test',
+      parent: 'c1',
+      tree,
+    };
+    const c3: CommitObject = {
+      hash: 'c3',
+      message: 'third',
+      timestamp: 3000,
+      author: 'test',
+      parent: 'c2',
+      tree,
+    };
+
+    storage.saveCommit(c1);
+    storage.saveCommit(c2);
+    storage.saveCommit(c3);
+
+    const history = storage.getHistory('c3');
+    expect(history.length).toBe(3);
+    expect(history[0].hash).toBe('c3');
+    expect(history[1].hash).toBe('c2');
+    expect(history[2].hash).toBe('c1');
+  });
+
+  it('should handle empty history', () => {
+    const tree: TreeObject = { files: new Map(), hash: 'tree1' };
+    const commit: CommitObject = {
+      hash: 'root',
+      message: 'root commit',
+      timestamp: 1000,
+      author: 'test',
+      parent: null,
+      tree,
+    };
+
+    storage.saveCommit(commit);
+    const history = storage.getHistory('root');
+    expect(history.length).toBe(1);
+  });
+
+  it('should hash different content differently', () => {
+    const hash1 = storage.hash('content1');
+    const hash2 = storage.hash('content2');
+    expect(hash1).not.toBe(hash2);
+  });
+});