@zoebuildsai/trace 1.5.0

package/tests/v1.5/integration-testing.real.test.ts

@@ -0,0 +1,440 @@
+/**
+ * Real Integration Testing - Trace v1.5.0
+ * Testing actual workflows with real agent scenarios
+ * This validates end-to-end functionality
+ */
+
+import { TraceCliv2 } from '../../src/cli-v2';
+import { WorkspaceIsolation } from '../../src/workspace-isolation';
+import { AgentCoordination } from '../../src/agent-coordination';
+import { ConflictResolutionUI } from '../../src/conflict-resolution-ui';
+
+describe('Trace v1.5.0 - Real Integration Testing', () => {
+  let cli: TraceCliv2;
+  let isolation: WorkspaceIsolation;
+  let coordination: AgentCoordination;
+
+  beforeEach(() => {
+    cli = new TraceCliv2();
+    isolation = new WorkspaceIsolation('/test/workspace', true);
+    coordination = new AgentCoordination({
+      allowParallel: true,
+      maxConcurrent: 10,
+      lockTimeout: 5000,
+      conflictStrategy: 'block',
+    });
+  });
+
+  describe('Real Agent Workflow 1: Simple Collaborative Edit', () => {
+    test('two agents edit different files in parallel', async () => {
+      // Agent A starts
+      const initResult = await cli.execute('trace init /workspace');
+      expect(initResult.success).toBe(true);
+
+      // Agent A edits file 1
+      const lockA = await cli.execute('trace lock src/api.ts');
+      expect(lockA.success).toBe(true);
+
+      const commitA = await cli.execute('trace commit -m "feat: add user endpoint"');
+      expect(commitA.success).toBe(true);
+
+      // Agent B edits different file in parallel
+      const lockB = await cli.execute('trace lock src/utils.ts');
+      expect(lockB.success).toBe(true);
+
+      const commitB = await cli.execute('trace commit -m "refactor: optimize helpers"');
+      expect(commitB.success).toBe(true);
+
+      // Both unlock
+      const unlockA = await cli.execute('trace unlock src/api.ts');
+      const unlockB = await cli.execute('trace unlock src/utils.ts');
+      expect(unlockA.success).toBe(true);
+      expect(unlockB.success).toBe(true);
+
+      // Both push
+      const pushA = await cli.execute('trace push origin main');
+      const pushB = await cli.execute('trace push origin main');
+      expect(pushA.success).toBe(true);
+      expect(pushB.success).toBe(true);
+    });
+  });
+
+  describe('Real Agent Workflow 2: Serialized File Editing', () => {
+    test('two agents queue for same file, second waits', async () => {
+      // Agent A locks shared file
+      const taskA = coordination.registerTask('agent-a', ['src/shared.ts'], 2);
+      expect(taskA.canStart).toBe(true);
+
+      // Agent A gets lock
+      const lockA = coordination.requestLock('src/shared.ts', 'agent-a');
+      expect(lockA.locked).toBe(true);
+
+      // Agent B tries same file, gets blocked
+      const taskB = coordination.registerTask('agent-b', ['src/shared.ts'], 1);
+      expect(taskB.canStart).toBe(false);
+      expect(taskB.blockedBy).toContain(taskA.taskId);
+
+      // Agent A completes
+      const unlockA = coordination.releaseLock('src/shared.ts', 'agent-a');
+      expect(unlockA).toBe(true);
+
+      coordination.completeTask(taskA.taskId);
+
+      // Now Agent B should be able to proceed
+      const lockB = coordination.requestLock('src/shared.ts', 'agent-b');
+      expect(lockB.locked).toBe(true);
+    });
+  });
+
+  describe('Real Agent Workflow 3: Conflict Detection & Resolution', () => {
+    test('detect conflict, resolve it, commit', async () => {
+      // Both agents try to edit same file
+      const taskA = coordination.registerTask('agent-a', ['src/main.ts', 'src/api.ts'], 2);
+      const taskB = coordination.registerTask('agent-b', ['src/main.ts', 'src/utils.ts'], 1);
+
+      // A can start
+      expect(taskA.canStart).toBe(true);
+
+      // B is blocked (conflict on main.ts)
+      expect(taskB.canStart).toBe(false);
+
+      // Detect collision
+      const collisions = coordination.getBlockedTasks();
+      expect(collisions.length).toBeGreaterThan(0);
+
+      // Show stats
+      const stats = coordination.getStats();
+      expect(stats.blocked).toBe(1);
+      expect(stats.executing).toBe(1);
+
+      // A completes
+      coordination.completeTask(taskA.taskId);
+
+      // B auto-unblocks
+      const unblocked = coordination.getBlockedTasks();
+      expect(unblocked.length).toBe(0);
+
+      // B can now proceed
+      const statusB = coordination.getTaskStatus(taskB.taskId);
+      expect(statusB?.status).toBe('executing');
+
+      // Resolve the conflict (if happened)
+      const resolveResult = await cli.execute('trace resolve src/main.ts --strategy ours');
+      expect(resolveResult.success).toBe(true);
+
+      // Commit after resolution
+      const commitResult = await cli.execute('trace commit -m "fix: resolved merge conflict"');
+      expect(commitResult.success).toBe(true);
+    });
+  });
+
+  describe('Real Agent Workflow 4: Security & Validation', () => {
+    test('prevent accidental .env commit, validate before push', async () => {
+      // Agent tries to commit .env (dangerous!)
+      const envCheck = isolation.isSafeToCommit('.env');
+      expect(envCheck.safe).toBe(false);
+      expect(envCheck.violations.length).toBeGreaterThan(0);
+
+      // Check the violation reason exists
+      expect(envCheck.violations[0].reason).toBeTruthy();
+      expect(envCheck.violations[0].reason.length).toBeGreaterThan(0);
+
+      // Try to commit safe file
+      const safeCheck = isolation.isSafeToCommit('src/api.ts');
+      expect(safeCheck.safe).toBe(true);
+      expect(safeCheck.violations.length).toBe(0);
+
+      // Validate multiple files before push
+      const files = ['src/api.ts', 'src/utils.ts', 'tests/api.test.ts'];
+      const pushValidation = isolation.validateGitPush(files);
+      expect(pushValidation.canPush).toBe(true);
+
+      // Try with dangerous files
+      const dangerousFiles = ['src/api.ts', '.env', 'secrets.json'];
+      const unsafeValidation = isolation.validateGitPush(dangerousFiles);
+      expect(unsafeValidation.canPush).toBe(false);
+      expect(unsafeValidation.violations.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Real Agent Workflow 5: Complex Task Dependencies', () => {
+    test('three agents with task dependencies (A→B→C)', async () => {
+      // Agent A: works on types (Task 1)
+      const taskA = coordination.registerTask('agent-a', ['src/types.ts'], 3);
+      expect(taskA.canStart).toBe(true);
+
+      // Agent B: works on API, depends on types (Task 2)
+      const taskB = coordination.registerTask('agent-b', ['src/api.ts', 'src/types.ts'], 2);
+      expect(taskB.canStart).toBe(false); // Blocked by A
+      expect(taskB.blockedBy).toContain(taskA.taskId);
+
+      // Agent C: works on tests, depends on both (Task 3)
+      const taskC = coordination.registerTask('agent-c', ['src/types.ts', 'src/api.ts', 'tests/api.test.ts'], 1);
+      expect(taskC.canStart).toBe(false); // Blocked by A and B
+      expect(taskC.blockedBy?.length).toBeGreaterThanOrEqual(1);
+
+      // Get suggested order
+      const order = coordination.suggestOrder();
+      const aIdx = order.indexOf(taskA.taskId);
+      const bIdx = order.indexOf(taskB.taskId);
+      const cIdx = order.indexOf(taskC.taskId);
+
+      // A should come before B before C
+      expect(aIdx).toBeLessThan(bIdx);
+      expect(bIdx).toBeLessThan(cIdx);
+
+      // Complete A
+      const unblocked1 = coordination.completeTask(taskA.taskId);
+      expect(unblocked1.unblocked).toContain(taskB.taskId);
+
+      // Verify B is now executing
+      const statusB = coordination.getTaskStatus(taskB.taskId);
+      expect(statusB?.status).toBe('executing');
+
+      // Complete B
+      const unblocked2 = coordination.completeTask(taskB.taskId);
+      expect(unblocked2.unblocked).toContain(taskC.taskId);
+
+      // Now C is executing
+      const statusC = coordination.getTaskStatus(taskC.taskId);
+      expect(statusC?.status).toBe('executing');
+
+      // Complete C
+      const unblocked3 = coordination.completeTask(taskC.taskId);
+      expect(unblocked3.success).toBe(true);
+    });
+  });
+
+  describe('Real Agent Workflow 6: High Concurrency Scenario', () => {
+    test('10 agents working simultaneously on different files', async () => {
+      const agents = Array.from({ length: 10 }, (_, i) => `agent-${i}`);
+      const files = Array.from({ length: 10 }, (_, i) => `src/module${i}.ts`);
+
+      // All agents register tasks simultaneously
+      const tasks = agents.map((agent, i) => {
+        return coordination.registerTask(agent, [files[i]], 10 - i);
+      });
+
+      // All should start (no conflicts)
+      tasks.forEach(task => {
+        expect(task.canStart).toBe(true);
+      });
+
+      // All should get locks
+      files.forEach((file, i) => {
+        const lock = coordination.requestLock(file, agents[i]);
+        expect(lock.locked).toBe(true);
+      });
+
+      // Get stats
+      const stats = coordination.getStats();
+      expect(stats.executing).toBe(10);
+      expect(stats.blocked).toBe(0);
+      expect(stats.currentLocks).toBe(10);
+
+      // Complete all tasks
+      for (let i = 0; i < tasks.length; i++) {
+        const result = coordination.completeTask(tasks[i].taskId);
+        expect(result.success).toBe(true);
+      }
+
+      // All should be done
+      const finalStats = coordination.getStats();
+      expect(finalStats.completed).toBe(10);
+      expect(finalStats.executing).toBe(0);
+    });
+  });
+
+  describe('Real Agent Workflow 7: Conflict Resolution UI', () => {
+    test('render conflict and suggest resolution', async () => {
+      const ours = `export function getUserName(id: string) {
+  return db.query('SELECT name FROM users WHERE id = ?', [id]);
+}`;
+
+      const theirs = `export async function getUserName(id: string): Promise<string> {
+  const result = await db.query('SELECT name FROM users WHERE id = ?', [id]);
+  return result[0].name;
+}`;
+
+      const base = `export function getUserName(id: string) {
+  return db.query('SELECT name FROM users WHERE id = ?', [id]);
+}`;
+
+      // Get suggestion
+      const suggestion = ConflictResolutionUI.suggestResolution(ours, theirs, base);
+      expect(suggestion.suggestion).toBeDefined();
+      expect(suggestion.confidence).toBeGreaterThan(0);
+      expect(suggestion.reason).toBeDefined();
+
+      // Render HTML UI
+      const html = ConflictResolutionUI.renderHTML('src/users.ts', ours, theirs, base);
+      expect(html).toContain('Conflict Resolution');
+      expect(html).toContain('getUserName');
+
+      // Render terminal UI
+      const terminal = ConflictResolutionUI.renderTerminal(
+        'src/users.ts',
+        ours.split('\n'),
+        theirs.split('\n'),
+        base.split('\n')
+      );
+      expect(terminal).toContain('RESOLUTION OPTIONS');
+
+      // Parse conflict markers (real git format)
+      const conflicted = `<<<<<<< HEAD
+export function getUserName(id: string) {
+  return db.query('SELECT name FROM users WHERE id = ?', [id]);
+}
+=======
+export async function getUserName(id: string): Promise<string> {
+  const result = await db.query('SELECT name FROM users WHERE id = ?', [id]);
+  return result[0].name;
+}
+>>>>>>> feature/async-queries`;
+
+      const parsed = ConflictResolutionUI.parseConflictMarkers(conflicted);
+      expect(parsed.hasConflicts).toBe(true);
+      expect(parsed.markers.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Real Agent Workflow 8: Multi-Agent Coordination State', () => {
+    test('complete workflow with coordination state display', async () => {
+      // Register 5 tasks with varying priorities
+      const task1 = coordination.registerTask('agent-1', ['file1.ts'], 5);
+      const task2 = coordination.registerTask('agent-2', ['file1.ts'], 4); // Blocks on 1
+      const task3 = coordination.registerTask('agent-3', ['file2.ts', 'file1.ts'], 3); // Blocks on 1&2
+      const task4 = coordination.registerTask('agent-4', ['file2.ts'], 2);
+      const task5 = coordination.registerTask('agent-5', ['file3.ts'], 1);
+
+      // Get current state
+      let state = coordination.formatState();
+      expect(state).toContain('AGENT COORDINATION STATE');
+      expect(state).toContain('BLOCKED TASKS');
+
+      // Get stats
+      let stats = coordination.getStats();
+      expect(stats.executing).toBeGreaterThan(0);
+      expect(stats.blocked).toBeGreaterThan(0);
+
+      // Complete task 1
+      coordination.completeTask(task1.taskId);
+      stats = coordination.getStats();
+      // Task 2 should unblock, so blocked count decreases
+      expect(stats.blocked).toBeLessThanOrEqual(2);
+
+      // Complete task 4
+      coordination.completeTask(task4.taskId);
+      stats = coordination.getStats();
+
+      // Complete remaining
+      coordination.completeTask(task2.taskId);
+      coordination.completeTask(task3.taskId);
+      coordination.completeTask(task5.taskId);
+
+      // All done
+      stats = coordination.getStats();
+      expect(stats.completed).toBe(5);
+      expect(stats.executing).toBe(0);
+      expect(stats.blocked).toBe(0);
+
+      // View final state
+      state = coordination.formatState();
+      expect(state).toContain('5 total');
+    });
+  });
+
+  describe('Performance Validation (Real Workloads)', () => {
+    test('process 100 tasks under 1 second', () => {
+      const start = Date.now();
+
+      for (let i = 0; i < 100; i++) {
+        const file = `file${i % 20}.ts`;
+        coordination.registerTask(`agent-${i % 10}`, [file], 100 - i);
+      }
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(1000);
+    });
+
+    test('detect conflicts in 100 tasks under 100ms', () => {
+      const tasks = [];
+      for (let i = 0; i < 100; i++) {
+        tasks.push(coordination.registerTask(`agent-${i % 5}`, [`file${i % 10}.ts`], i));
+      }
+
+      const start = Date.now();
+      const blocked = coordination.getBlockedTasks();
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(100);
+      // Check if there are blocked tasks (may be 0 if all different files)
+      expect(Array.isArray(blocked)).toBe(true);
+    });
+
+    test('file lock operations under 1ms each', () => {
+      const start = Date.now();
+
+      for (let i = 0; i < 1000; i++) {
+        const file = `file${i % 50}.ts`;
+        const agent = `agent-${i % 10}`;
+        coordination.requestLock(file, agent);
+      }
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(100); // 1000 operations < 100ms
+    });
+  });
+
+  describe('End-to-End Sanity Checks', () => {
+    test('CLI commands respond immediately', async () => {
+      const commands = [
+        'trace help',
+        'trace status',
+        'trace log',
+        'trace audit',
+        'trace validate',
+      ];
+
+      for (const cmd of commands) {
+        const start = Date.now();
+        const result = await cli.execute(cmd);
+        const elapsed = Date.now() - start;
+
+        expect(result.success).toBe(true);
+        expect(elapsed).toBeLessThan(100); // <100ms per command
+      }
+    });
+
+    test('security checks work', () => {
+      const dangerousFiles = ['.env', 'secrets.json', 'private.key', 'password.txt'];
+      const safeFiles = ['src/api.ts', 'tests/main.test.ts', 'docs/API.md'];
+
+      dangerousFiles.forEach(file => {
+        const result = isolation.isSafeToCommit(file);
+        expect(result.safe).toBe(false);
+      });
+
+      safeFiles.forEach(file => {
+        const result = isolation.isSafeToCommit(file);
+        expect(result.safe).toBe(true);
+      });
+    });
+
+    test('coordination prevents collisions', () => {
+      // Register A for file X
+      const a = coordination.registerTask('agent-a', ['shared.ts'], 2);
+      expect(a.canStart).toBe(true);
+
+      // Register B for same file
+      const b = coordination.registerTask('agent-b', ['shared.ts'], 1);
+      expect(b.canStart).toBe(false);
+
+      // Verify collision detected
+      expect(b.blockedBy).toContain(a.taskId);
+
+      // Cleanup
+      coordination.completeTask(a.taskId);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}