@zoebuildsai/trace 1.5.0

package/tests/tags.test.ts

@@ -0,0 +1,477 @@
+/**
+ * Tags Feature Tests
+ * 
+ * Comprehensive test suite for tagging functionality:
+ * - Create, list, delete tags
+ * - Checkout to tagged commits
+ * - Tag metadata (created_at, description, creator)
+ * - Tag conflicts and edge cases
+ * - Performance requirements (<50ms)
+ */
+
+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('Tags Feature', () => {
+  let testDir: string;
+  let homeDir: string;
+  let memoryDir: string;
+  let commands: TraceCommands;
+  let tagManager: TagManager;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'memory-git-'));
+    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);
+    
+    // New tags manager with fresh directory
+    tagManager = new TagManager(commands, testDir);
+
+    // Create initial commit
+    fs.writeFileSync(path.join(memoryDir, 'initial.md'), 'initial');
+    commands.commit('initial');
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+    if (fs.existsSync(homeDir)) {
+      fs.rmSync(homeDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Tag creation', () => {
+    it('should create a simple tag', () => {
+      const hash = commands.status().clean ? '1234567890abcdef' : undefined;
+      const tag = tagManager.create('v1.0', { description: 'Version 1.0' });
+
+      expect(tag).toBeDefined();
+      expect(tag.name).toBe('v1.0');
+      expect(tag.created_at).toBeDefined();
+    });
+
+    it('should create tag with metadata', () => {
+      const tag = tagManager.create('checkpoint-1', {
+        description: 'Training checkpoint',
+        creator: 'agent',
+      });
+
+      expect(tag.metadata?.description).toBe('Training checkpoint');
+      expect(tag.metadata?.creator).toBe('agent');
+    });
+
+    it('should record created_at timestamp', () => {
+      const beforeCreate = Date.now();
+      const tag = tagManager.create('test-tag');
+      const afterCreate = Date.now();
+
+      expect(tag.created_at).toBeGreaterThanOrEqual(beforeCreate);
+      expect(tag.created_at).toBeLessThanOrEqual(afterCreate);
+    });
+
+    it('should handle unicode tag names', () => {
+      const tag = tagManager.create('标签-v1.0', {
+        description: 'Unicode tag',
+      });
+
+      expect(tag.name).toBe('标签-v1.0');
+      expect(tagManager.get('标签-v1.0')).toBeDefined();
+    });
+
+    it('should handle special characters in tag names', () => {
+      const validNames = ['release/1.0', 'alpha-2', 'test_1'];
+      validNames.forEach(name => {
+        const tag = tagManager.create(name);
+        expect(tag.name).toBe(name);
+      });
+    });
+
+    it('should reject invalid tag names', () => {
+      expect(() => {
+        tagManager.create(''); // empty
+      }).toThrow();
+
+      expect(() => {
+        tagManager.create('tag with spaces');
+      }).toThrow();
+    });
+  });
+
+  describe('Tag conflicts', () => {
+    it('should prevent duplicate tag names', () => {
+      tagManager.create('v1.0');
+
+      expect(() => {
+        tagManager.create('v1.0');
+      }).toThrow();
+    });
+
+    it('should allow updating existing tag with force flag', () => {
+      tagManager.create('v1.0');
+
+      // Create new commit
+      fs.writeFileSync(path.join(memoryDir, 'file2.md'), 'content');
+      commands.commit('second');
+
+      const updated = tagManager.create('v1.0', { force: true });
+      expect(updated).toBeDefined();
+    });
+
+    it('should handle tag deletion and recreation', () => {
+      tagManager.create('v1.0');
+      tagManager.delete('v1.0');
+
+      const recreated = tagManager.create('v1.0');
+      expect(recreated).toBeDefined();
+    });
+  });
+
+  describe('Tag listing', () => {
+    it('should list all tags', () => {
+      tagManager.create('v1.0');
+      tagManager.create('v1.1');
+      tagManager.create('v2.0');
+
+      const tags = tagManager.list();
+      expect(tags.length).toBe(3);
+      expect(tags.map(t => t.name)).toContain('v1.0');
+    });
+
+    it('should list tags with full metadata', () => {
+      tagManager.create('test', { description: 'Test tag' });
+
+      const tags = tagManager.list();
+      const testTag = tags.find(t => t.name === 'test');
+
+      expect(testTag?.metadata?.description).toBe('Test tag');
+      expect(testTag?.created_at).toBeDefined();
+    });
+
+    it('should return empty list when no tags', () => {
+      const tags = tagManager.list();
+      expect(tags).toEqual([]);
+    });
+
+    it('should list tags sorted by creation time', (done) => {
+      tagManager.create('first');
+      
+      // Small delay to ensure different timestamp
+      setTimeout(() => {
+        tagManager.create('second');
+        
+        const tags = tagManager.list({ sortBy: 'created_at' });
+        expect(tags[0].name).toBe('first');
+        expect(tags[1].name).toBe('second');
+        done();
+      }, 20);
+    });
+
+    it('should filter tags by pattern', () => {
+      tagManager.create('v1.0');
+      tagManager.create('v1.1');
+      tagManager.create('release-2.0');
+
+      const vTags = tagManager.list({ pattern: 'v*' });
+      expect(vTags.length).toBe(2);
+      expect(vTags.every(t => t.name.startsWith('v'))).toBe(true);
+    });
+  });
+
+  describe('Tag deletion', () => {
+    it('should delete a tag', () => {
+      tagManager.create('v1.0');
+      tagManager.delete('v1.0');
+
+      expect(tagManager.get('v1.0')).toBeUndefined();
+    });
+
+    it('should throw on deleting non-existent tag', () => {
+      expect(() => {
+        tagManager.delete('nonexistent');
+      }).toThrow();
+    });
+
+    it('should allow deleting tag while on tagged commit', () => {
+      tagManager.create('v1.0');
+      const tags = tagManager.list();
+      expect(tags.length).toBe(1);
+
+      tagManager.delete('v1.0');
+      expect(tagManager.list().length).toBe(0);
+    });
+
+    it('should handle rapid tag creation/deletion', () => {
+      for (let i = 0; i < 100; i++) {
+        const name = `tag-${i}`;
+        tagManager.create(name);
+      }
+
+      for (let i = 0; i < 100; i++) {
+        tagManager.delete(`tag-${i}`);
+      }
+
+      expect(tagManager.list().length).toBe(0);
+    });
+  });
+
+  describe('Checkout to tag', () => {
+    it('should checkout to tagged commit', () => {
+      // Create first state
+      fs.writeFileSync(path.join(memoryDir, 'v1.md'), 'v1 content');
+      const hash1 = commands.commit('version 1');
+
+      tagManager.create('v1.0');
+
+      // Create second state
+      fs.writeFileSync(path.join(memoryDir, 'v2.md'), 'v2 content');
+      commands.commit('version 2');
+
+      // Create third state
+      fs.writeFileSync(path.join(memoryDir, 'v3.md'), 'v3 content');
+      commands.commit('version 3');
+
+      // Checkout to v1.0
+      const restored = tagManager.checkout('v1.0');
+      expect(restored).toBe(true);
+
+      // Verify we're pointing at the right commit
+      const currentCommit = commands.getCurrentCommit();
+      expect(currentCommit?.hash).toBe(hash1);
+      
+      const log = commands.log(1);
+      expect(log[0].message).toBe('version 1');
+    });
+
+    it('should restore to tagged commit state', () => {
+      const file1 = path.join(memoryDir, 'doc.md');
+      fs.writeFileSync(file1, 'documentation');
+      const hash1 = commands.commit('added docs');
+      tagManager.create('with-docs');
+
+      // Remove the file
+      fs.unlinkSync(file1);
+      commands.commit('removed docs');
+
+      // Restore
+      tagManager.checkout('with-docs');
+      
+      // Verify we're at the right commit
+      const currentCommit = commands.getCurrentCommit();
+      expect(currentCommit?.hash).toBe(hash1);
+      
+      const log = commands.log(1);
+      expect(log[0].message).toBe('added docs');
+    });
+
+    it('should throw on checkout to non-existent tag', () => {
+      expect(() => {
+        tagManager.checkout('nonexistent');
+      }).toThrow();
+    });
+
+    it('should handle checkout with uncommitted changes', () => {
+      tagManager.create('v1');
+
+      // Make uncommitted change
+      fs.writeFileSync(path.join(memoryDir, 'uncommitted.md'), 'new');
+
+      // Should handle gracefully
+      expect(() => {
+        tagManager.checkout('v1', { force: true });
+      }).not.toThrow();
+    });
+  });
+
+  describe('Tag storage & persistence', () => {
+    it('should persist tags to disk', () => {
+      tagManager.create('persistent-tag', { description: 'Should persist' });
+
+      // Create new manager instance
+      const newManager = new TagManager(commands, testDir);
+      const tags = newManager.list();
+
+      expect(tags.find(t => t.name === 'persistent-tag')).toBeDefined();
+    });
+
+    it('should store tags in refs/tags/ directory', () => {
+      tagManager.create('test-tag');
+
+      const tagsDir = path.join(testDir, 'refs', 'tags');
+      expect(fs.existsSync(tagsDir)).toBe(true);
+      
+      // The tag name is stored as-is (no special chars in 'test-tag')
+      const files = fs.readdirSync(tagsDir);
+      expect(files.length).toBeGreaterThan(0);
+      expect(files[0]).toBe('test-tag');
+    });
+
+    it('should handle tag file corruption gracefully', () => {
+      tagManager.create('good-tag');
+
+      // Corrupt a tag file
+      const tagsDir = path.join(testDir, 'refs', 'tags');
+      fs.mkdirSync(tagsDir, { recursive: true });
+      const badFile = path.join(tagsDir, 'bad-tag');
+      fs.writeFileSync(badFile, 'invalid json');
+
+      // Should not crash
+      const newManager = new TagManager(commands, testDir);
+      const tags = newManager.list();
+
+      expect(tags.find(t => t.name === 'good-tag')).toBeDefined();
+    });
+  });
+
+  describe('Tag indexing & lookup', () => {
+    it('should build fast tag index', () => {
+      for (let i = 0; i < 1000; i++) {
+        tagManager.create(`tag-${i}`);
+      }
+
+      const startTime = Date.now();
+      const tag = tagManager.get('tag-500');
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(50);
+      expect(tag?.name).toBe('tag-500');
+    });
+
+    it('should handle 1000+ tags efficiently', () => {
+      for (let i = 0; i < 1000; i++) {
+        tagManager.create(`tag-${i}`);
+      }
+
+      const tags = tagManager.list();
+      expect(tags.length).toBe(1000);
+    });
+
+    it('should rebuild index on demand', () => {
+      tagManager.create('v1');
+      tagManager.create('v2');
+
+      tagManager.rebuildIndex();
+
+      const tags = tagManager.list();
+      expect(tags.length).toBe(2);
+    });
+  });
+
+  describe('Performance requirements', () => {
+    it('should create tag in <50ms', () => {
+      const startTime = Date.now();
+      tagManager.create('perf-test');
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(50);
+    });
+
+    it('should list tags in <50ms even with 100 tags', () => {
+      for (let i = 0; i < 100; i++) {
+        tagManager.create(`tag-${i}`);
+      }
+
+      const startTime = Date.now();
+      tagManager.list();
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(50);
+    });
+
+    it('should lookup tag in <20ms', () => {
+      for (let i = 0; i < 100; i++) {
+        tagManager.create(`tag-${i}`);
+      }
+
+      const startTime = Date.now();
+      tagManager.get('tag-50');
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(20);
+    });
+
+    it('should delete tag in <50ms', () => {
+      tagManager.create('delete-test');
+
+      const startTime = Date.now();
+      tagManager.delete('delete-test');
+      const duration = Date.now() - startTime;
+
+      expect(duration).toBeLessThan(50);
+    });
+  });
+
+  describe('Edge cases & robustness', () => {
+    it('should handle very long tag names (255+ chars)', () => {
+      const longName = 'tag-' + 'x'.repeat(250);
+      const tag = tagManager.create(longName);
+      expect(tag.name).toBe(longName);
+    });
+
+    it('should handle empty metadata', () => {
+      const tag = tagManager.create('empty');
+      expect(tag.metadata).toBeUndefined();
+    });
+
+    it('should handle large metadata objects', () => {
+      const largeMetadata = {
+        description: 'x'.repeat(10000),
+        data: Array(1000).fill('item'),
+      };
+      const tag = tagManager.create('large', largeMetadata);
+      expect(tag.metadata?.description.length).toBeGreaterThan(1000);
+    });
+
+    it('should recover from partial write', () => {
+      tagManager.create('good-tag');
+      tagManager.create('also-good');
+
+      // Simulate partial write by corrupting a tag file
+      const tagsDir = path.join(testDir, 'refs', 'tags');
+      const files = fs.readdirSync(tagsDir);
+      if (files.length > 0) {
+        fs.writeFileSync(path.join(tagsDir, files[0]), '{"incomplete');
+      }
+
+      // New manager should load good tags and skip corrupt ones
+      const newManager = new TagManager(commands, testDir);
+      const tags = newManager.list();
+      
+      // Should have at least recovered the uncorrupted tag
+      expect(tags.length).toBeGreaterThanOrEqual(1);
+      expect(tags.some(t => t.name === 'also-good' || t.name === 'good-tag')).toBe(true);
+    });
+  });
+
+  describe('Tag metadata tracking', () => {
+    it('should track commit hash with tag', () => {
+      const tag = tagManager.create('v1.0');
+      expect(tag.commit_hash).toBeDefined();
+      expect(tag.commit_hash.length).toBeGreaterThan(0);
+    });
+
+    it('should track creator in metadata', () => {
+      const tag = tagManager.create('creator-test', { creator: 'agent' });
+      expect(tag.metadata?.creator).toBe('agent');
+    });
+
+    it('should allow custom metadata fields', () => {
+      const tag = tagManager.create('custom', {
+        milestone: 'M1',
+        tested: true,
+        version: '1.0.0',
+      });
+
+      expect(tag.metadata?.milestone).toBe('M1');
+      expect(tag.metadata?.tested).toBe(true);
+      expect(tag.metadata?.version).toBe('1.0.0');
+    });
+  });
+});

