@ktpartners/dgs-platform 2.6.2

package/deliver-great-systems/bin/lib/merge-conflicts.test.cjs

@@ -0,0 +1,370 @@
+/**
+ * Tests for classifyConflictHunks in merge-conflicts.cjs
+ *
+ * Covers all four conflict types (ADDITIVE, DIVERGENT, STRUCTURAL, DELETION),
+ * confidence scoring (HIGH, MEDIUM, LOW), ambiguity flagging, plan-context
+ * enhancement, multi-hunk files, and edge cases.
+ *
+ * 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 { classifyConflictHunks } = require('./merge-conflicts.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');
+}
+
+// ─── ADDITIVE classification ─────────────────────────────────────────────────
+
+describe('classifyConflictHunks', () => {
+
+  describe('ADDITIVE classification', () => {
+
+    it('detects ours-empty as ADDITIVE with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: '',
+        theirs: 'const newFeature = true;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[0].confidence, 'HIGH');
+      assert.equal(result[0].ambiguous, false);
+    });
+
+    it('detects one-side-superset as ADDITIVE with MEDIUM confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'const a = 1;',
+        theirs: 'const a = 1;\nconst b = 2;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[0].confidence, 'MEDIUM');
+    });
+
+    it('detects ours-is-superset as ADDITIVE with MEDIUM confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'const x = 10;\nconst y = 20;',
+        theirs: 'const x = 10;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[0].confidence, 'MEDIUM');
+    });
+
+  });
+
+  // ─── DIVERGENT classification ────────────────────────────────────────────────
+
+  describe('DIVERGENT classification', () => {
+
+    it('detects both-sides-different as DIVERGENT with LOW confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'const mode = "dark";',
+        theirs: 'const mode = "light";',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'DIVERGENT');
+      assert.equal(result[0].confidence, 'LOW');
+    });
+
+    it('marks DIVERGENT hunks as ambiguous when neither is superset', () => {
+      const content = buildConflictFile([{
+        ours: 'const timeout = 3000;',
+        theirs: 'const timeout = 5000;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'DIVERGENT');
+      assert.equal(result[0].ambiguous, true);
+    });
+
+    it('upgrades DIVERGENT to MEDIUM confidence with plan context', () => {
+      const content = buildConflictFile([{
+        ours: 'const retries = 3;',
+        theirs: 'const retries = 5;',
+      }]);
+      const planContext = [
+        { task_name: 'Update retry config', action_excerpt: 'Changed retry count' },
+      ];
+      const result = classifyConflictHunks(content, planContext);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'DIVERGENT');
+      assert.equal(result[0].confidence, 'MEDIUM');
+    });
+
+  });
+
+  // ─── STRUCTURAL classification ───────────────────────────────────────────────
+
+  describe('STRUCTURAL classification', () => {
+
+    it('detects function signature conflicts as STRUCTURAL with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'function processData(input) {',
+        theirs: 'function processData(input, options) {',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'STRUCTURAL');
+      assert.equal(result[0].confidence, 'HIGH');
+    });
+
+    it('detects import/require conflicts as STRUCTURAL with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: "const utils = require('./utils.cjs');",
+        theirs: "const utils = require('./utils-v2.cjs');",
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'STRUCTURAL');
+      assert.equal(result[0].confidence, 'HIGH');
+    });
+
+    it('detects module.exports conflicts as STRUCTURAL with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'module.exports = { foo };',
+        theirs: 'module.exports = { foo, bar };',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'STRUCTURAL');
+      assert.equal(result[0].confidence, 'HIGH');
+    });
+
+    it('detects class declaration conflicts as STRUCTURAL with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'class Parser extends BaseParser {',
+        theirs: 'class Parser extends EnhancedParser {',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'STRUCTURAL');
+      assert.equal(result[0].confidence, 'HIGH');
+    });
+
+    it('detects one-side structural as STRUCTURAL with MEDIUM confidence', () => {
+      const content = buildConflictFile([{
+        ours: "const helper = require('./helper.cjs');",
+        theirs: 'const value = 42;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'STRUCTURAL');
+      assert.equal(result[0].confidence, 'MEDIUM');
+    });
+
+  });
+
+  // ─── DELETION classification ─────────────────────────────────────────────────
+
+  describe('DELETION classification', () => {
+
+    it('detects theirs-empty as DELETION with HIGH confidence', () => {
+      const content = buildConflictFile([{
+        ours: 'const legacy = true;',
+        theirs: '',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'DELETION');
+      assert.equal(result[0].confidence, 'HIGH');
+    });
+
+    it('provides reasoning for DELETION', () => {
+      const content = buildConflictFile([{
+        ours: 'const deprecated = "old";',
+        theirs: '',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.equal(result[0].type, 'DELETION');
+      assert.ok(result[0].reasoning.length > 0, 'reasoning should be non-empty');
+    });
+
+  });
+
+  // ─── Ambiguity detection ─────────────────────────────────────────────────────
+
+  describe('ambiguity detection', () => {
+
+    it('flags ambiguous when classification is uncertain (DIVERGENT)', () => {
+      const content = buildConflictFile([{
+        ours: 'const color = "red";',
+        theirs: 'const color = "blue";',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result[0].ambiguous, true);
+    });
+
+    it('does not flag unambiguous ADDITIVE hunks', () => {
+      const content = buildConflictFile([{
+        ours: '',
+        theirs: 'const added = true;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result[0].ambiguous, false);
+    });
+
+    it('does not flag unambiguous STRUCTURAL hunks', () => {
+      const content = buildConflictFile([{
+        ours: 'function foo() {',
+        theirs: 'function foo(arg) {',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result[0].ambiguous, false);
+    });
+
+  });
+
+  // ─── Plan context enhancement ────────────────────────────────────────────────
+
+  describe('plan context enhancement', () => {
+
+    it('enhances ADDITIVE confidence to HIGH with matching plan context', () => {
+      const content = buildConflictFile([{
+        ours: 'const base = 1;',
+        theirs: 'const base = 1;\nconst extra = 2;',
+      }]);
+      // Without context: ADDITIVE MEDIUM (superset)
+      const withoutCtx = classifyConflictHunks(content, null);
+      assert.equal(withoutCtx[0].type, 'ADDITIVE');
+      assert.equal(withoutCtx[0].confidence, 'MEDIUM');
+
+      // With context matching additive intent: confidence upgraded
+      const planContext = [
+        { task_name: 'Add extra config', action_excerpt: 'create new configuration options' },
+      ];
+      const withCtx = classifyConflictHunks(content, planContext);
+      assert.equal(withCtx[0].type, 'ADDITIVE');
+      assert.equal(withCtx[0].confidence, 'HIGH');
+    });
+
+    it('enhances DIVERGENT confidence to MEDIUM with any plan context', () => {
+      const content = buildConflictFile([{
+        ours: 'const limit = 100;',
+        theirs: 'const limit = 200;',
+      }]);
+      const withoutCtx = classifyConflictHunks(content, null);
+      assert.equal(withoutCtx[0].confidence, 'LOW');
+
+      const planContext = [
+        { task_name: 'Increase limits', action_excerpt: 'bump limit values' },
+      ];
+      const withCtx = classifyConflictHunks(content, planContext);
+      assert.equal(withCtx[0].confidence, 'MEDIUM');
+    });
+
+    it('returns results without enhancement when planContext is null', () => {
+      const content = buildConflictFile([{
+        ours: '',
+        theirs: 'const fresh = true;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[0].confidence, 'HIGH');
+      assert.ok(!result[0].reasoning.includes('Plan context'));
+    });
+
+    it('returns results without enhancement when planContext is empty array', () => {
+      const content = buildConflictFile([{
+        ours: '',
+        theirs: 'const fresh = true;',
+      }]);
+      const result = classifyConflictHunks(content, []);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[0].confidence, 'HIGH');
+      assert.ok(!result[0].reasoning.includes('Plan context'));
+    });
+
+  });
+
+  // ─── Edge cases ──────────────────────────────────────────────────────────────
+
+  describe('edge cases', () => {
+
+    it('returns empty array for file with no conflict markers', () => {
+      const content = '// normal file\nconst x = 1;\n';
+      const result = classifyConflictHunks(content, null);
+      assert.deepEqual(result, []);
+    });
+
+    it('handles multiple conflict hunks in one file', () => {
+      const content = buildConflictFile([
+        { ours: '', theirs: 'const newA = 1;' },
+        { ours: 'const val = "x";', theirs: 'const val = "y";' },
+        { ours: 'function run() {', theirs: 'function run(opts) {' },
+      ]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 3);
+      assert.equal(result[0].type, 'ADDITIVE');
+      assert.equal(result[1].type, 'DIVERGENT');
+      assert.equal(result[2].type, 'STRUCTURAL');
+    });
+
+    it('returns start_line and end_line for each hunk', () => {
+      const content = buildConflictFile([{
+        ours: 'line1',
+        theirs: 'line2',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result.length, 1);
+      assert.ok(typeof result[0].start_line === 'number');
+      assert.ok(typeof result[0].end_line === 'number');
+      assert.ok(result[0].start_line > 0);
+      assert.ok(result[0].end_line >= result[0].start_line);
+    });
+
+    it('preserves ours and theirs content in output', () => {
+      const content = buildConflictFile([{
+        ours: 'const a = 1;',
+        theirs: 'const a = 2;',
+      }]);
+      const result = classifyConflictHunks(content, null);
+      assert.equal(result[0].ours, 'const a = 1;');
+      assert.equal(result[0].theirs, 'const a = 2;');
+    });
+
+    it('handles empty file content', () => {
+      const result = classifyConflictHunks('', null);
+      assert.deepEqual(result, []);
+    });
+
+    it('includes reasoning string in every classified hunk', () => {
+      const content = buildConflictFile([
+        { ours: '', theirs: 'new code' },
+        { ours: 'old', theirs: '' },
+        { ours: 'x', theirs: 'y' },
+      ]);
+      const result = classifyConflictHunks(content, null);
+      for (const hunk of result) {
+        assert.ok(typeof hunk.reasoning === 'string');
+        assert.ok(hunk.reasoning.length > 0, `reasoning for ${hunk.type} should be non-empty`);
+      }
+    });
+
+  });
+
+});