@zoebuildsai/trace 1.5.0

package/tests/checkout.test.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { TraceCommands } from '../src/commands';
+
+describe('Checkout Tests', () => {
+  let tmpDir: string;
+  let commands: TraceCommands;
+  let memoryDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-'));
+    const 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(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+    fs.rmSync(process.env.HOME || '', { recursive: true });
+  });
+
+  it('should restore to previous commit', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    commands.commit('Second');
+
+    commands.checkout(h1);
+    const current = commands.getCurrentCommit();
+    expect(current?.hash).toBe(h1);
+  });
+
+  it('should update HEAD reference', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    const h2 = commands.commit('Second');
+
+    commands.checkout(h1);
+    const current = commands.getCurrentCommit();
+    expect(current?.message).toBe('First');
+  });
+
+  it('should throw on invalid hash', () => {
+    expect(() => commands.checkout('nonexistent')).toThrow();
+  });
+
+  it('should handle checkout to root commit', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('Root');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    commands.commit('Second');
+
+    commands.checkout(h1);
+    const current = commands.getCurrentCommit();
+    expect(current?.parent).toBeNull();
+  });
+
+  it('should restore multiple files', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file1.txt'), 'f1');
+    fs.writeFileSync(path.join(memoryDir, 'file2.txt'), 'f2');
+    const h1 = commands.commit('Multi');
+
+    fs.unlinkSync(path.join(memoryDir, 'file1.txt'));
+    fs.unlinkSync(path.join(memoryDir, 'file2.txt'));
+    commands.commit('Deleted');
+
+    commands.checkout(h1);
+    const current = commands.getCurrentCommit();
+    expect(current?.message).toBe('Multi');
+  });
+
+  it('should complete checkout quickly', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    commands.commit('Second');
+
+    const start = Date.now();
+    commands.checkout(h1);
+    const elapsed = Date.now() - start;
+
+    expect(elapsed).toBeLessThan(150);
+  });
+
+  it('should invalidate cache on checkout', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    const h2 = commands.commit('Second');
+
+    commands.checkout(h1);
+    commands.checkout(h2);
+
+    const current = commands.getCurrentCommit();
+    expect(current?.hash).toBe(h2);
+  });
+
+  it('should handle checkout chain', () => {
+    const hashes = [];
+    for (let i = 0; i < 5; i++) {
+      fs.writeFileSync(path.join(memoryDir, 'file.txt'), `v${i}`);
+      hashes.push(commands.commit(`C${i}`));
+    }
+
+    // Checkout backwards
+    for (let i = hashes.length - 2; i >= 0; i--) {
+      commands.checkout(hashes[i]);
+      const current = commands.getCurrentCommit();
+      expect(current?.hash).toBe(hashes[i]);
+    }
+  });
+
+  it('should restore from nested history', () => {
+    // Create deep history
+    for (let i = 0; i < 10; i++) {
+      fs.writeFileSync(path.join(memoryDir, 'file.txt'), `v${i}`);
+      commands.commit(`C${i}`);
+    }
+
+    const log = commands.log();
+    const targetHash = log[5].hash;
+
+    commands.checkout(targetHash);
+    const current = commands.getCurrentCommit();
+    expect(current?.hash).toBe(targetHash);
+  });
+});

package/tests/commit.test.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { TraceCommands } from '../src/commands';
+
+describe('Commit Tests', () => {
+  let tmpDir: string;
+  let commands: TraceCommands;
+  let memoryDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-'));
+    const 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(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+    fs.rmSync(process.env.HOME || '', { recursive: true });
+  });
+
+  it('should create valid commit hash', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    const hash = commands.commit('Test');
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it('should set correct author', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    const hash = commands.commit('Test', 'custom-author');
+    const log = commands.log(1);
+    expect(log[0].author).toBe('custom-author');
+  });
+
+  it('should default to agent author', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    const hash = commands.commit('Test');
+    const log = commands.log(1);
+    expect(log[0].author).toBe('agent');
+  });
+
+  it('should store message', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    commands.commit('My message');
+    const log = commands.log(1);
+    expect(log[0].message).toBe('My message');
+  });
+
+  it('should track commit timestamp', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    const before = Date.now();
+    commands.commit('Test');
+    const after = Date.now();
+    const log = commands.log(1);
+    expect(log[0].timestamp).toBeGreaterThanOrEqual(before);
+    expect(log[0].timestamp).toBeLessThanOrEqual(after);
+  });
+
+  it('should link parent commit', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    const h2 = commands.commit('Second');
+
+    const log = commands.log();
+    expect(log[0].hash).toBe(h2);
+    expect(log[1].hash).toBe(h1);
+  });
+
+  it('should store metadata', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    commands.commit('Test', 'agent', { version: '1.0', tag: 'release' });
+    const current = commands.getCurrentCommit();
+    expect(current?.metadata).toEqual({ version: '1.0', tag: 'release' });
+  });
+
+  it('should commit empty state', () => {
+    const hash = commands.commit('Empty state');
+    expect(hash).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it('should compute consistent hash', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    // Note: Same content may have different hash due to timestamp
+    const h1 = commands.commit('Test');
+    expect(h1.length).toBe(64);
+  });
+
+  it('should handle unicode in commit message', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    commands.commit('Test: привет мир 🌍');
+    const log = commands.log(1);
+    expect(log[0].message).toBe('Test: привет мир 🌍');
+  });
+
+  it('should reset to new HEAD on commit', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v1');
+    const h1 = commands.commit('First');
+
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'v2');
+    const h2 = commands.commit('Second');
+
+    const current = commands.getCurrentCommit();
+    expect(current?.hash).toBe(h2);
+  });
+
+  it('should handle large messages', () => {
+    fs.writeFileSync(path.join(memoryDir, 'file.txt'), 'content');
+    const largeMsg = 'x'.repeat(1000);
+    commands.commit(largeMsg);
+    const log = commands.log(1);
+    expect(log[0].message.length).toBe(1000);
+  });
+});