package/tests/types.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Type tests to ensure compile-time correctness
+ */
+
+import {
+  CommitObject,
+  TreeObject,
+  FileEntry,
+  DiffResult,
+  StatusResult,
+  CommitOptions,
+} from '../src/types';
+
+describe('Types', () => {
+  it('should create valid CommitObject', () => {
+    const tree: TreeObject = {
+      files: new Map(),
+      hash: 'abc123',
+    };
+
+    const commit: CommitObject = {
+      hash: 'abc123',
+      message: 'test commit',
+      timestamp: Date.now(),
+      author: 'test',
+      parent: null,
+      tree,
+    };
+
+    expect(commit.hash).toBeDefined();
+    expect(commit.message).toBeDefined();
+    expect(commit.timestamp).toBeGreaterThan(0);
+  });
+
+  it('should create valid FileEntry', () => {
+    const entry: FileEntry = {
+      path: 'test.txt',
+      hash: 'xyz789',
+      size: 100,
+      mode: 'file',
+      lastModified: Date.now(),
+    };
+
+    expect(entry.path).toBe('test.txt');
+    expect(entry.mode).toBe('file');
+  });
+
+  it('should create valid DiffResult', () => {
+    const diff: DiffResult = {
+      added: new Map(),
+      modified: new Map(),
+      deleted: new Map(),
+      stats: {
+        filesChanged: 0,
+        linesAdded: 0,
+        linesRemoved: 0,
+        totalChanges: 0,
+      },
+    };
+
+    expect(diff.added).toBeInstanceOf(Map);
+    expect(diff.stats.filesChanged).toBe(0);
+  });
+
+  it('should create valid CommitOptions', () => {
+    const opts: CommitOptions = {
+      message: 'test',
+      author: 'test-author',
+      metadata: { version: '1.0' },
+    };
+
+    expect(opts.message).toBeDefined();
+    expect(opts.metadata).toHaveProperty('version');
+  });
+});