@zoebuildsai/trace 1.5.0

package/tests/v1.3/message-search.test.ts

@@ -0,0 +1,264 @@
+/**
+ * Message Search Tests
+ * Full-text search across commit history
+ */
+
+import { MessageSearch } from '../../src/message-search';
+
+describe('MessageSearch', () => {
+  let search: MessageSearch;
+
+  beforeEach(() => {
+    search = new MessageSearch();
+  });
+
+  describe('Indexing', () => {
+    test('indexes commit', () => {
+      search.indexCommit(
+        'abc123',
+        'feat: add login button',
+        'agent-a',
+        Date.now(),
+        ['src/auth.ts'],
+        'feature'
+      );
+
+      const stats = search.getStats();
+      expect(stats.totalIndexedCommits).toBe(1);
+    });
+
+    test('indexes multiple commits', () => {
+      for (let i = 0; i < 100; i++) {
+        search.indexCommit(
+          `hash${i}`,
+          `commit message ${i}`,
+          `agent-${i % 5}`,
+          Date.now(),
+          [`file${i}.ts`],
+          'chore'
+        );
+      }
+
+      const stats = search.getStats();
+      expect(stats.totalIndexedCommits).toBe(100);
+    });
+
+    test('builds indices', () => {
+      search.indexCommit('h1', 'fix: bug', 'agent-a', Date.now(), ['file.ts'], 'fix');
+      search.indexCommit('h2', 'feat: feature', 'agent-b', Date.now(), ['file.ts'], 'feature');
+      search.indexCommit('h3', 'docs: update', 'agent-a', Date.now(), ['readme.md'], 'docs');
+
+      const stats = search.getStats();
+      expect(stats.uniqueAuthors).toBe(2);
+      expect(stats.uniqueFiles).toBe(2);
+      expect(stats.uniqueWords).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Text Search', () => {
+    test('searches by text', () => {
+      search.indexCommit('h1', 'add authentication system', 'agent-a', Date.now());
+      search.indexCommit('h2', 'update login form', 'agent-b', Date.now());
+      search.indexCommit('h3', 'fix auth bug', 'agent-c', Date.now());
+
+      const results = search.search({ text: 'auth' });
+      expect(results.length).toBeGreaterThan(0);
+      expect(results.every(r => r.message.includes('auth'))).toBe(true);
+    });
+
+    test('searches by multiple words', () => {
+      search.indexCommit('h1', 'add user authentication system', 'agent-a', Date.now());
+      search.indexCommit('h2', 'add payment processing', 'agent-b', Date.now());
+      search.indexCommit('h3', 'fix authentication bug', 'agent-c', Date.now());
+
+      const results = search.search({ text: 'authentication system' });
+      expect(results.length).toBeGreaterThan(0);
+    });
+
+    test('ignores stopwords', () => {
+      search.indexCommit('h1', 'the quick brown fox', 'agent-a', Date.now());
+      search.indexCommit('h2', 'implement feature', 'agent-b', Date.now());
+
+      const results = search.search({ text: 'the' });
+      expect(results.length).toBe(0); // 'the' is stopword
+    });
+
+    test('filters by limit', () => {
+      for (let i = 0; i < 50; i++) {
+        search.indexCommit(`h${i}`, 'feature implementation', 'agent-a', Date.now());
+      }
+
+      const results = search.search({ text: 'feature', limit: 10 });
+      expect(results).toHaveLength(10);
+    });
+  });
+
+  describe('Author Search', () => {
+    test('searches by author', () => {
+      search.indexCommit('h1', 'commit 1', 'agent-a', Date.now());
+      search.indexCommit('h2', 'commit 2', 'agent-a', Date.now());
+      search.indexCommit('h3', 'commit 3', 'agent-b', Date.now());
+
+      const results = search.getByAuthor('agent-a');
+      expect(results).toHaveLength(2);
+      expect(results.every(r => r.author === 'agent-a')).toBe(true);
+    });
+
+    test('returns empty for unknown author', () => {
+      search.indexCommit('h1', 'commit', 'agent-a', Date.now());
+
+      const results = search.getByAuthor('unknown');
+      expect(results).toHaveLength(0);
+    });
+
+    test('filters search by author', () => {
+      search.indexCommit('h1', 'feature: login', 'agent-a', Date.now());
+      search.indexCommit('h2', 'feature: logout', 'agent-b', Date.now());
+
+      const results = search.search({ text: 'feature', author: 'agent-a' });
+      expect(results.every(r => r.author === 'agent-a')).toBe(true);
+    });
+  });
+
+  describe('Type Search', () => {
+    test('searches by type', () => {
+      search.indexCommit('h1', 'msg1', 'agent-a', Date.now(), [], 'feature');
+      search.indexCommit('h2', 'msg2', 'agent-a', Date.now(), [], 'fix');
+      search.indexCommit('h3', 'msg3', 'agent-a', Date.now(), [], 'feature');
+
+      const results = search.getByType('feature');
+      expect(results).toHaveLength(2);
+    });
+
+    test('filters search by type', () => {
+      search.indexCommit('h1', 'add auth', 'agent-a', Date.now(), [], 'feature');
+      search.indexCommit('h2', 'fix auth bug', 'agent-b', Date.now(), [], 'fix');
+      search.indexCommit('h3', 'refactor auth', 'agent-c', Date.now(), [], 'refactor');
+
+      const results = search.search({ text: 'auth', type: 'feature' });
+      expect(results.every(r => r.message.includes('add auth'))).toBe(true);
+    });
+  });
+
+  describe('File Search', () => {
+    test('searches by file', () => {
+      search.indexCommit('h1', 'msg1', 'agent-a', Date.now(), ['src/auth.ts']);
+      search.indexCommit('h2', 'msg2', 'agent-b', Date.now(), ['src/auth.ts', 'src/api.ts']);
+      search.indexCommit('h3', 'msg3', 'agent-c', Date.now(), ['src/ui.ts']);
+
+      const results = search.getByFile('src/auth.ts');
+      expect(results).toHaveLength(2);
+    });
+
+    test('filters search by files', () => {
+      search.indexCommit('h1', 'auth work', 'agent-a', Date.now(), ['src/auth.ts']);
+      search.indexCommit('h2', 'api work', 'agent-b', Date.now(), ['src/api.ts']);
+
+      const results = search.search({ files: ['src/auth.ts'] });
+      expect(results.every(r => r.message.includes('auth'))).toBe(true);
+    });
+  });
+
+  describe('Date Range Search', () => {
+    test('filters by date range', () => {
+      const now = Date.now();
+      const yesterday = now - 24 * 60 * 60 * 1000;
+
+      search.indexCommit('h1', 'old', 'agent-a', yesterday);
+      search.indexCommit('h2', 'new', 'agent-b', now);
+
+      const results = search.search({ dateAfter: yesterday + 1000 });
+      expect(results.some(r => r.message === 'new')).toBe(true);
+      expect(results.some(r => r.message === 'old')).toBe(false);
+    });
+  });
+
+  describe('Pattern Search', () => {
+    test('searches by regex pattern', () => {
+      search.indexCommit('h1', 'feat: add login', 'agent-a', Date.now());
+      search.indexCommit('h2', 'fix: bug', 'agent-b', Date.now());
+      search.indexCommit('h3', 'feat: add logout', 'agent-c', Date.now());
+
+      const results = search.searchByPattern(/feat:/);
+      expect(results).toHaveLength(2);
+    });
+  });
+
+  describe('Relevance Scoring', () => {
+    test('scores by text matches', () => {
+      search.indexCommit('h1', 'add auth system', 'agent-a', Date.now());
+      search.indexCommit('h2', 'fix auth', 'agent-b', Date.now());
+      search.indexCommit('h3', 'auth', 'agent-c', Date.now());
+
+      const results = search.search({ text: 'auth system' });
+      expect(results[0].relevanceScore).toBeGreaterThan(results[1].relevanceScore);
+    });
+
+    test('boosts by type match', () => {
+      search.indexCommit('h1', 'add feature', 'agent-a', Date.now(), [], 'feature');
+      search.indexCommit('h2', 'add feature', 'agent-b', Date.now(), [], 'chore');
+
+      const results = search.search({ text: 'add feature', type: 'feature' });
+      expect(results[0].commitHash).toBe('h1');
+    });
+
+    test('boosts recent commits', () => {
+      const now = Date.now();
+      search.indexCommit('h1', 'auth', 'agent-a', now - 30 * 24 * 60 * 60 * 1000); // 30 days old
+      search.indexCommit('h2', 'auth', 'agent-b', now); // today
+
+      const results = search.search({ text: 'auth' });
+      expect(results[0].commitHash).toBe('h2'); // Recent one ranked higher
+    });
+  });
+
+  describe('Combined Queries', () => {
+    test('searches with multiple filters', () => {
+      search.indexCommit('h1', 'add auth system', 'agent-a', Date.now(), ['src/auth.ts'], 'feature');
+      search.indexCommit('h2', 'fix auth bug', 'agent-a', Date.now(), ['src/auth.ts'], 'fix');
+      search.indexCommit('h3', 'add ui', 'agent-b', Date.now(), ['src/ui.ts'], 'feature');
+
+      const results = search.search({
+        text: 'auth',
+        author: 'agent-a',
+        type: 'feature',
+        files: ['src/auth.ts'],
+      });
+
+      expect(results).toHaveLength(1);
+      expect(results[0].commitHash).toBe('h1');
+    });
+  });
+
+  describe('Real-world Scenarios', () => {
+    test('finds all commits by feature', () => {
+      for (let i = 0; i < 100; i++) {
+        const type = i % 3 === 0 ? 'feature' : i % 3 === 1 ? 'fix' : 'chore';
+        search.indexCommit(`h${i}`, `commit ${i}`, `agent-${i % 5}`, Date.now(), [], type);
+      }
+
+      const features = search.getByType('feature');
+      expect(features.length).toBeGreaterThan(20);
+      expect(features.every(r => r.matchedFields.includes('type'))).toBe(true);
+    });
+
+    test('searches production code changes', () => {
+      search.indexCommit('h1', 'add database migration', 'agent-a', Date.now(), ['migrations/001_users.sql'], 'feature');
+      search.indexCommit('h2', 'fix race condition', 'agent-b', Date.now(), ['src/concurrent.ts'], 'fix');
+      search.indexCommit('h3', 'update docs', 'agent-c', Date.now(), ['docs/api.md'], 'docs');
+
+      const prodChanges = search.search({ files: ['src/concurrent.ts', 'migrations/001_users.sql'] });
+      expect(prodChanges.length).toBe(2);
+    });
+  });
+
+  describe('Index Management', () => {
+    test('clears index', () => {
+      search.indexCommit('h1', 'msg', 'agent-a', Date.now());
+      expect(search.getStats().totalIndexedCommits).toBe(1);
+
+      search.clearIndex();
+      expect(search.getStats().totalIndexedCommits).toBe(0);
+    });
+  });
+});

package/tests/v1.3/stage-area.test.ts

@@ -0,0 +1,330 @@
+/**
+ * Stage Area Tests
+ * Smart partial commits (agent-native git add)
+ */
+
+import { StageArea } from '../../src/stage-area';
+
+describe('StageArea', () => {
+  let stage: StageArea;
+
+  beforeEach(() => {
+    stage = new StageArea();
+  });
+
+  describe('Staging Changes', () => {
+    test('stages a single change', () => {
+      const change = stage.stageChange('src/file.ts', 'modify', 'old', 'new');
+      expect(change.path).toBe('src/file.ts');
+      expect(change.type).toBe('modify');
+      expect(stage.isStaged('src/file.ts')).toBe(true);
+    });
+
+    test('stages added file', () => {
+      const change = stage.stageChange('src/new.ts', 'add', undefined, 'content');
+      expect(change.type).toBe('add');
+      expect(change.newContent).toBe('content');
+    });
+
+    test('stages deleted file', () => {
+      const change = stage.stageChange('src/removed.ts', 'delete', 'content');
+      expect(change.type).toBe('delete');
+      expect(change.oldContent).toBe('content');
+    });
+
+    test('stages multiple changes', () => {
+      const changes = [
+        { path: 'a.ts', type: 'add' as const, newContent: 'a' },
+        { path: 'b.ts', type: 'modify' as const, oldContent: 'b1', newContent: 'b2' },
+        { path: 'c.ts', type: 'delete' as const, oldContent: 'c' },
+      ];
+
+      stage.stageMultiple(changes.map(c => ({
+        ...c,
+        timestamp: Date.now(),
+      })));
+
+      expect(stage.getStagedChanges()).toHaveLength(3);
+    });
+
+    test('overwrites previous stage', () => {
+      stage.stageChange('file.ts', 'modify', 'v1', 'v2');
+      stage.stageChange('file.ts', 'modify', 'v2', 'v3');
+
+      const staged = stage.getStagedChanges();
+      expect(staged).toHaveLength(1);
+      expect(staged[0].newContent).toBe('v3');
+    });
+  });
+
+  describe('Unstaging', () => {
+    test('unstages file', () => {
+      stage.stageChange('file.ts', 'modify', 'old', 'new');
+      expect(stage.isStaged('file.ts')).toBe(true);
+
+      stage.unstageFile('file.ts');
+      expect(stage.isStaged('file.ts')).toBe(false);
+    });
+
+    test('unstages all', () => {
+      stage.stageChange('a.ts', 'add', undefined, 'a');
+      stage.stageChange('b.ts', 'add', undefined, 'b');
+      stage.stageChange('c.ts', 'add', undefined, 'c');
+
+      stage.unstageAll();
+      expect(stage.getStagedChanges()).toHaveLength(0);
+    });
+
+    test('returns false for unknown file', () => {
+      const result = stage.unstageFile('unknown.ts');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('Status Tracking', () => {
+    test('reports staging status', () => {
+      stage.updateWorkingDirectory(new Map([
+        ['staged.ts', 'content'],
+        ['modified.ts', 'new content'],
+        ['new.ts', 'new file'],
+      ]));
+
+      stage.recordCommit(new Map([
+        ['old.ts', 'old'],
+        ['modified.ts', 'old content'],
+      ]));
+
+      stage.stageChange('staged.ts', 'modify', 'old', 'new');
+
+      const status = stage.getStatus();
+      expect(status.staged).toBe(1);
+      expect(status.unstaged).toBe(1); // modified.ts
+      expect(status.untracked).toBe(1); // new.ts
+    });
+  });
+
+  describe('Auto-Staging', () => {
+    test('stages all changes', () => {
+      const workingDir = new Map([
+        ['a.ts', 'added'],
+        ['b.ts', 'modified'],
+      ]);
+
+      stage.recordCommit(new Map([['b.ts', 'old content']]));
+
+      const changes = stage.stageAll(workingDir);
+      expect(changes).toHaveLength(2);
+      expect(changes.some(c => c.type === 'add')).toBe(true);
+      expect(changes.some(c => c.type === 'modify')).toBe(true);
+    });
+
+    test('detects deleted files', () => {
+      const workingDir = new Map();
+      stage.recordCommit(new Map([['deleted.ts', 'content']]));
+
+      const changes = stage.stageAll(workingDir);
+      expect(changes).toHaveLength(1);
+      expect(changes[0].type).toBe('delete');
+    });
+  });
+
+  describe('Commit Creation', () => {
+    test('creates commit from staged', () => {
+      stage.stageChange('file.ts', 'modify', 'old', 'new');
+
+      const commit = stage.createCommit('fix: bug', 'fix');
+      expect(commit.message).toBe('fix: bug');
+      expect(commit.type).toBe('fix');
+      expect(commit.stagedChanges).toHaveLength(1);
+    });
+
+    test('throws without staged changes', () => {
+      expect(() => {
+        stage.createCommit('empty commit');
+      }).toThrow('No staged changes');
+    });
+
+    test('sets commit timestamp', () => {
+      stage.stageChange('file.ts', 'add', undefined, 'content');
+      const commit = stage.createCommit('feat: new');
+
+      expect(commit.timestamp).toBeGreaterThan(0);
+      expect(commit.timestamp).toBeLessThanOrEqual(Date.now());
+    });
+  });
+
+  describe('Stage by Type', () => {
+    test('stages by semantic type (feature)', () => {
+      stage.stageChange('src/feature.ts', 'add', undefined, 'code');
+      stage.stageChange('src/utils.ts', 'modify', 'old', 'new');
+      stage.stageChange('README.md', 'modify', 'old', 'new');
+
+      const featured = stage.stageByType('feature');
+      expect(featured.some(c => c.path.includes('src/'))).toBe(true);
+      expect(featured.some(c => c.path === 'README.md')).toBe(false);
+    });
+
+    test('stages by semantic type (docs)', () => {
+      stage.stageChange('README.md', 'modify', 'old', 'new');
+      stage.stageChange('docs/api.md', 'add', undefined, 'docs');
+      stage.stageChange('src/code.ts', 'add', undefined, 'code');
+
+      const docs = stage.stageByType('docs');
+      expect(docs.every(c => c.path.endsWith('.md'))).toBe(true);
+    });
+
+    test('stages by semantic type (test)', () => {
+      stage.stageChange('src/feature.test.ts', 'add', undefined, 'test');
+      stage.stageChange('src/feature.ts', 'add', undefined, 'code');
+
+      const tests = stage.stageByType('test');
+      expect(tests.every(c => c.path.includes('.test.'))).toBe(true);
+    });
+  });
+
+  describe('Diff', () => {
+    test('gets diff of staged changes', () => {
+      stage.stageChange('a.ts', 'add', undefined, 'new');
+      stage.stageChange('b.ts', 'modify', 'old', 'new');
+      stage.stageChange('c.ts', 'delete', 'old');
+
+      const diff = stage.getDiff();
+      expect(diff.get('a.ts')).toEqual({ old: undefined, new: 'new' });
+      expect(diff.get('b.ts')).toEqual({ old: 'old', new: 'new' });
+      expect(diff.get('c.ts')).toEqual({ old: 'old', new: undefined });
+    });
+  });
+
+  describe('Statistics', () => {
+    test('calculates staging stats', () => {
+      stage.stageChange('a.ts', 'add', undefined, 'content1');
+      stage.stageChange('b.ts', 'modify', 'old', 'content2');
+      stage.stageChange('c.ts', 'delete', 'content3');
+
+      const stats = stage.getStats();
+      expect(stats.stagedFiles).toBe(3);
+      expect(stats.addedFiles).toBe(1);
+      expect(stats.modifiedFiles).toBe(1);
+      expect(stats.deletedFiles).toBe(1);
+      expect(stats.estimatedSize).toBe('content1content2'.length);
+    });
+  });
+
+  describe('Type Detection', () => {
+    test('detects feature from source files', () => {
+      stage.stageChange('src/component.ts', 'add', undefined, 'code');
+      const type = stage.detectCommitType();
+      expect(type).toBe('feature');
+    });
+
+    test('detects test from test files', () => {
+      stage.stageChange('src/component.test.ts', 'add', undefined, 'test');
+      stage.stageChange('src/component.ts', 'add', undefined, 'code');
+
+      const type = stage.detectCommitType();
+      expect(type).toBe('test');
+    });
+
+    test('detects docs from markdown', () => {
+      stage.stageChange('README.md', 'modify', 'old', 'new');
+      const type = stage.detectCommitType();
+      expect(type).toBe('docs');
+    });
+
+    test('defaults to chore', () => {
+      stage.stageChange('random.txt', 'add', undefined, 'content');
+      const type = stage.detectCommitType();
+      expect(type).toBe('chore');
+    });
+  });
+
+  describe('Validation', () => {
+    test('validates valid commit', () => {
+      stage.stageChange('file.ts', 'modify', 'old', 'new');
+      const result = stage.validateCommit();
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('rejects empty stage', () => {
+      const result = stage.validateCommit();
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('No staged changes');
+    });
+
+    test('detects conflicting changes', () => {
+      stage.stageChange('file.ts', 'add', undefined, 'content');
+      stage.stageChange('file.ts', 'delete', 'content');
+
+      const result = stage.validateCommit();
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('multiple staged changes'))).toBe(true);
+    });
+  });
+
+  describe('Discard', () => {
+    test('discards staged changes', () => {
+      stage.stageChange('a.ts', 'add', undefined, 'a');
+      stage.stageChange('b.ts', 'add', undefined, 'b');
+
+      stage.discardStaged();
+      expect(stage.getStagedChanges()).toHaveLength(0);
+    });
+  });
+
+  describe('Commit Recording', () => {
+    test('records commit and clears stage', () => {
+      stage.stageChange('file.ts', 'modify', 'old', 'new');
+      expect(stage.getStagedChanges()).toHaveLength(1);
+
+      stage.recordCommit(new Map([['file.ts', 'new']]));
+      expect(stage.getStagedChanges()).toHaveLength(0);
+    });
+  });
+
+  describe('Real-world Workflow', () => {
+    test('complete commit workflow', () => {
+      // Setup working directory
+      const working = new Map([
+        ['src/feature.ts', 'export function feature() {}'],
+        ['src/utils.ts', 'export function helper() {}'],
+        ['tests/feature.test.ts', 'describe("feature", () => {})'],
+      ]);
+
+      stage.updateWorkingDirectory(working);
+
+      // Initial commit
+      stage.recordCommit(new Map([['src/utils.ts', 'old helper']]));
+
+      // Agent stages only test changes
+      const testChanges = working;
+      const tests = Array.from(testChanges.entries())
+        .filter(([path]) => path.includes('.test.'))
+        .map(([path, content]) => ({
+          path,
+          type: 'add' as const,
+          newContent: content,
+          timestamp: Date.now(),
+        }));
+
+      stage.stageMultiple(tests);
+
+      // Create test commit
+      const commit = stage.createCommit('test: add feature tests', 'test');
+      expect(commit.stagedChanges).toHaveLength(1);
+      expect(commit.stagedChanges[0].path).toContain('.test.ts');
+    });
+  });
+
+  describe('Cleanup', () => {
+    test('clears all state', () => {
+      stage.stageChange('file.ts', 'add', undefined, 'content');
+      stage.updateWorkingDirectory(new Map([['file.ts', 'content']]));
+      stage.recordCommit(new Map());
+
+      stage.clear();
+      expect(stage.getStagedChanges()).toHaveLength(0);
+    });
+  });
+});