package/tests/diff.test.ts

@@ -0,0 +1,191 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Differ } from '../src/diff';
+import { Storage } from '../src/storage';
+import { TreeObject, FileEntry } from '../src/types';
+
+describe('Differ', () => {
+  let tmpDir: string;
+  let storage: Storage;
+  let differ: Differ;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-'));
+    storage = new Storage(tmpDir);
+    differ = new Differ(storage);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should detect added files', () => {
+    const oldTree: TreeObject = {
+      files: new Map(),
+      hash: 'tree1',
+    };
+
+    const newEntry: FileEntry = {
+      path: 'new.txt',
+      hash: 'hash1',
+      size: 100,
+      mode: 'file',
+      lastModified: Date.now(),
+    };
+
+    const newTree: TreeObject = {
+      files: new Map([['new.txt', newEntry]]),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    expect(diff.added.has('new.txt')).toBe(true);
+    expect(diff.modified.size).toBe(0);
+    expect(diff.deleted.size).toBe(0);
+    expect(diff.stats.filesChanged).toBe(1);
+  });
+
+  it('should detect deleted files', () => {
+    const oldEntry: FileEntry = {
+      path: 'deleted.txt',
+      hash: 'hash1',
+      size: 100,
+      mode: 'file',
+      lastModified: 1000,
+    };
+
+    const oldTree: TreeObject = {
+      files: new Map([['deleted.txt', oldEntry]]),
+      hash: 'tree1',
+    };
+
+    const newTree: TreeObject = {
+      files: new Map(),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    expect(diff.deleted.has('deleted.txt')).toBe(true);
+    expect(diff.added.size).toBe(0);
+    expect(diff.modified.size).toBe(0);
+  });
+
+  it('should detect modified files', () => {
+    const oldEntry: FileEntry = {
+      path: 'file.txt',
+      hash: 'hash1',
+      size: 100,
+      mode: 'file',
+      lastModified: 1000,
+    };
+
+    const newEntry: FileEntry = {
+      path: 'file.txt',
+      hash: 'hash2',
+      size: 150,
+      mode: 'file',
+      lastModified: 2000,
+    };
+
+    const oldTree: TreeObject = {
+      files: new Map([['file.txt', oldEntry]]),
+      hash: 'tree1',
+    };
+
+    const newTree: TreeObject = {
+      files: new Map([['file.txt', newEntry]]),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    expect(diff.modified.has('file.txt')).toBe(true);
+    expect(diff.added.size).toBe(0);
+    expect(diff.deleted.size).toBe(0);
+  });
+
+  it('should handle complex diffs', () => {
+    const oldFile: FileEntry = {
+      path: 'keep.txt',
+      hash: 'hash1',
+      size: 100,
+      mode: 'file',
+      lastModified: 1000,
+    };
+
+    const modFile: FileEntry = {
+      path: 'modify.txt',
+      hash: 'hash2',
+      size: 150,
+      mode: 'file',
+      lastModified: 1000,
+    };
+
+    const oldTree: TreeObject = {
+      files: new Map([
+        ['keep.txt', oldFile],
+        ['delete.txt', { path: 'delete.txt', hash: 'hash3', size: 50, mode: 'file', lastModified: 1000 }],
+        ['modify.txt', { path: 'modify.txt', hash: 'hashOld', size: 50, mode: 'file', lastModified: 1000 }],
+      ]),
+      hash: 'tree1',
+    };
+
+    const newTree: TreeObject = {
+      files: new Map([
+        ['keep.txt', oldFile],
+        ['modify.txt', modFile],
+        ['new.txt', { path: 'new.txt', hash: 'hash4', size: 75, mode: 'file', lastModified: 2000 }],
+      ]),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    expect(diff.added.size).toBe(1);
+    expect(diff.modified.size).toBe(1);
+    expect(diff.deleted.size).toBe(1);
+    expect(diff.stats.filesChanged).toBe(3);
+  });
+
+  it('should format diff output', () => {
+    const oldTree: TreeObject = {
+      files: new Map([['old.txt', { path: 'old.txt', hash: 'h1', size: 100, mode: 'file', lastModified: 1000 }]]),
+      hash: 'tree1',
+    };
+
+    const newTree: TreeObject = {
+      files: new Map([['new.txt', { path: 'new.txt', hash: 'h2', size: 100, mode: 'file', lastModified: 2000 }]]),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    const formatted = differ.format(diff);
+    expect(formatted).toContain('deleted');
+    expect(formatted).toContain('new file');
+    expect(formatted).toContain('2 files changed');
+  });
+
+  it('should compute stats', () => {
+    const oldTree: TreeObject = {
+      files: new Map(),
+      hash: 'tree1',
+    };
+
+    const newEntry: FileEntry = {
+      path: 'file.txt',
+      hash: 'h1',
+      size: 100,
+      mode: 'file',
+      lastModified: Date.now(),
+    };
+
+    const newTree: TreeObject = {
+      files: new Map([['file.txt', newEntry]]),
+      hash: 'tree2',
+    };
+
+    const diff = differ.diff(oldTree, newTree);
+    const stats = differ.getStats(diff);
+    expect(stats.filesChanged).toBe(1);
+    expect(stats.totalChanges).toBe(1);
+  });
+});

package/tests/github.test.ts

@@ -0,0 +1,94 @@
+/**
+ * GitHub Integration Tests
+ */
+
+import { TraceSync } from '../src/github';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+describe('TraceSync', () => {
+  let testDir: string;
+  let github: TraceSync;
+
+  beforeEach(() => {
+    testDir = mkdtempSync(join('/tmp', 'trace-test-'));
+    github = new TraceSync(testDir);
+    github.initRepo();
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true });
+  });
+
+  test('should initialize a git repository', () => {
+    expect(() => {
+      execSync('git rev-parse --git-dir', { cwd: testDir, stdio: 'ignore' });
+    }).not.toThrow();
+  });
+
+  test('should add a remote', () => {
+    github.addRemote('origin', 'https://github.com/test/repo.git');
+    const remotes = github.listRemotes();
+    expect(remotes.length).toBeGreaterThan(0);
+    expect(remotes.some(r => r.name === 'origin')).toBe(true);
+  });
+
+  test('should list remotes', () => {
+    github.addRemote('origin', 'https://github.com/test/repo.git');
+    github.addRemote('backup', 'https://github.com/test/backup.git');
+    
+    const remotes = github.listRemotes();
+    expect(remotes.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('should stage and commit changes', () => {
+    // Create a test file
+    execSync(`echo "test" > ${join(testDir, 'test.txt')}`);
+    
+    const result = github.stageAndCommit('test commit');
+    expect(result.success).toBe(true);
+    expect(result.hash.length).toBeGreaterThan(0);
+  });
+
+  test('should handle nothing to commit gracefully', () => {
+    // Make an initial commit first
+    execSync(`echo "test" > ${join(testDir, 'test.txt')}`);
+    const init = github.stageAndCommit('initial');
+    expect(init.success).toBe(true);
+    
+    // Now try to commit with no changes
+    const result = github.stageAndCommit('empty commit');
+    // Git returns non-zero exit code for "nothing to commit"
+    // So success should be false, or we can accept either behavior
+    // Let's just test that it doesn't crash
+    expect(result).toHaveProperty('success');
+    expect(result).toHaveProperty('hash');
+  });
+
+  test('should commit with auto-push flag', () => {
+    execSync(`echo "test" > ${join(testDir, 'test.txt')}`);
+    
+    const result = github.commitWithAutoPush('test message', false);
+    expect(result.success).toBe(true);
+    expect(result.hash).toBeDefined();
+  });
+
+  test('should handle push timeout gracefully', () => {
+    github.addRemote('origin', 'https://github.com/nonexistent/repo.git');
+    execSync(`echo "test" > ${join(testDir, 'test.txt')}`);
+    github.stageAndCommit('test');
+
+    // This will timeout or fail, which is OK - we just check error handling
+    const result = github.push('origin', 1000);
+    // Should either fail or timeout - both are acceptable
+    expect(result).toHaveProperty('success');
+    expect(result).toHaveProperty('message');
+  });
+
+  test('should handle missing remote gracefully', () => {
+    const result = github.pull('nonexistent');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('failed');
+  });
+});