@gitwand/core - npm Package Compare versions

Comparing version

2.8.2

2.8.4

+37

dist/__tests__/bench/congra-mini.test.d.ts

		/**
		* v2.5 — ConGra-mini regression bench.
		*
		* Loads ~15 hand-crafted `complex` conflicts under
		* `__tests__/fixtures/congra-mini/`, feeds each to `resolveAsync()` with the
		* LLM fallback enabled and a deterministic mock endpoint, then tallies the
		* resolution outcome.
		*
		* ## Done criterion (CORE-V2-ROADMAP v2.5)
		*
		* > "résout au moins 80 % des hunks `complex` du ConGra-mini sans régression
		* > sur le reste"
		*
		* The test fails if `successRate < 0.80`. We do NOT lower the threshold when
		* a fixture regresses — that's the whole point of locking the bench. If a
		* fixture becomes unrealistic for the deterministic+LLM pipeline, either
		* fix the pipeline or replace the fixture; do not move the goalposts.
		*
		* ## Why `validationLevel: "off"`
		*
		* Tree-sitter grammars are not loaded in unit tests (the bench runs without
		* `web-tree-sitter` peer or grammar WASMs). Parse-tree validation would
		* therefore always return `null` and is irrelevant to what we're measuring
		* here — namely, the LLM fallback's hit rate.
		*
		* ## Why a normal `describe` and not Vitest's `bench`
		*
		* We are measuring a hit rate, not throughput. A real bench (`bench(...)`)
		* would re-run the same workload many times and report ops/s — useless here.
		* The file is named `*.bench.ts` to keep it co-located with the other
		* regression-style benches, but it lives in the standard test suite so CI
		* runs it on every push.
		*
		* Use `SKIP_BENCH=true pnpm test` to skip the suite in fast iterations.
		*/
		export {};
		//# sourceMappingURL=congra-mini.test.d.ts.map

+1

dist/__tests__/bench/congra-mini.test.d.ts.map

{"version":3,"file":"congra-mini.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/bench/congra-mini.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG"}

+187

