@zoebuildsai/trace 1.5.0

package/tests/v1.4/conflict-resolution-advanced.test.ts

@@ -0,0 +1,429 @@
+/**
+ * Advanced Conflict Resolution Tests
+ * Complex merge scenarios and edge cases
+ */
+
+import { ConflictResolutionUI } from '../../src/conflict-resolution-ui';
+
+describe('ConflictResolutionUI - Advanced Scenarios', () => {
+  describe('Complex Code Conflicts', () => {
+    test('handles import statement conflicts', () => {
+      const ours = `import React from 'react';
+import { Component } from 'react';
+import styles from './App.css';`;
+
+      const theirs = `import React, { Component } from 'react';
+import { useEffect } from 'react';
+import './App.css';`;
+
+      const base = `import React from 'react';`;
+
+      const html = ConflictResolutionUI.renderHTML('App.tsx', ours, theirs, base);
+      expect(html).toContain('import');
+    });
+
+    test('handles function signature conflicts', () => {
+      const ours = `function processData(items: Item[], options?: ProcessOptions): Result {
+  return new Result(items, options);
+}`;
+
+      const theirs = `async function processData(items: Item[]): Promise<Result> {
+  return await new Result(items).process();
+}`;
+
+      const base = `function processData(items: Item[]): Result {
+  return new Result(items);
+}`;
+
+      const result = ConflictResolutionUI.suggestResolution(ours, theirs, base);
+      expect(result.suggestion).toBeDefined();
+    });
+
+    test('handles class method conflicts', () => {
+      const ours = `class UserService {
+  getUser(id: string) {
+    return db.query('SELECT * FROM users WHERE id = ?', [id]);
+  }
+}`;
+
+      const theirs = `class UserService {
+  async getUser(id: string): Promise<User> {
+    const user = await db.query('SELECT * FROM users WHERE id = ?', [id]);
+    return user[0];
+  }
+}`;
+
+      const base = `class UserService {
+  getUser(id: string) {
+    return db.query('SELECT * FROM users WHERE id = ?', [id]);
+  }
+}`;
+
+      const html = ConflictResolutionUI.renderHTML('UserService.ts', ours, theirs, base);
+      expect(html).toContain('async');
+    });
+
+    test('handles JSON/config conflicts', () => {
+      const ours = `{
+  "name": "app",
+  "version": "1.0.0",
+  "dependencies": {
+    "react": "^18.0.0",
+    "lodash": "^4.17.0"
+  }
+}`;
+
+      const theirs = `{
+  "name": "app",
+  "version": "1.1.0",
+  "dependencies": {
+    "react": "^18.2.0",
+    "typescript": "^5.0.0"
+  }
+}`;
+
+      const base = `{
+  "name": "app",
+  "version": "1.0.0",
+  "dependencies": {}
+}`;
+
+      const html = ConflictResolutionUI.renderHTML('package.json', ours, theirs, base);
+      expect(html).toContain('version');
+    });
+  });
+
+  describe('Multi-Conflict Files', () => {
+    test('parses multiple conflicts in one file', () => {
+      const content = `export const config1 = {
+<<<<<<< HEAD
+  apiUrl: 'prod',
+  timeout: 5000,
+=======
+  apiUrl: 'dev',
+  timeout: 10000,
+>>>>>>> feature
+};
+
+export const config2 = {
+<<<<<<< HEAD
+  debug: false,
+=======
+  debug: true,
+>>>>>>> feature
+};`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(true);
+      expect(result.markers.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test('handles nested conflicts', () => {
+      const content = `function outer() {
+<<<<<<< HEAD
+  const inner = function() {
+    return 'ours';
+  };
+=======
+  const inner = () => 'theirs';
+>>>>>>> feature
+  return inner();
+}`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(true);
+    });
+
+    test('identifies correct conflict boundaries', () => {
+      const content = `start
+<<<<<<< ours
+content1
+content2
+content3
+=======
+different1
+different2
+>>>>>>> theirs
+end`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      const marker = result.markers[0];
+      expect(marker).toBeDefined();
+      expect(marker.oursStart < marker.oursEnd).toBe(true);
+    });
+  });
+
+  describe('Large File Conflicts', () => {
+    test('handles large conflict efficiently', () => {
+      const largeOurs = Array(1000)
+        .fill('line')
+        .map((l, i) => `${l} ${i}`)
+        .join('\n');
+      const largeTheirs = Array(1000)
+        .fill('other')
+        .map((l, i) => `${l} ${i}`)
+        .join('\n');
+
+      const start = Date.now();
+      const html = ConflictResolutionUI.renderHTML('large.ts', largeOurs, largeTheirs, 'base');
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(500);
+      expect(html).toContain('1000 lines');
+    });
+
+    test('terminal rendering truncates large files', () => {
+      const largeLines = Array(100).fill('line');
+      const output = ConflictResolutionUI.renderTerminal(
+        'file.ts',
+        largeLines,
+        largeLines,
+        largeLines
+      );
+
+      expect(output).toContain('... +');
+      expect(output).not.toContain('line 99'); // Should truncate
+    });
+  });
+
+  describe('Binary/Non-Text Conflicts', () => {
+    test('detects binary file conflicts', () => {
+      const binaryMarker = Buffer.from([0xff, 0xd8, 0xff, 0xe0]).toString('utf8');
+      const content = `<<<<<<< HEAD
+${binaryMarker}
+=======
+different binary
+>>>>>>> theirs`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(true);
+    });
+  });
+
+  describe('Special Characters & Encoding', () => {
+    test('handles Unicode characters', () => {
+      const ours = 'export const msg = "Hello 世界";';
+      const theirs = 'export const msg = "Hola 世界";';
+      const base = 'export const msg = "Hi";';
+
+      const html = ConflictResolutionUI.renderHTML('i18n.ts', ours, theirs, base);
+      expect(html).toContain('&');
+    });
+
+    test('escapes HTML special characters', () => {
+      const ours = '<script>alert("xss")</script>';
+      const theirs = '<img src=x onerror="alert(1)">';
+      const base = 'console.log("safe");';
+
+      const html = ConflictResolutionUI.renderHTML('xss.ts', ours, theirs, base);
+      expect(html).not.toContain('<script>');
+      expect(html).not.toContain('onerror=');
+      expect(html).toContain('&lt;');
+    });
+
+    test('handles emoji and special symbols', () => {
+      const ours = '// TODO: Implement feature 🚀';
+      const theirs = '// FIXME: Bug here ⚠️';
+
+      const html = ConflictResolutionUI.renderHTML('file.ts', ours, theirs, 'base');
+      expect(html.length).toBeGreaterThan(0);
+    });
+
+    test('preserves whitespace in conflicts', () => {
+      const ours = 'const x = 1;  // extra spaces';
+      const theirs = 'const x = 1;   // triple spaces';
+
+      const html = ConflictResolutionUI.renderHTML('file.ts', ours, theirs, 'base');
+      expect(html).toContain('pre-wrap'); // Should preserve whitespace
+    });
+  });
+
+  describe('Suggestion Algorithm', () => {
+    test('prefers shorter for obvious cases', () => {
+      const result = ConflictResolutionUI.suggestResolution(
+        'x = 1;',
+        'const veryLongVariableNameWithComplexLogic = functionCall(param1, param2, param3);',
+        'base'
+      );
+
+      expect(result.suggestion).toBe('ours');
+      expect(result.confidence).toBeGreaterThan(0.5);
+    });
+
+    test('provides confidence levels', () => {
+      const confident = ConflictResolutionUI.suggestResolution('short', 'very long content', 'base');
+      const uncertain = ConflictResolutionUI.suggestResolution('medium', 'medium length', 'base');
+
+      expect(confident.confidence).toBeGreaterThan(uncertain.confidence);
+    });
+
+    test('explains reasoning', () => {
+      const result = ConflictResolutionUI.suggestResolution('a', 'longer', 'b');
+      expect(result.reason).toContain('shorter');
+    });
+  });
+
+  describe('Git Format Variations', () => {
+    test('handles custom conflict marker names', () => {
+      const content = `<<<<<<< feature/my-branch
+our code
+=======
+their code
+>>>>>>> main`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(true);
+    });
+
+    test('handles three-way merge markers (merge base)', () => {
+      const content = `<<<<<<< current
+our change
+||||||| base
+original
+=======
+their change
+>>>>>>> other`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      // Should handle various conflict formats
+      expect(Array.isArray(result.markers)).toBe(true);
+    });
+
+    test('handles edge case: marker at EOF', () => {
+      const content = `line 1
+line 2
+<<<<<<< HEAD
+our final line`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      // Should handle incomplete conflicts gracefully
+      expect(result.hasConflicts).toBe(true);
+    });
+  });
+
+  describe('HTML UI Features', () => {
+    test('HTML includes copy-to-clipboard function', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'ours', 'theirs', 'base');
+      // Should be safe to copy code from rendered HTML
+      expect(html).toContain('line-content');
+    });
+
+    test('HTML includes keyboard shortcuts hints', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'ours', 'theirs', 'base');
+      expect(html).toContain('onclick');
+    });
+
+    test('terminal includes clear instructions', () => {
+      const output = ConflictResolutionUI.renderTerminal(
+        'file.ts',
+        ['our'],
+        ['their'],
+        ['base']
+      );
+
+      expect(output).toContain('[o]');
+      expect(output).toContain('[t]');
+      expect(output).toContain('[m]');
+      expect(output).toContain('[s]');
+    });
+  });
+
+  describe('Error Scenarios', () => {
+    test('handles empty inputs', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', '', '', '');
+      expect(html).toContain('Conflict Resolution');
+    });
+
+    test('handles very long lines', () => {
+      const longLine = 'a'.repeat(1000);
+      const html = ConflictResolutionUI.renderHTML('file.ts', longLine, 'short', 'base');
+      expect(html).toContain('white-space: pre-wrap');
+    });
+
+    test('handles mixed line endings', () => {
+      const ours = 'line1\r\nline2\nline3\r';
+      const theirs = 'line1\nline2\r\nline3';
+
+      const result = ConflictResolutionUI.parseConflictMarkers(
+        `<<<<<<< HEAD\n${ours}\n=======\n${theirs}\n>>>>>>> other`
+      );
+      expect(result.hasConflicts).toBe(true);
+    });
+  });
+
+  describe('Performance & Scalability', () => {
+    test('renders 10000-line file conflict', () => {
+      const huge = Array(5000)
+        .fill('line')
+        .map((l, i) => `${l} ${i}`)
+        .join('\n');
+
+      const start = Date.now();
+      const html = ConflictResolutionUI.renderHTML('huge.ts', huge, huge, 'base');
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(1000);
+      expect(html).toContain('5000 lines');
+    });
+
+    test('parses 100 conflicts efficiently', () => {
+      let content = '';
+      for (let i = 0; i < 100; i++) {
+        content += `<<<<<<< HEAD\nours${i}\n=======\ntheirs${i}\n>>>>>>> other\n`;
+      }
+
+      const start = Date.now();
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(500);
+      expect(result.markers.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('Real Repository Scenarios', () => {
+    test('handles merge conflict from git rebase', () => {
+      const conflicted = `CONFLICT (content): Merge conflict in src/main.ts
+<<<<<<< HEAD
+const version = '1.1.0';
+console.log(\`App version: \${version}\`);
+=======
+const version = '1.2.0';
+console.log('Starting app...');
+console.log(\`Version: \${version}\`);
+>>>>>>> feature/update-version`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(conflicted);
+      expect(result.hasConflicts).toBe(true);
+    });
+
+    test('handles dependency version conflicts', () => {
+      const ours = `"react": "^18.0.0",
+"react-dom": "^18.0.0",`;
+
+      const theirs = `"react": "^18.2.0",
+"react-dom": "^18.2.0",`;
+
+      const suggestion = ConflictResolutionUI.suggestResolution(ours, theirs, 'base');
+      expect(suggestion.confidence).toBeGreaterThan(0);
+    });
+
+    test('handles database migration conflicts', () => {
+      const ours = `CREATE TABLE users (
+  id INT PRIMARY KEY,
+  name VARCHAR(255),
+  email VARCHAR(255) UNIQUE
+);`;
+
+      const theirs = `CREATE TABLE users (
+  id INT PRIMARY KEY AUTO_INCREMENT,
+  username VARCHAR(255) UNIQUE,
+  email VARCHAR(255) UNIQUE,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);`;
+
+      const html = ConflictResolutionUI.renderHTML('migration.sql', ours, theirs, 'base');
+      expect(html).toContain('CREATE TABLE');
+    });
+  });
+});

package/tests/v1.4/conflict-resolution-ui.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Conflict Resolution UI Tests
+ * HTML/Terminal rendering for conflict resolution
+ */
+
+import { ConflictResolutionUI } from '../../src/conflict-resolution-ui';
+
+describe('ConflictResolutionUI', () => {
+  describe('HTML Rendering', () => {
+    test('renders HTML for conflict', () => {
+      const html = ConflictResolutionUI.renderHTML(
+        'main.ts',
+        'export function myFunc() {}',
+        'export async function myFunc() {}',
+        'function myFunc() {}'
+      );
+
+      expect(html).toContain('<!DOCTYPE html>');
+      expect(html).toContain('Conflict Resolution');
+      expect(html).toContain('main.ts');
+    });
+
+    test('includes both versions in HTML', () => {
+      const html = ConflictResolutionUI.renderHTML(
+        'file.ts',
+        'version a',
+        'version b',
+        'base'
+      );
+
+      expect(html).toContain('Your Changes (Ours)');
+      expect(html).toContain('Incoming Changes (Theirs)');
+      expect(html).toContain('version a');
+      expect(html).toContain('version b');
+    });
+
+    test('includes action buttons in HTML', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'a', 'b', 'c');
+      expect(html).toContain('Use Ours');
+      expect(html).toContain('Use Theirs');
+      expect(html).toContain('Manual Merge');
+      expect(html).toContain('Skip');
+    });
+
+    test('includes line numbers in HTML', () => {
+      const html = ConflictResolutionUI.renderHTML(
+        'file.ts',
+        'line1\nline2\nline3',
+        'line1\nlineB\nlineC',
+        'line1'
+      );
+
+      expect(html).toContain('line-num');
+      expect(html).toContain('3 lines');
+      expect(html).toContain('2 lines');
+    });
+
+    test('escapes HTML special characters', () => {
+      const html = ConflictResolutionUI.renderHTML(
+        'file.ts',
+        '<script>alert("xss")</script>',
+        'const x = 5;',
+        'base'
+      );
+
+      expect(html).toContain('&lt;');
+      expect(html).not.toContain('<script>');
+    });
+  });
+
+  describe('Terminal Rendering', () => {
+    test('renders terminal conflict', () => {
+      const output = ConflictResolutionUI.renderTerminal(
+        'main.ts',
+        ['export function myFunc() {}'],
+        ['export async function myFunc() {}'],
+        ['function myFunc() {}']
+      );
+
+      expect(output).toContain('CONFLICT RESOLUTION');
+      expect(output).toContain('main.ts');
+    });
+
+    test('includes both versions in terminal', () => {
+      const output = ConflictResolutionUI.renderTerminal(
+        'file.ts',
+        ['version a'],
+        ['version b'],
+        ['base']
+      );
+
+      expect(output).toContain('YOURS (Current Branch)');
+      expect(output).toContain('THEIRS (Incoming Changes)');
+      expect(output).toContain('BASE (Common Ancestor)');
+    });
+
+    test('includes resolution options in terminal', () => {
+      const output = ConflictResolutionUI.renderTerminal(
+        'file.ts',
+        ['a'],
+        ['b'],
+        ['c']
+      );
+
+      expect(output).toContain('RESOLUTION OPTIONS');
+      expect(output).toContain('[o]');
+      expect(output).toContain('[t]');
+      expect(output).toContain('[m]');
+      expect(output).toContain('[s]');
+    });
+
+    test('handles large diffs gracefully', () => {
+      const largeOurs = Array(50).fill('line').map((l, i) => `${l} ${i}`);
+      const largeTheirs = Array(50).fill('other').map((l, i) => `${l} ${i}`);
+      const output = ConflictResolutionUI.renderTerminal(
+        'large.ts',
+        largeOurs,
+        largeTheirs,
+        ['base']
+      );
+
+      expect(output).toContain('... +40 more lines');
+    });
+  });
+
+  describe('Resolution Suggestions', () => {
+    test('suggests shorter version', () => {
+      const result = ConflictResolutionUI.suggestResolution(
+        'short',
+        'this is much longer content',
+        'base'
+      );
+
+      expect(result.suggestion).toBe('ours');
+      expect(result.confidence).toBeGreaterThan(0);
+    });
+
+    test('suggests incoming if shorter', () => {
+      const result = ConflictResolutionUI.suggestResolution(
+        'this is much longer content',
+        'short',
+        'base'
+      );
+
+      expect(result.suggestion).toBe('theirs');
+    });
+
+    test('suggests manual if equal', () => {
+      const result = ConflictResolutionUI.suggestResolution(
+        'version a',
+        'version b',
+        'base'
+      );
+
+      expect(result.suggestion).toBe('manual');
+      expect(result.confidence).toBeLessThan(0.7);
+    });
+
+    test('includes reasoning', () => {
+      const result = ConflictResolutionUI.suggestResolution(
+        'short',
+        'longer content',
+        'base'
+      );
+
+      expect(result.reason).toBeDefined();
+      expect(result.reason.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Conflict Marker Parsing', () => {
+    test('parses git conflict markers', () => {
+      const content = `line 1
+<<<<<<< ours
+our change
+=======
+their change
+>>>>>>> theirs
+line 2`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(true);
+      expect(result.markers).toHaveLength(1);
+    });
+
+    test('identifies multiple conflicts', () => {
+      const content = `<<<<<<< ours
+a1
+=======
+b1
+>>>>>>> theirs
+<<<<<<< ours
+a2
+=======
+b2
+>>>>>>> theirs`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.markers.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test('reports no conflicts when none exist', () => {
+      const content = `clean file
+with no conflicts
+just code`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.hasConflicts).toBe(false);
+      expect(result.markers).toHaveLength(0);
+    });
+
+    test('locates conflict markers accurately', () => {
+      const content = `line 0
+line 1
+<<<<<<< ours
+our
+=======
+their
+>>>>>>> theirs
+line 2`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(content);
+      expect(result.markers[0].startLine).toBe(2);
+    });
+  });
+
+  describe('Real-World Scenarios', () => {
+    test('handles code conflict', () => {
+      const ours = `function calculateTotal(items) {
+  let sum = 0;
+  for (let item of items) {
+    sum += item.price;
+  }
+  return sum;
+}`;
+
+      const theirs = `function calculateTotal(items) {
+  return items.reduce((sum, item) => sum + item.price, 0);
+}`;
+
+      const base = `function calculateTotal(items) {
+  let sum = 0;
+  items.forEach(item => sum += item.price);
+  return sum;
+}`;
+
+      const html = ConflictResolutionUI.renderHTML('calc.ts', ours, theirs, base);
+      expect(html).toContain('calculateTotal');
+    });
+
+    test('handles merge conflict markers', () => {
+      const conflicted = `const config = {
+<<<<<<< HEAD
+  apiUrl: 'https://api.prod.com',
+  timeout: 5000,
+=======
+  apiUrl: 'https://api.dev.com',
+  timeout: 10000,
+>>>>>>> feature/dev-config
+  retries: 3
+};`;
+
+      const result = ConflictResolutionUI.parseConflictMarkers(conflicted);
+      expect(result.hasConflicts).toBe(true);
+    });
+  });
+
+  describe('UI Accessibility', () => {
+    test('includes proper semantic HTML', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'a', 'b', 'c');
+      expect(html).toContain('<button');
+      expect(html).toContain('</html>');
+    });
+
+    test('includes styling', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'a', 'b', 'c');
+      expect(html).toContain('<style>');
+    });
+
+    test('includes JavaScript handlers', () => {
+      const html = ConflictResolutionUI.renderHTML('file.ts', 'a', 'b', 'c');
+      expect(html).toContain('<script>');
+      expect(html).toContain('resolve');
+    });
+  });
+});