@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/conflict-agent.test.cjs

@@ -0,0 +1,554 @@
+/**
+ * Tests for conflict-agent.cjs pure functions
+ *
+ * Covers resolution strategy selection (ADDITIVE, DELETION, STRUCTURAL, DIVERGENT),
+ * whole-file resolution, semantic conflict detection, cascading learning context,
+ * and resolution report generation.
+ *
+ * Uses Node.js built-in test runner (node:test) and assert (node:assert/strict).
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  selectResolutionStrategy,
+  resolveFileContent,
+  detectSemanticConflicts,
+  createLearningContext,
+  mergeLearningContexts,
+  buildResolutionReport,
+} = require('./conflict-agent.cjs');
+
+// ─── Helper ──────────────────────────────────────────────────────────────────
+
+/**
+ * Build a file content string with one or more conflict hunks.
+ * @param {Array<{ours: string, theirs: string}>} hunks
+ * @returns {string}
+ */
+function buildConflictFile(hunks) {
+  const parts = ['// preamble'];
+  for (const h of hunks) {
+    parts.push('<<<<<<< HEAD');
+    if (h.ours) parts.push(h.ours);
+    parts.push('=======');
+    if (h.theirs) parts.push(h.theirs);
+    parts.push('>>>>>>> feature-branch');
+  }
+  parts.push('// postamble');
+  return parts.join('\n');
+}
+
+// ─── selectResolutionStrategy ────────────────────────────────────────────────
+
+describe('selectResolutionStrategy', () => {
+
+  it('selects theirs for ADDITIVE hunk where ours is empty and theirs has content', () => {
+    const hunks = [{
+      type: 'ADDITIVE',
+      confidence: 'HIGH',
+      ours: '',
+      theirs: 'const newFeature = true;',
+      start_line: 2,
+      end_line: 6,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'theirs');
+    assert.equal(result[0].confidence, 'HIGH');
+  });
+
+  it('selects ours for ADDITIVE hunk where theirs is empty and ours has content', () => {
+    const hunks = [{
+      type: 'ADDITIVE',
+      confidence: 'HIGH',
+      ours: 'const added = true;',
+      theirs: '',
+      start_line: 2,
+      end_line: 6,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'ours');
+    assert.equal(result[0].confidence, 'HIGH');
+  });
+
+  it('selects theirs for ADDITIVE hunk where theirs adds new content (superset)', () => {
+    const hunks = [{
+      type: 'ADDITIVE',
+      confidence: 'MEDIUM',
+      ours: 'const a = 1;',
+      theirs: 'const a = 1;\nconst b = 2;',
+      start_line: 2,
+      end_line: 8,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'theirs');
+    assert.equal(result[0].confidence, 'HIGH');
+  });
+
+  it('selects combined for STRUCTURAL hunk with different imports on each side', () => {
+    const hunks = [{
+      type: 'STRUCTURAL',
+      confidence: 'HIGH',
+      ours: "const utils = require('./utils.cjs');",
+      theirs: "const helpers = require('./helpers.cjs');",
+      start_line: 1,
+      end_line: 5,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'combined');
+    assert.ok(result[0].confidence === 'HIGH' || result[0].confidence === 'MEDIUM');
+  });
+
+  it('escalates DIVERGENT hunk without plan context', () => {
+    const hunks = [{
+      type: 'DIVERGENT',
+      confidence: 'LOW',
+      ours: 'const mode = "dark";',
+      theirs: 'const mode = "light";',
+      start_line: 3,
+      end_line: 7,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'escalate');
+    assert.equal(result[0].confidence, 'LOW');
+  });
+
+  it('selects combined for DIVERGENT hunk when plan context is available and no overlapping lines', () => {
+    const hunks = [{
+      type: 'DIVERGENT',
+      confidence: 'LOW',
+      ours: 'const timeout = 3000;',
+      theirs: 'const retries = 5;',
+      start_line: 3,
+      end_line: 7,
+    }];
+    const planContext = [
+      { task_name: 'Update config', action_excerpt: 'adjust settings for both timeout and retries' },
+    ];
+    const result = selectResolutionStrategy(hunks, planContext, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'combined');
+    assert.equal(result[0].confidence, 'MEDIUM');
+  });
+
+  it('selects ours (keep-content) for DELETION hunk by default', () => {
+    const hunks = [{
+      type: 'DELETION',
+      confidence: 'HIGH',
+      ours: 'const legacy = true;',
+      theirs: '',
+      start_line: 2,
+      end_line: 6,
+    }];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].strategy, 'ours');
+    assert.equal(result[0].confidence, 'MEDIUM');
+    assert.ok(result[0].reasoning.includes('keeping content'));
+  });
+
+  it('boosts confidence when accumulated learnings match domain', () => {
+    const hunks = [{
+      type: 'DIVERGENT',
+      confidence: 'LOW',
+      ours: 'const timeout = 3000;',
+      theirs: 'const retries = 5;',
+      start_line: 3,
+      end_line: 7,
+    }];
+    const planContext = [
+      { task_name: 'Update config', action_excerpt: 'Adjust timeout and retries' },
+    ];
+    const learnings = {
+      files_resolved: ['config.cjs'],
+      strategies_used: [{ file: 'config.cjs', strategy: 'combined' }],
+      domain_changes: { config: 'Resolved via combined' },
+      phase_merges_completed: 1,
+    };
+    // DIVERGENT with plan context + no overlap => 'combined' at MEDIUM
+    // Learnings have 'config' domain, and hunk text doesn't necessarily contain 'config'
+    // But timeout/retries text may not match 'config' domain, so let's use matching domain
+    const hunks2 = [{
+      type: 'DIVERGENT',
+      confidence: 'LOW',
+      ours: 'const config = { timeout: 3000 };',
+      theirs: 'const config = { retries: 5 };',
+      start_line: 3,
+      end_line: 7,
+    }];
+    const result = selectResolutionStrategy(hunks2, planContext, learnings);
+    assert.equal(result.length, 1);
+    // DIVERGENT with context and overlapping 'config' line => escalate because overlap
+    // Let's use non-overlapping lines that contain 'config' in their text
+    const hunks3 = [{
+      type: 'DELETION',
+      confidence: 'HIGH',
+      ours: 'const config_timeout = 3000;',
+      theirs: '',
+      start_line: 3,
+      end_line: 7,
+    }];
+    const result2 = selectResolutionStrategy(hunks3, null, learnings);
+    // DELETION default => ours, MEDIUM confidence
+    // Learnings domain 'config' matches 'config_timeout' in ours text
+    // MEDIUM boosted to HIGH
+    assert.equal(result2[0].strategy, 'ours');
+    assert.equal(result2[0].confidence, 'HIGH');
+    assert.ok(result2[0].reasoning.includes('boosted'));
+  });
+
+  it('handles multiple hunks returning strategy per hunk', () => {
+    const hunks = [
+      { type: 'ADDITIVE', confidence: 'HIGH', ours: '', theirs: 'new line', start_line: 2, end_line: 6 },
+      { type: 'DELETION', confidence: 'HIGH', ours: 'old line', theirs: '', start_line: 8, end_line: 12 },
+      { type: 'DIVERGENT', confidence: 'LOW', ours: 'const a = 1;', theirs: 'const a = 2;', start_line: 14, end_line: 18 },
+    ];
+    const result = selectResolutionStrategy(hunks, null, null);
+    assert.equal(result.length, 3);
+    assert.equal(result[0].hunk_index, 0);
+    assert.equal(result[1].hunk_index, 1);
+    assert.equal(result[2].hunk_index, 2);
+    assert.equal(result[0].strategy, 'theirs');  // ADDITIVE, ours empty
+    assert.equal(result[1].strategy, 'ours');     // DELETION, keep content
+    assert.equal(result[2].strategy, 'escalate'); // DIVERGENT, no context
+  });
+
+});
+
+// ─── resolveFileContent ──────────────────────────────────────────────────────
+
+describe('resolveFileContent', () => {
+
+  it('resolves ours strategy by keeping ours content', () => {
+    const content = buildConflictFile([{ ours: 'const x = 1;', theirs: 'const x = 2;' }]);
+    const strategies = [{ hunk_index: 0, strategy: 'ours' }];
+    const result = resolveFileContent(content, strategies, null);
+    assert.ok(result.resolved_content.includes('const x = 1;'));
+    assert.ok(!result.resolved_content.includes('const x = 2;'));
+    assert.ok(!result.resolved_content.includes('<<<<<<<'));
+    assert.equal(result.applied, 1);
+    assert.equal(result.escalated, 0);
+    assert.equal(result.has_unresolved, false);
+  });
+
+  it('resolves theirs strategy by keeping theirs content', () => {
+    const content = buildConflictFile([{ ours: 'const x = 1;', theirs: 'const x = 2;' }]);
+    const strategies = [{ hunk_index: 0, strategy: 'theirs' }];
+    const result = resolveFileContent(content, strategies, null);
+    assert.ok(result.resolved_content.includes('const x = 2;'));
+    assert.ok(!result.resolved_content.includes('const x = 1;'));
+    assert.ok(!result.resolved_content.includes('<<<<<<<'));
+    assert.equal(result.applied, 1);
+    assert.equal(result.escalated, 0);
+  });
+
+  it('resolves combined strategy by concatenating both sides', () => {
+    const content = buildConflictFile([{ ours: 'const a = 1;', theirs: 'const b = 2;' }]);
+    const strategies = [{ hunk_index: 0, strategy: 'combined' }];
+    const result = resolveFileContent(content, strategies, null);
+    assert.ok(result.resolved_content.includes('const a = 1;'));
+    assert.ok(result.resolved_content.includes('const b = 2;'));
+    assert.ok(!result.resolved_content.includes('<<<<<<<'));
+    assert.equal(result.applied, 1);
+  });
+
+  it('leaves escalated hunks with conflict markers', () => {
+    const content = buildConflictFile([{ ours: 'const x = 1;', theirs: 'const x = 2;' }]);
+    const strategies = [{ hunk_index: 0, strategy: 'escalate' }];
+    const result = resolveFileContent(content, strategies, null);
+    assert.ok(result.resolved_content.includes('<<<<<<< ours'));
+    assert.ok(result.resolved_content.includes('======='));
+    assert.ok(result.resolved_content.includes('>>>>>>> theirs'));
+    assert.equal(result.has_unresolved, true);
+    assert.equal(result.escalated, 1);
+    assert.equal(result.applied, 0);
+  });
+
+  it('handles multi-hunk file with mixed strategies', () => {
+    const content = buildConflictFile([
+      { ours: 'const a = 1;', theirs: 'const a = 2;' },
+      { ours: 'const b = 10;', theirs: 'const b = 20;' },
+      { ours: 'const c = 100;', theirs: 'const c = 200;' },
+    ]);
+    const strategies = [
+      { hunk_index: 0, strategy: 'ours' },
+      { hunk_index: 1, strategy: 'theirs' },
+      { hunk_index: 2, strategy: 'combined' },
+    ];
+    const result = resolveFileContent(content, strategies, null);
+    assert.ok(result.resolved_content.includes('const a = 1;'));   // ours
+    assert.ok(!result.resolved_content.includes('const a = 2;'));
+    assert.ok(result.resolved_content.includes('const b = 20;'));  // theirs
+    assert.ok(!result.resolved_content.includes('const b = 10;'));
+    assert.ok(result.resolved_content.includes('const c = 100;')); // combined
+    assert.ok(result.resolved_content.includes('const c = 200;'));
+    assert.equal(result.applied, 3);
+    assert.equal(result.escalated, 0);
+    assert.equal(result.has_unresolved, false);
+  });
+
+  it('deduplicates require lines in combined structural resolution', () => {
+    const oursImports = "const fs = require('fs');\nconst path = require('path');";
+    const theirsImports = "const path = require('path');\nconst os = require('os');";
+    const content = buildConflictFile([{ ours: oursImports, theirs: theirsImports }]);
+    const strategies = [{ hunk_index: 0, strategy: 'combined' }];
+    const result = resolveFileContent(content, strategies, null);
+    // Should deduplicate: path appears once, sorted alphabetically
+    const lines = result.resolved_content.split('\n');
+    const requireLines = lines.filter(l => l.includes('require('));
+    assert.equal(requireLines.length, 3, 'Should have 3 unique require lines (fs, os, path)');
+    // Check alphabetical order
+    const requireTexts = requireLines.map(l => l.trim());
+    const sorted = [...requireTexts].sort((a, b) => a.localeCompare(b));
+    assert.deepEqual(requireTexts, sorted, 'Require lines should be alphabetically sorted');
+    assert.equal(result.applied, 1);
+  });
+
+  it('returns correct applied and escalated counts', () => {
+    const content = buildConflictFile([
+      { ours: 'line1', theirs: 'line2' },
+      { ours: 'line3', theirs: 'line4' },
+      { ours: 'line5', theirs: 'line6' },
+    ]);
+    const strategies = [
+      { hunk_index: 0, strategy: 'ours' },
+      { hunk_index: 1, strategy: 'theirs' },
+      { hunk_index: 2, strategy: 'escalate' },
+    ];
+    const result = resolveFileContent(content, strategies, null);
+    assert.equal(result.applied, 2);
+    assert.equal(result.escalated, 1);
+    assert.equal(result.has_unresolved, true);
+  });
+
+  it('handles file with no conflict markers gracefully', () => {
+    const content = '// normal file\nconst x = 1;\nmodule.exports = { x };\n';
+    const strategies = [];
+    const result = resolveFileContent(content, strategies, null);
+    assert.equal(result.resolved_content, content);
+    assert.equal(result.applied, 0);
+    assert.equal(result.escalated, 0);
+    assert.equal(result.has_unresolved, false);
+  });
+
+});
+
+// ─── detectSemanticConflicts ─────────────────────────────────────────────────
+
+describe('detectSemanticConflicts', () => {
+
+  it('returns empty array when no files have dual-branch modifications', () => {
+    // Test with a non-existent cwd so git commands return nothing useful
+    // detectSemanticConflicts checks git log for MERGE_HEAD..HEAD and HEAD..MERGE_HEAD
+    // In a non-merge state, these return empty or error, so no warnings
+    const result = detectSemanticConflicts('/tmp/nonexistent-dir-' + Date.now(), [], null);
+    assert.deepEqual(result, []);
+  });
+
+  it('returns empty array for empty file list', () => {
+    const result = detectSemanticConflicts(process.cwd(), [], null);
+    assert.deepEqual(result, []);
+  });
+
+  it('includes domain information when plan context available', () => {
+    // This test verifies the function signature and output shape
+    // Without a real merge state, the function won't find dual-branch modifications
+    const planContext = [
+      { task_name: 'Update parser', action_excerpt: 'modify parser logic' },
+    ];
+    const result = detectSemanticConflicts('/tmp/nonexistent-dir-' + Date.now(), ['parser.js'], planContext);
+    // No real git repo so no warnings generated, but function handles gracefully
+    assert.ok(Array.isArray(result));
+  });
+
+  it('returns risk level based on domain overlap', () => {
+    // Verify the output shape when warnings are present
+    // We can test this by creating a mock result structure
+    // The function itself requires a real merge state to produce warnings
+    // Testing the expected shape: { file, domain, ours_changes, theirs_changes, risk }
+    const result = detectSemanticConflicts('/tmp/nonexistent-dir-' + Date.now(), [], null);
+    assert.ok(Array.isArray(result));
+    // Verify it handles gracefully even without real git state
+    assert.equal(result.length, 0);
+  });
+
+});
+
+// ─── createLearningContext and mergeLearningContexts ─────────────────────────
+
+describe('createLearningContext and mergeLearningContexts', () => {
+
+  it('creates learning context from resolution results', () => {
+    const resolutionResults = [
+      {
+        file: 'src/config.cjs',
+        strategies: [{ strategy: 'ours', confidence: 'HIGH' }],
+        result: { applied: 1, escalated: 0 },
+      },
+      {
+        file: 'src/utils.cjs',
+        strategies: [{ strategy: 'combined', confidence: 'MEDIUM' }, { strategy: 'theirs', confidence: 'HIGH' }],
+        result: { applied: 2, escalated: 0 },
+      },
+    ];
+    const ctx = createLearningContext(resolutionResults);
+    assert.deepEqual(ctx.files_resolved, ['src/config.cjs', 'src/utils.cjs']);
+    assert.equal(ctx.strategies_used.length, 3);
+    assert.ok(ctx.domain_changes.config);
+    assert.ok(ctx.domain_changes.utils);
+    assert.equal(ctx.phase_merges_completed, 1);
+  });
+
+  it('merges two learning contexts preserving all entries', () => {
+    const ctx1 = {
+      files_resolved: ['a.cjs'],
+      strategies_used: [{ file: 'a.cjs', strategy: 'ours' }],
+      domain_changes: { a: 'Resolved via ours' },
+      phase_merges_completed: 1,
+    };
+    const ctx2 = {
+      files_resolved: ['b.cjs'],
+      strategies_used: [{ file: 'b.cjs', strategy: 'theirs' }],
+      domain_changes: { b: 'Resolved via theirs' },
+      phase_merges_completed: 1,
+    };
+    const merged = mergeLearningContexts(ctx1, ctx2);
+    assert.deepEqual(merged.files_resolved, ['a.cjs', 'b.cjs']);
+    assert.equal(merged.strategies_used.length, 2);
+    assert.ok(merged.domain_changes.a);
+    assert.ok(merged.domain_changes.b);
+    assert.equal(merged.phase_merges_completed, 2);
+  });
+
+  it('handles empty existing context on first merge', () => {
+    const newCtx = {
+      files_resolved: ['first.cjs'],
+      strategies_used: [{ file: 'first.cjs', strategy: 'combined' }],
+      domain_changes: { first: 'Resolved via combined' },
+      phase_merges_completed: 1,
+    };
+    const merged = mergeLearningContexts(null, newCtx);
+    assert.deepEqual(merged.files_resolved, ['first.cjs']);
+    assert.equal(merged.strategies_used.length, 1);
+    assert.equal(merged.phase_merges_completed, 1);
+  });
+
+  it('accumulates across 3 sequential merges', () => {
+    const ctx1 = createLearningContext([{ file: 'a.cjs', strategies: [{ strategy: 'ours' }], result: {} }]);
+    const ctx2 = createLearningContext([{ file: 'b.cjs', strategies: [{ strategy: 'theirs' }], result: {} }]);
+    const ctx3 = createLearningContext([{ file: 'c.cjs', strategies: [{ strategy: 'combined' }], result: {} }]);
+
+    let acc = mergeLearningContexts(null, ctx1);
+    acc = mergeLearningContexts(acc, ctx2);
+    acc = mergeLearningContexts(acc, ctx3);
+
+    assert.deepEqual(acc.files_resolved, ['a.cjs', 'b.cjs', 'c.cjs']);
+    assert.equal(acc.strategies_used.length, 3);
+    assert.equal(acc.phase_merges_completed, 3);
+    assert.ok(acc.domain_changes.a);
+    assert.ok(acc.domain_changes.b);
+    assert.ok(acc.domain_changes.c);
+  });
+
+});
+
+// ─── buildResolutionReport ───────────────────────────────────────────────────
+
+describe('buildResolutionReport', () => {
+
+  const sampleFileResults = [
+    {
+      file: 'src/config.cjs',
+      hunks: [{
+        type: 'ADDITIVE',
+        start_line: 2,
+        end_line: 6,
+        ours: '',
+        theirs: 'const newConfig = true;',
+      }],
+      strategies: [{
+        hunk_index: 0,
+        strategy: 'theirs',
+        confidence: 'HIGH',
+        reasoning: 'Additive hunk: theirs adds new content',
+      }],
+      result: { applied: 1, escalated: 0 },
+    },
+    {
+      file: 'src/utils.cjs',
+      hunks: [{
+        type: 'DIVERGENT',
+        start_line: 10,
+        end_line: 14,
+        ours: 'const val = 1;',
+        theirs: 'const val = 2;',
+      }],
+      strategies: [{
+        hunk_index: 0,
+        strategy: 'escalate',
+        confidence: 'LOW',
+        reasoning: 'Divergent hunk: no plan context',
+      }],
+      result: { applied: 0, escalated: 1 },
+    },
+  ];
+
+  const sampleMetadata = {
+    branches: { ours: 'main', theirs: 'feature-x' },
+    phase: '01-test',
+    timestamp: '2026-02-27T00:00:00Z',
+    semantic_warnings: [
+      { file: 'src/shared.cjs', domain: 'shared', ours_changes: 'add helper', theirs_changes: 'modify helper', risk: 'warning' },
+    ],
+  };
+
+  it('produces valid markdown with all sections', () => {
+    const report = buildResolutionReport(sampleFileResults, sampleMetadata);
+    assert.ok(report.includes('# Conflict Resolution Report'));
+    assert.ok(report.includes('## Resolved Conflicts'));
+    assert.ok(report.includes('## Semantic Warnings'));
+    assert.ok(report.includes('## Summary'));
+  });
+
+  it('includes per-file detail with truncated before/after snippets', () => {
+    const report = buildResolutionReport(sampleFileResults, sampleMetadata);
+    assert.ok(report.includes('src/config.cjs'));
+    assert.ok(report.includes('src/utils.cjs'));
+    // Should include ours/theirs side snippets
+    assert.ok(report.includes('Ours side (truncated)') || report.includes('Theirs side (truncated)'));
+  });
+
+  it('includes confidence breakdown in summary', () => {
+    const report = buildResolutionReport(sampleFileResults, sampleMetadata);
+    // Should have confidence count table
+    assert.ok(report.includes('| HIGH |'));
+    assert.ok(report.includes('| MEDIUM |'));
+    assert.ok(report.includes('| LOW |'));
+  });
+
+  it('includes semantic warnings section', () => {
+    const report = buildResolutionReport(sampleFileResults, sampleMetadata);
+    assert.ok(report.includes('src/shared.cjs'));
+    assert.ok(report.includes('warning'));
+    assert.ok(report.includes('shared'));
+  });
+
+  it('shows no semantic warnings message when array is empty', () => {
+    const metaNoWarnings = { ...sampleMetadata, semantic_warnings: [] };
+    const report = buildResolutionReport(sampleFileResults, metaNoWarnings);
+    assert.ok(report.includes('No semantic conflicts detected'));
+  });
+
+  it('includes overall assessment based on confidence levels', () => {
+    const report = buildResolutionReport(sampleFileResults, sampleMetadata);
+    // Has LOW confidence, so assessment should recommend review
+    assert.ok(report.includes('Manual review recommended') || report.includes('LOW confidence'));
+  });
+
+});