dist/__tests__/bench/congra-mini.test.js

		/**
		* v2.5 — ConGra-mini regression bench.
		*
		* Loads ~15 hand-crafted `complex` conflicts under
		* `__tests__/fixtures/congra-mini/`, feeds each to `resolveAsync()` with the
		* LLM fallback enabled and a deterministic mock endpoint, then tallies the
		* resolution outcome.
		*
		* ## Done criterion (CORE-V2-ROADMAP v2.5)
		*
		* > "résout au moins 80 % des hunks `complex` du ConGra-mini sans régression
		* > sur le reste"
		*
		* The test fails if `successRate < 0.80`. We do NOT lower the threshold when
		* a fixture regresses — that's the whole point of locking the bench. If a
		* fixture becomes unrealistic for the deterministic+LLM pipeline, either
		* fix the pipeline or replace the fixture; do not move the goalposts.
		*
		* ## Why `validationLevel: "off"`
		*
		* Tree-sitter grammars are not loaded in unit tests (the bench runs without
		* `web-tree-sitter` peer or grammar WASMs). Parse-tree validation would
		* therefore always return `null` and is irrelevant to what we're measuring
		* here — namely, the LLM fallback's hit rate.
		*
		* ## Why a normal `describe` and not Vitest's `bench`
		*
		* We are measuring a hit rate, not throughput. A real bench (`bench(...)`)
		* would re-run the same workload many times and report ops/s — useless here.
		* The file is named `*.bench.ts` to keep it co-located with the other
		* regression-style benches, but it lives in the standard test suite so CI
		* runs it on every push.
		*
		* Use `SKIP_BENCH=true pnpm test` to skip the suite in fast iterations.
		*/
		import { describe, it, expect } from "vitest";
		import { readFileSync, readdirSync, statSync } from "node:fs";
		import { join, dirname } from "node:path";
		import { fileURLToPath } from "node:url";
		import { resolveAsync } from "../../resolver/index.js";
		import { buildMockEndpoint, fenced } from "../utils/mock-llm-endpoint.js";
		const __dirname = dirname(fileURLToPath(import.meta.url));
		const FIXTURES_ROOT = join(__dirname, "..", "fixtures", "congra-mini");
		/**
		* Extract a unique substring of the first conflict's `ours` block. We grab
		* the first non-empty line after `<<<<<<< ours` — that's enough to
		* disambiguate fixtures whose conflict markers are unique per fixture.
		*/
		function extractOursSnippet(conflict) {
		const lines = conflict.split("\n");
		const start = lines.findIndex((l) => l.startsWith("<<<<<<<"));
		if (start === -1)
		return "";
		const end = lines.findIndex((l, i) => i > start && (l.startsWith("\|\|\|\|\|\|\|") \|\| l.startsWith("=======")));
		const ours = lines.slice(start + 1, end === -1 ? lines.length : end);
		return ours.find((l) => l.trim().length > 0) ?? ours.join("\n");
		}
		function loadFixtures() {
		const entries = readdirSync(FIXTURES_ROOT).filter((n) => {
		const p = join(FIXTURES_ROOT, n);
		return statSync(p).isDirectory();
		});
		return entries.sort().map((name) => {
		const dir = join(FIXTURES_ROOT, name);
		const conflict = readFileSync(join(dir, "conflict.txt"), "utf-8");
		const expectedResolution = readFileSync(join(dir, "expected-llm-resolution.txt"), "utf-8");
		const meta = JSON.parse(readFileSync(join(dir, "meta.json"), "utf-8"));
		return {
		name,
		conflict,
		expectedResolution,
		meta,
		oursSnippet: extractOursSnippet(conflict),
		};
		});
		}
		function classifyOutcome(fixture, result) {
		const firstHunk = result.hunks[0];
		const firstResolution = result.resolutions[0];
		if (!firstHunk \|\| !firstResolution) {
		return {
		fixture,
		outcome: "unresolved",
		decisionType: "no-hunk",
		reason: "no conflict parsed",
		};
		}
		// Resolved by the LLM fallback → success.
		if (firstHunk.type === "llm_proposed" && firstResolution.autoResolved) {
		return {
		fixture,
		outcome: "llm-resolved",
		decisionType: firstHunk.type,
		validationScore: firstHunk.trace.llmTrace?.validationScore,
		reason: firstResolution.resolutionReason,
		};
		}
		// Resolved by a deterministic pattern before the LLM ran → does NOT count
		// toward LLM success (the fixture was supposed to be `complex`).
		if (firstResolution.autoResolved) {
		return {
		fixture,
		outcome: "deterministic-resolved",
		decisionType: firstHunk.type,
		reason: firstResolution.resolutionReason,
		};
		}
		return {
		fixture,
		outcome: "unresolved",
		decisionType: firstHunk.type,
		validationScore: firstHunk.trace.llmTrace?.validationScore,
		reason: firstResolution.resolutionReason,
		};
		}
		// ─── Suite ───────────────────────────────────────────────
		const SKIP = process.env.SKIP_BENCH === "true";
		describe.skipIf(SKIP)("ConGra-mini — LLM fallback regression bench", () => {
		const fixtures = loadFixtures();
		it("loads exactly 15 fixtures", () => {
		expect(fixtures.length).toBe(15);
		});
		it("each fixture parses one or more conflict hunks", () => {
		for (const f of fixtures) {
		expect(f.conflict).toContain("<<<<<<<");
		expect(f.conflict).toContain("=======");
		expect(f.conflict).toContain(">>>>>>>");
		expect(f.oursSnippet.length).toBeGreaterThan(0);
		}
		});
		it("resolves ≥ 80 % of complex hunks via the LLM fallback", async () => {
		// Build a single mock endpoint that knows every fixture's expected
		// resolution. The endpoint matches by ours-snippet substring (see
		// mock-llm-endpoint.ts).
		const responses = new Map();
		for (const f of fixtures) {
		responses.set(f.oursSnippet, fenced(f.expectedResolution));
		}
		const endpoint = buildMockEndpoint(responses);
		const results = [];
		for (const f of fixtures) {
		const merge = await resolveAsync(f.conflict, f.meta.filePath, {
		llmFallback: {
		enabled: true,
		endpoint,
		minPostMergeScore: 80,
		contextLines: 50,
		},
		// Tree-sitter is unavailable in unit-test env — disable parse-tree
		// validation. The LLM resolver still runs `validateMergedContent`
		// (residual markers + JSON/YAML/TOML syntax).
		validationLevel: "off",
		});
		results.push(classifyOutcome(f, merge));
		}
		// Per-fixture log (one line each) + summary.
		const lines = [];
		for (const r of results) {
		const symbol = r.outcome === "llm-resolved" ? "✓"
		: r.outcome === "deterministic-resolved" ? "·"
		: "✗";
		const score = r.validationScore !== undefined ? ` score=${r.validationScore}` : "";
		lines.push(` ${symbol} [${r.fixture.meta.category}/${r.fixture.meta.difficulty}] ${r.fixture.name} → ${r.decisionType}${score}`);
		}
		const llmResolved = results.filter((r) => r.outcome === "llm-resolved").length;
		const deterministic = results.filter((r) => r.outcome === "deterministic-resolved").length;
		const unresolved = results.filter((r) => r.outcome === "unresolved").length;
		const total = results.length;
		const successRate = llmResolved / total;
		const summary = [
		"",
		"ConGra-mini bench summary:",
		...lines,
		"",
		` Total fixtures : ${total}`,
		` LLM-resolved : ${llmResolved} (${(successRate * 100).toFixed(1)} %)`,
		` Deterministic-resolved: ${deterministic} (regressions — expected to be complex)`,
		` Unresolved : ${unresolved}`,
		` Target : ≥ 80 % LLM-resolved`,
		"",
		].join("\n");
		// eslint-disable-next-line no-console
		console.log(summary);
		expect(successRate, `LLM fallback resolved ${llmResolved}/${total} = ${(successRate * 100).toFixed(1)} % (target ≥ 80 %).\n${summary}`).toBeGreaterThanOrEqual(0.8);
		});
		});
		//# sourceMappingURL=congra-mini.test.js.map

+1

dist/__tests__/bench/congra-mini.test.js.map

+44

dist/__tests__/utils/mock-llm-endpoint.d.ts

		/**
		* v2.5 — Mock LLM endpoint for deterministic bench / integration tests.
		*
		* `@gitwand/core` never makes a network call: it consumes an injected
		* `LlmEndpoint` whose `call(prompt)` returns the model output as a string.
		* For tests, we want a reproducible endpoint that returns a pre-recorded
		* response for each fixture without any randomness.
		*
		* ## Lookup strategy
		*
		* The pipeline serialises the conflict hunk (ours / base / theirs) verbatim
		* inside the prompt — so we can match a fixture by searching the prompt for
		* a unique substring. Two keys are supported, in order:
		*
		* 1. A literal `[FIXTURE: <name>]` marker injected by the caller (used by
		* future prompt builders that want explicit tagging).
		* 2. The `ours` snippet of the fixture — the prompt always contains the
		* ours block verbatim between `<<<<<<< ours` and `\|\|\|\|\|\|\| base` (or
		* `=======` for diff2). A unique substring of `oursLines` is therefore
		* enough to disambiguate.
		*
		* If neither match yields a hit, the endpoint returns the empty string —
		* which the pipeline treats as `CANNOT_RESOLVE` (lines: null, rejected).
		* This is the expected behaviour for "the LLM has nothing useful to say".
		*/
		import type { LlmEndpoint } from "../../types.js";
		/**
		* Build a deterministic mock endpoint that returns pre-recorded responses
		* keyed by a unique substring of the prompt.
		*
		* @param responses - Map of `lookupKey → rawResponseBody`. The raw response
		* is returned as-is to the pipeline, which then parses
		* fenced blocks / detects `CANNOT_RESOLVE` / etc.
		* Wrap the resolution in triple backticks like a real
		* LLM would.
		*/
		export declare function buildMockEndpoint(responses: Map<string, string>): LlmEndpoint;
		/**
		* Wrap a raw resolution body in a fenced code block, matching what a real
		* LLM would output. The pipeline's `parseResponse()` extracts the first
		* fenced block and uses it as the resolved lines.
		*/
		export declare function fenced(body: string): string;
		//# sourceMappingURL=mock-llm-endpoint.d.ts.map

+1

dist/__tests__/utils/mock-llm-endpoint.d.ts.map

{"version":3,"file":"mock-llm-endpoint.d.ts","sourceRoot":"","sources":["../../../src/__tests__/utils/mock-llm-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,WAAW,CAsBb;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3C"}

+67

dist/__tests__/utils/mock-llm-endpoint.js

		/**
		* v2.5 — Mock LLM endpoint for deterministic bench / integration tests.
		*
		* `@gitwand/core` never makes a network call: it consumes an injected
		* `LlmEndpoint` whose `call(prompt)` returns the model output as a string.
		* For tests, we want a reproducible endpoint that returns a pre-recorded
		* response for each fixture without any randomness.
		*
		* ## Lookup strategy
		*
		* The pipeline serialises the conflict hunk (ours / base / theirs) verbatim
		* inside the prompt — so we can match a fixture by searching the prompt for
		* a unique substring. Two keys are supported, in order:
		*
		* 1. A literal `[FIXTURE: <name>]` marker injected by the caller (used by
		* future prompt builders that want explicit tagging).
		* 2. The `ours` snippet of the fixture — the prompt always contains the
		* ours block verbatim between `<<<<<<< ours` and `\|\|\|\|\|\|\| base` (or
		* `=======` for diff2). A unique substring of `oursLines` is therefore
		* enough to disambiguate.
		*
		* If neither match yields a hit, the endpoint returns the empty string —
		* which the pipeline treats as `CANNOT_RESOLVE` (lines: null, rejected).
		* This is the expected behaviour for "the LLM has nothing useful to say".
		*/
		/**
		* Build a deterministic mock endpoint that returns pre-recorded responses
		* keyed by a unique substring of the prompt.
		*
		* @param responses - Map of `lookupKey → rawResponseBody`. The raw response
		* is returned as-is to the pipeline, which then parses
		* fenced blocks / detects `CANNOT_RESOLVE` / etc.
		* Wrap the resolution in triple backticks like a real
		* LLM would.
		*/
		export function buildMockEndpoint(responses) {
		return {
		async call(prompt) {
		// First pass — explicit fixture tag (future-proof).
		const tagMatch = prompt.match(/\[FIXTURE: ([^\]]+)\]/);
		if (tagMatch) {
		const direct = responses.get(tagMatch[1]);
		if (direct !== undefined)
		return direct;
		}
		// Second pass — first key whose substring appears in the prompt wins.
		// The fixture loader stores the ours-snippet as the key, which the
		// pipeline serialises verbatim into the conflict block.
		for (const [key, response] of responses) {
		if (key && prompt.includes(key))
		return response;
		}
		// No match — return empty string. The pipeline treats this as
		// CANNOT_RESOLVE, leaving the hunk unresolved (audit trail kept).
		return "";
		},
		};
		}
		/**
		* Wrap a raw resolution body in a fenced code block, matching what a real
		* LLM would output. The pipeline's `parseResponse()` extracts the first
		* fenced block and uses it as the resolved lines.
		*/
		export function fenced(body) {
		return "```\n" + body + "\n```";
		}
		//# sourceMappingURL=mock-llm-endpoint.js.map

+1

dist/__tests__/utils/mock-llm-endpoint.js.map

{"version":3,"file":"mock-llm-endpoint.js","sourceRoot":"","sources":["../../../src/__tests__/utils/mock-llm-endpoint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAC/B,SAA8B;IAE9B,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,MAAc;YACvB,oDAAoD;YACpD,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;YACvD,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,IAAI,MAAM,KAAK,SAAS;oBAAE,OAAO,MAAM,CAAC;YAC1C,CAAC;YAED,sEAAsE;YACtE,mEAAmE;YACnE,wDAAwD;YACxD,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,SAAS,EAAE,CAAC;gBACxC,IAAI,GAAG,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;oBAAE,OAAO,QAAQ,CAAC;YACnD,CAAC;YAED,8DAA8D;YAC9D,kEAAkE;YAClE,OAAO,EAAE,CAAC;QACZ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,MAAM,CAAC,IAAY;IACjC,OAAO,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC;AAClC,CAAC"}

+1

-1

package.json

		{
		"name": "@gitwand/core",
		"version": "2.8.2",
		"version": "2.8.4",
		"description": "GitWand core — automatic Git conflict resolution engine (powers @gitwand/cli, @gitwand/mcp, and the GitWand desktop app)",
		@@ -5,0 +5,0 @@ "type": "module",

@gitwand/core - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics