@gitkraken/conflict-tools 0.2.3 → 0.2.4-beta.2

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- Reference-integrity detection. `resolveConflicts` now attaches a `StepResult.detection` report listing broken references (symbols that resolved in a pre-merge parent but no longer resolve in the merged result, with provenance), duplicate definitions, and syntax errors in the resolved files. Detection is opt-in via a new `ParserPort` (`ResolverDeps.parser`) that supplies parsing/symbol resolution per surface (tree-sitter, language server); when it is absent, unavailable, or a file's language is unsupported, the report says so rather than implying a clean result. Report-only in this release — no automatic fixing.
+- Auto-merged scope for reference-integrity detection: the detector discovers the merge's incoming/auto-merged set itself (new optional `changedFiles` git-port op; `git diff --name-only base..theirs`, base from `refs.base` or `mergeBase`) and includes it in scope, so dangling references in cleanly-merged files are caught. Scope is capped and reported via `DetectionReport.scope`; an optional `ResolutionContext.touchedFiles` overrides discovery. Adds a `dropped-side` finding when a whole-side take (take-ours/take-theirs/fallback) discards a substantial diff from the other side.
+
 ## [0.2.3] - 2026-07-06
 
 ### Added

package/dist/git/port-dispatch.d.ts

@@ -8,6 +8,7 @@ declare function mergeBase(git: ConflictGitPort, a: string, b: string, opts?: Op
 declare function blame(git: ConflictGitPort, path: string, opts?: BlameOptions): Promise<string>;
 declare function grep(git: ConflictGitPort, pattern: string, opts?: GrepOptions): Promise<string>;
 declare function diff(git: ConflictGitPort, from: string, to: string, opts?: ConflictDiffOptions): Promise<string>;
+declare function changedFiles(git: ConflictGitPort, from: string, to: string, opts?: OpOptions): Promise<string[]>;
 declare function log(git: ConflictGitPort, opts?: LogOptions): Promise<string>;
 declare function show(git: ConflictGitPort, sha: string, opts?: ShowOptions): Promise<string>;
 declare function writeFile(git: ConflictGitPort, path: string, content: string, opts?: OpOptions): Promise<void>;
@@ -15,4 +16,4 @@ declare function stageFiles(git: ConflictGitPort, paths: string[], opts?: OpOpti
 declare function checkoutFile(git: ConflictGitPort, path: string, side: 'ours' | 'theirs', opts?: OpOptions): Promise<void>;
 declare function removeFile(git: ConflictGitPort, path: string, opts?: OpOptions): Promise<void>;
 //#endregion
-export { blame, checkoutFile, diff, grep, log, mergeBase, readFile, removeFile, show, showFile, stageFiles, unmergedEntries, writeFile };
+export { blame, changedFiles, checkoutFile, diff, grep, log, mergeBase, readFile, removeFile, show, showFile, stageFiles, unmergedEntries, writeFile };

package/dist/git/port-dispatch.js

@@ -1,2 +1,3 @@
 import{ConflictGitPortMissingOpError as e}from"../ports/git.js";import{sliceLines as t,truncateLines as n,truncateMatches as r}from"./truncation.js";const i={DD:`both-deleted`,AU:`added-by-us`,UD:`deleted-by-them`,UA:`added-by-them`,DU:`deleted-by-us`,AA:`both-added`,UU:`both-modified`};function a(e){return i[e]??e}function o(e){return`Search capped at ${e} matches. There may be more — narrow with a more specific pattern or path.`}function s(t,n){throw new e(t,n)}function c(e,t){return e!=null&&t!=null?`startLine=${e}, endLine=${t}`:e==null?`endLine=${t}`:`startLine=${e}`}async function l(e,t,n){return e.readFile?e.readFile(t,n):s(`readFile`)}async function u(e,r,i,a){let o;if(e.showFile)o=await e.showFile(r,i,a);else if(e.exec){let n=t(await e.exec([`show`,`${r}:${i}`],{signal:a?.signal}),a?.startLine,a?.endLine);if(!n.ok)return n.reason===`invalid-range`?`[Invalid range: ${c(n.startLine,n.endLine)} (startLine must be <= endLine).]`:`[Range out of bounds: file has ${n.total} lines, requested ${c(n.startLine,n.endLine)}.]`;o=n.content}else return s(`showFile`);return n(o,1e3,`Output capped at 1000 lines. Use startLine/endLine to read other regions of the file.`)}async function d(e,t){if(e.unmergedEntries)return e.unmergedEntries(t);if(e.exec){let n=await e.exec([`status`,`--porcelain=v2`],{signal:t?.signal}),r=[];for(let e of n.split(`
-`)){if(!e.startsWith(`u `))continue;let t=e.split(` `),n=t[1]??``,i=t.slice(10).join(` `);r.push({path:i,reason:a(n)})}return r}return s(`unmergedEntries`)}async function f(e,t,n,r){return e.mergeBase?e.mergeBase(t,n,r):e.exec?(await e.exec([`merge-base`,`--`,t,n],{signal:r?.signal})).trim():s(`mergeBase`)}async function p(e,t,r){let i=r?.startLine,a=r?.endLine,o=Number.isFinite(i),l=Number.isFinite(a);if(o&&l&&i>a)return`[Invalid range: ${c(i,a)} (startLine must be <= endLine).]`;let u;if(e.blame)u=await e.blame(t,r);else if(e.exec){let n=[`blame`,`--porcelain`],s=o?Math.max(1,i):void 0,c=l?Math.max(1,a):void 0;s!=null&&c!=null?n.push(`-L`,`${s},${c}`):s==null?c!=null&&n.push(`-L`,`1,${c}`):n.push(`-L`,`${s},`),r?.ref&&n.push(r.ref),n.push(`--`,t),u=await e.exec(n,{signal:r?.signal})}else return s(`blame`);return n(u,1e3,`Output capped at 1000 lines. Use startLine/endLine to inspect other regions.`)}async function m(e,t,n){let i=n?.maxResults,a=i!=null&&Number.isFinite(i)?Math.min(Math.max(1,i),100):100,c;if(e.grep)c=await e.grep(t,n);else if(e.exec){let r=[`grep`,`-n`,`--`,t];n?.ref&&r.push(n.ref),c=await e.exec(r,{signal:n?.signal})}else return s(`grep`);return r(c,a,o(a))}async function h(e,t,n,r){if(e.diff)return e.diff(t,n,r);if(e.exec){let i=[`diff`,t,n];return r?.path&&i.push(`--`,r.path),e.exec(i,{signal:r?.signal})}return s(`diff`)}async function g(e,t){let r=t?.maxCount,i=r!=null&&Number.isFinite(r)?Math.min(Math.max(1,r),100):100,a;if(e.log)a=await e.log({...t,maxCount:i});else if(e.exec){let n=[`log`,`--oneline`,`-n`,String(i)];t?.ref&&n.push(t.ref),t?.path&&n.push(`--`,t.path),a=await e.exec(n,{signal:t?.signal})}else return s(`log`);return n(a,100,`Output capped at 100 commits. Use path to scope to a file or refine the ref range.`)}async function _(e,t,r){let i;if(e.show)i=await e.show(t,r);else if(e.exec){let n=[`show`,t];r?.path&&n.push(`--`,r.path),i=await e.exec(n,{signal:r?.signal})}else return s(`show`);return n(i,500,`Output capped at 500 lines. Use show_file_at_ref with startLine/endLine to read specific regions.`)}async function v(e,t,n,r){return e.writeFile?e.writeFile(t,n,r):s(`writeFile`)}async function y(e,t,n){if(e.stageFiles)return e.stageFiles(t,n);if(e.exec){await e.exec([`add`,`--`,...t],{signal:n?.signal});return}return s(`stageFiles`)}async function b(e,t,n,r){if(e.checkoutFile)return e.checkoutFile(t,n,r);if(e.exec){await e.exec([`checkout`,`--${n}`,`--`,t],{signal:r?.signal});return}return s(`checkoutFile`)}async function x(e,t,n){if(e.removeFile)return e.removeFile(t,n);if(e.exec){await e.exec([`rm`,`--`,t],{signal:n?.signal});return}return s(`removeFile`)}export{p as blame,b as checkoutFile,h as diff,m as grep,g as log,f as mergeBase,l as readFile,x as removeFile,_ as show,u as showFile,y as stageFiles,d as unmergedEntries,v as writeFile};
+`)){if(!e.startsWith(`u `))continue;let t=e.split(` `),n=t[1]??``,i=t.slice(10).join(` `);r.push({path:i,reason:a(n)})}return r}return s(`unmergedEntries`)}async function f(e,t,n,r){return e.mergeBase?e.mergeBase(t,n,r):e.exec?(await e.exec([`merge-base`,`--`,t,n],{signal:r?.signal})).trim():s(`mergeBase`)}async function p(e,t,r){let i=r?.startLine,a=r?.endLine,o=Number.isFinite(i),l=Number.isFinite(a);if(o&&l&&i>a)return`[Invalid range: ${c(i,a)} (startLine must be <= endLine).]`;let u;if(e.blame)u=await e.blame(t,r);else if(e.exec){let n=[`blame`,`--porcelain`],s=o?Math.max(1,i):void 0,c=l?Math.max(1,a):void 0;s!=null&&c!=null?n.push(`-L`,`${s},${c}`):s==null?c!=null&&n.push(`-L`,`1,${c}`):n.push(`-L`,`${s},`),r?.ref&&n.push(r.ref),n.push(`--`,t),u=await e.exec(n,{signal:r?.signal})}else return s(`blame`);return n(u,1e3,`Output capped at 1000 lines. Use startLine/endLine to inspect other regions.`)}async function m(e,t,n){let i=n?.maxResults,a=i!=null&&Number.isFinite(i)?Math.min(Math.max(1,i),100):100,c;if(e.grep)c=await e.grep(t,n);else if(e.exec){let r=[`grep`,`-n`,`--`,t];n?.ref&&r.push(n.ref),c=await e.exec(r,{signal:n?.signal})}else return s(`grep`);return r(c,a,o(a))}async function h(e,t,n,r){if(e.diff)return e.diff(t,n,r);if(e.exec){let i=[`diff`,t,n];return r?.path&&i.push(`--`,r.path),e.exec(i,{signal:r?.signal})}return s(`diff`)}async function g(e,t,n,r){return e.changedFiles?e.changedFiles(t,n,r):e.exec?(await e.exec([`diff`,`--name-only`,t,n],{signal:r?.signal})).split(`
+`).map(e=>e.trim()).filter(e=>e.length>0):s(`changedFiles`)}async function _(e,t){let r=t?.maxCount,i=r!=null&&Number.isFinite(r)?Math.min(Math.max(1,r),100):100,a;if(e.log)a=await e.log({...t,maxCount:i});else if(e.exec){let n=[`log`,`--oneline`,`-n`,String(i)];t?.ref&&n.push(t.ref),t?.path&&n.push(`--`,t.path),a=await e.exec(n,{signal:t?.signal})}else return s(`log`);return n(a,100,`Output capped at 100 commits. Use path to scope to a file or refine the ref range.`)}async function v(e,t,r){let i;if(e.show)i=await e.show(t,r);else if(e.exec){let n=[`show`,t];r?.path&&n.push(`--`,r.path),i=await e.exec(n,{signal:r?.signal})}else return s(`show`);return n(i,500,`Output capped at 500 lines. Use show_file_at_ref with startLine/endLine to read specific regions.`)}async function y(e,t,n,r){return e.writeFile?e.writeFile(t,n,r):s(`writeFile`)}async function b(e,t,n){if(e.stageFiles)return e.stageFiles(t,n);if(e.exec){await e.exec([`add`,`--`,...t],{signal:n?.signal});return}return s(`stageFiles`)}async function x(e,t,n,r){if(e.checkoutFile)return e.checkoutFile(t,n,r);if(e.exec){await e.exec([`checkout`,`--${n}`,`--`,t],{signal:r?.signal});return}return s(`checkoutFile`)}async function S(e,t,n){if(e.removeFile)return e.removeFile(t,n);if(e.exec){await e.exec([`rm`,`--`,t],{signal:n?.signal});return}return s(`removeFile`)}export{p as blame,g as changedFiles,x as checkoutFile,h as diff,m as grep,_ as log,f as mergeBase,l as readFile,S as removeFile,v as show,u as showFile,b as stageFiles,d as unmergedEntries,y as writeFile};

package/dist/index.d.ts

@@ -9,7 +9,10 @@ import { extractConflict } from "./extraction/extract.js";
 import { checkoutFile, removeFile, show } from "./git/port-dispatch.js";
 import { ToolCall, ToolDefinition, ToolResult } from "./types/tool.js";
 import { ConflictModelMessage, ConflictModelParams, ConflictModelPort, ConflictModelResult, ResolverConfig } from "./ports/model.js";
+import { ParsedFile, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue } from "./ports/parser.js";
 import { ResolutionVerifier, VerificationResult, defaultVerifier } from "./ports/verify.js";
+import { CheckStatus, DetectionReport, Finding, FindingCategory, FindingTier } from "./types/findings.js";
+import { DetectDeps, detect } from "./reference-integrity/detect.js";
 import { createResolution } from "./resolution/create-resolution.js";
 import { takeOurs, takeTheirs } from "./resolution/take-strategy.js";
 import { applyResolutions } from "./resolver/apply-resolutions.js";
@@ -19,4 +22,4 @@ import { FileRule, StepConfig, StepResult } from "./types/step.js";
 import { resolveConflicts } from "./resolver/resolve-conflicts.js";
 import { OperationDigest, OperationSummary, ReviewItem } from "./types/summary.js";
 import { SummarizeOperationOptions, buildOperationDigest, summarizeOperation } from "./resolver/summarize-operation.js";
-export { AIError, type AIErrorCode, type BlameOptions, type Conflict, type ConflictDiffOptions, ConflictError, type ConflictErrorCode, type ConflictGitOps, type ConflictGitPort, ConflictGitPortMissingOpError, type ConflictMarker, type ConflictMarkerUserInput, type ConflictModelMessage, type ConflictModelParams, type ConflictModelPort, type ConflictModelResult, type ConflictProgressEvent, type ConflictType, type DiffStats, type FileRule, type GrepOptions, type IntraFileEditOp, type Issue, type LogOptions, type OpOptions, type OperationDigest, type OperationSummary, type Resolution, type ResolutionContext, type ResolutionMetrics, type ResolutionRawSignals, type ResolutionRefs, type ResolutionStrategy, type ResolutionVerifier, type ResolvedChunk, type ResolverConfig, type ReviewItem, type ShowFileOptions, type ShowOptions, type StepConfig, type StepResult, type SummarizeOperationOptions, type ThreeWayDiff, type ToolCall, type ToolDefinition, type ToolResult, type UnmergedEntry, type UnmergedReason, type VerificationResult, applyResolutions, buildOperationDigest, checkoutFile, createResolution, defaultVerifier, extractConflict, removeFile, resolveConflict, resolveConflicts, show, summarizeOperation, takeOurs, takeTheirs };
+export { AIError, type AIErrorCode, type BlameOptions, type CheckStatus, type Conflict, type ConflictDiffOptions, ConflictError, type ConflictErrorCode, type ConflictGitOps, type ConflictGitPort, ConflictGitPortMissingOpError, type ConflictMarker, type ConflictMarkerUserInput, type ConflictModelMessage, type ConflictModelParams, type ConflictModelPort, type ConflictModelResult, type ConflictProgressEvent, type ConflictType, type DetectDeps, type DetectionReport, type DiffStats, type FileRule, type Finding, type FindingCategory, type FindingTier, type GrepOptions, type IntraFileEditOp, type Issue, type LogOptions, type OpOptions, type OperationDigest, type OperationSummary, type ParsedFile, type ParserPort, type Resolution, type ResolutionContext, type ResolutionMetrics, type ResolutionRawSignals, type ResolutionRefs, type ResolutionStrategy, type ResolutionVerifier, type ResolvedChunk, type ResolverConfig, type ReviewItem, type ShowFileOptions, type ShowOptions, type SourceOverlay, type StepConfig, type StepResult, type SummarizeOperationOptions, type SymbolDefinition, type SymbolReference, type SyntaxIssue, type ThreeWayDiff, type ToolCall, type ToolDefinition, type ToolResult, type UnmergedEntry, type UnmergedReason, type VerificationResult, applyResolutions, buildOperationDigest, checkoutFile, createResolution, defaultVerifier, detect, extractConflict, removeFile, resolveConflict, resolveConflicts, show, summarizeOperation, takeOurs, takeTheirs };

package/dist/index.js

@@ -1 +1 @@
-import{AIError as e}from"./errors/ai.js";import{ConflictError as t}from"./errors/conflict.js";import{ConflictGitPortMissingOpError as n}from"./ports/git.js";import{checkoutFile as r,removeFile as i,show as a}from"./git/port-dispatch.js";import{extractConflict as o}from"./extraction/extract.js";import{defaultVerifier as s}from"./ports/verify.js";import{createResolution as c}from"./resolution/create-resolution.js";import{takeOurs as l,takeTheirs as u}from"./resolution/take-strategy.js";import{applyResolutions as d}from"./resolver/apply-resolutions.js";import{resolveConflict as f}from"./resolver/resolve-conflict.js";import{resolveConflicts as p}from"./resolver/resolve-conflicts.js";import{buildOperationDigest as m,summarizeOperation as h}from"./resolver/summarize-operation.js";export{e as AIError,t as ConflictError,n as ConflictGitPortMissingOpError,d as applyResolutions,m as buildOperationDigest,r as checkoutFile,c as createResolution,s as defaultVerifier,o as extractConflict,i as removeFile,f as resolveConflict,p as resolveConflicts,a as show,h as summarizeOperation,l as takeOurs,u as takeTheirs};
+import{AIError as e}from"./errors/ai.js";import{ConflictError as t}from"./errors/conflict.js";import{ConflictGitPortMissingOpError as n}from"./ports/git.js";import{checkoutFile as r,removeFile as i,show as a}from"./git/port-dispatch.js";import{extractConflict as o}from"./extraction/extract.js";import{defaultVerifier as s}from"./ports/verify.js";import{detect as c}from"./reference-integrity/detect.js";import{createResolution as l}from"./resolution/create-resolution.js";import{takeOurs as u,takeTheirs as d}from"./resolution/take-strategy.js";import{applyResolutions as f}from"./resolver/apply-resolutions.js";import{resolveConflict as p}from"./resolver/resolve-conflict.js";import{resolveConflicts as m}from"./resolver/resolve-conflicts.js";import{buildOperationDigest as h,summarizeOperation as g}from"./resolver/summarize-operation.js";export{e as AIError,t as ConflictError,n as ConflictGitPortMissingOpError,f as applyResolutions,h as buildOperationDigest,r as checkoutFile,l as createResolution,s as defaultVerifier,c as detect,o as extractConflict,i as removeFile,p as resolveConflict,m as resolveConflicts,a as show,g as summarizeOperation,u as takeOurs,d as takeTheirs};

package/dist/ports/git.d.ts

@@ -45,6 +45,11 @@ interface ConflictGitOps {
   showFile?: (ref: string, path: string, opts?: ShowFileOptions) => Promise<string>;
   unmergedEntries?: (opts?: OpOptions) => Promise<UnmergedEntry[]>;
   mergeBase?: (a: string, b: string, opts?: OpOptions) => Promise<string>;
+  /**
+   * Returns the paths changed between two refs (name-only). Used to discover the merge's
+   * incoming/auto-merged set for reference-integrity detection.
+   */
+  changedFiles?: (from: string, to: string, opts?: OpOptions) => Promise<string[]>;
   /**
    * Returns line-by-line authorship for `path`. When `opts.startLine`/`endLine` are provided,
    * implementations should restrict to that 1-indexed inclusive range. The library does not

package/dist/ports/parser.d.ts

@@ -0,0 +1,51 @@
+//#region src/ports/parser.d.ts
+/** File contents to analyze, keyed by path. The analyzer treats these as the authoritative content
+ *  for those paths (an overlay): a tree-sitter backend sees only these files, while a language server
+ *  may resolve against its workspace with these contents overlaid on top. */
+type SourceOverlay = ReadonlyMap<string, string>;
+interface SymbolDefinition {
+  name: string;
+  kind?: string;
+  /** 1-indexed. */
+  line: number;
+}
+interface SymbolReference {
+  name: string;
+  /** 1-indexed. */
+  line: number;
+  column?: number;
+  /** Whether the reference resolved to a definition reachable within the analyzed overlay. */
+  resolved: boolean;
+  target?: {
+    file: string;
+    line: number;
+  };
+}
+interface SyntaxIssue {
+  /** 1-indexed. */
+  line: number;
+  message: string;
+}
+/** Per-file parse result. `language` is `'unsupported'` when the backend cannot parse the file — the
+ *  detector then skips it rather than emitting false findings. */
+interface ParsedFile {
+  language: string;
+  definitions: SymbolDefinition[];
+  references: SymbolReference[];
+  syntaxErrors: SyntaxIssue[];
+}
+/**
+ * Parsing / symbol-resolution capability supplied per surface — merge-mate via tree-sitter,
+ * GitLens/GKD via a language server. The detector stays free of any parser dependency; the port
+ * abstracts the precision difference between backends.
+ */
+interface ParserPort {
+  /**
+   * Parse and resolve every file in `sources`, treating those contents as authoritative for their
+   * paths. Returns one {@link ParsedFile} per input path. Works only from the provided content — it
+   * never reads the filesystem itself.
+   */
+  analyze(sources: SourceOverlay): Promise<ReadonlyMap<string, ParsedFile>>;
+}
+//#endregion
+export { ParsedFile, ParserPort, SourceOverlay, SymbolDefinition, SymbolReference, SyntaxIssue };

package/dist/ports/parser.js

@@ -0,0 +1 @@
+export{};

package/dist/reference-integrity/detect.d.ts

@@ -0,0 +1,21 @@
+import { ConflictGitPort } from "../ports/git.js";
+import { Resolution, ResolutionContext } from "../types/resolution.js";
+import { ParserPort } from "../ports/parser.js";
+import { DetectionReport } from "../types/findings.js";
+
+//#region src/reference-integrity/detect.d.ts
+interface DetectDeps {
+  git: ConflictGitPort;
+  /** Parsing/symbol-resolution capability. When absent, detection is skipped and reported as such. */
+  parser?: ParserPort;
+  signal?: AbortSignal;
+}
+/**
+ * Deterministic post-resolution detection: flags references that resolved in a pre-merge parent
+ * (ours/theirs) but no longer resolve in the merged result, plus duplicate definitions and syntax
+ * errors in the resolved files. Report-only — it never mutates state or fails the operation. When no
+ * parser is supplied, or refs are missing, the report says so instead of implying a clean result.
+ */
+declare function detect(resolutions: Resolution[], context: ResolutionContext, deps: DetectDeps): Promise<DetectionReport>;
+//#endregion
+export { DetectDeps, detect };

package/dist/reference-integrity/detect.js

@@ -0,0 +1,3 @@
+import{buildSnapshots as e}from"./snapshot.js";async function t(t,r,o){let c=o.parser;if(!c)return{findings:[],checks:{referenceIntegrity:`skipped-no-parser`,structural:`skipped-no-parser`}};try{let l=r.refs?await e(t,r,o):null;if(l){let[e,r,o]=await Promise.all([c.analyze(l.ours),c.analyze(l.theirs),c.analyze(l.result)]);return{findings:[...n(e,r,o),...i(o),...a(t,l)],checks:{referenceIntegrity:s([e,r,o])?`partial-unsupported-language`:`ran`,structural:s([o])?`partial-unsupported-language`:`ran`},scope:{analyzed:l.analyzed,truncated:l.truncated}}}let u=new Map(t.map(e=>[e.filePath,e.content])),d=await c.analyze(u);return{findings:i(d),checks:{referenceIntegrity:`skipped-no-refs`,structural:s([d])?`partial-unsupported-language`:`ran`}}}catch{return{findings:[],checks:{referenceIntegrity:`errored`,structural:`errored`}}}}function n(e,t,n){let i=new Map;r(e,`ours`,i),r(t,`theirs`,i);let a=[];for(let[e,t]of n)for(let n of t.references){if(n.resolved)continue;let t=i.get(c(e,n.name));t&&a.push({category:`broken-reference`,severity:`error`,tier:`project`,location:{file:e,line:n.line,symbol:n.name},provenance:t,message:`Reference "${n.name}" resolved before the merge (on ${t.side}) but no longer resolves.`})}return a}function r(e,t,n){for(let[r,i]of e)for(let e of i.references){if(!e.resolved)continue;let i=c(r,e.name);n.has(i)||n.set(i,{side:t,line:e.line})}}function i(e){let t=[];for(let[n,r]of e){let e=new Map;for(let i of r.definitions){let r=e.get(i.name);r==null?e.set(i.name,i.line):t.push({category:`duplicate-definition`,severity:`error`,tier:`file`,location:{file:n,line:i.line,symbol:i.name},message:`Duplicate definition of "${i.name}" (also defined at line ${r}).`})}for(let e of r.syntaxErrors)t.push({category:`syntax-error`,severity:`error`,tier:`file`,location:{file:n,line:e.line},message:e.message})}return t}function a(e,t){let n=[];for(let r of e){let e=r.strategy===`take-ours`?`theirs`:r.strategy===`take-theirs`?`ours`:null;if(!e)continue;let i=(e===`ours`?t.ours:t.theirs).get(r.filePath);if(i==null)continue;let a=o(i,r.content);a<20||n.push({category:`dropped-side`,severity:`error`,tier:`file`,location:{file:r.filePath,line:1},message:`Resolution took "${r.strategy}" wholesale, discarding ~${a} line(s) of the ${e} side.`})}return n}function o(e,t){let n=new Set(t.split(`
+`)),r=0;for(let t of e.split(`
+`))t.trim()!==``&&!n.has(t)&&r++;return r}function s(e){return e.some(e=>{for(let t of e.values())if(t.language===`unsupported`)return!0;return!1})}function c(e,t){return JSON.stringify([e,t])}export{t as detect};

package/dist/reference-integrity/snapshot.d.ts

@@ -0,0 +1,29 @@
+import { ConflictGitPort } from "../ports/git.js";
+import { Resolution, ResolutionContext } from "../types/resolution.js";
+import { SourceOverlay } from "../ports/parser.js";
+
+//#region src/reference-integrity/snapshot.d.ts
+interface DetectionSnapshots {
+  ours: SourceOverlay;
+  theirs: SourceOverlay;
+  result: SourceOverlay;
+  /** Number of files actually included in the snapshots (after the cap). */
+  analyzed: number;
+  /** Whether the scope exceeded the cap and was truncated. */
+  truncated: boolean;
+}
+interface SnapshotDeps {
+  git: ConflictGitPort;
+  signal?: AbortSignal;
+}
+/**
+ * Builds the file-content overlays the detector compares: both pre-merge parents (read from git
+ * objects — no working tree needed) and the resolved result (in-memory resolutions overlaid on the
+ * surrounding files). Scope is the resolved files plus the merge's incoming/auto-merged set, which
+ * the detector discovers itself via the git port (`changedFiles(base, theirs)`), unless the consumer
+ * supplies `context.touchedFiles` as an override. Returns `null` when `context.refs` is absent — the
+ * before/after comparison is impossible without the parent refs.
+ */
+declare function buildSnapshots(resolutions: Resolution[], context: ResolutionContext, deps: SnapshotDeps): Promise<DetectionSnapshots | null>;
+//#endregion
+export { DetectionSnapshots, SnapshotDeps, buildSnapshots };

package/dist/reference-integrity/snapshot.js

@@ -0,0 +1 @@
+import{changedFiles as e,mergeBase as t,readFile as n,showFile as r}from"../git/port-dispatch.js";async function i(e,t,n){let r=t.refs;if(!r)return null;let i=n.signal?{signal:n.signal}:void 0,c=new Map(e.map(e=>[e.filePath,e.content])),l=t.touchedFiles??await a(n.git,r,i),u=[],d=new Set;for(let e of[...c.keys(),...l,...t.fileNeighbors??[]])d.has(e)||(d.add(e),u.push(e));let f=u.length>400,p=f?u.slice(0,400):u,m=new Map,h=new Map,g=new Map;for(let e of p){let t=await o(n.git,r.ours,e,i);t!=null&&m.set(e,t);let a=await o(n.git,r.theirs,e,i);a!=null&&h.set(e,a);let l=c.get(e);if(l!=null)g.set(e,l);else{let t=await s(n.git,e,i);t!=null&&g.set(e,t)}}return{ours:m,theirs:h,result:g,analyzed:p.length,truncated:f}}async function a(n,r,i){try{return await e(n,r.base??await t(n,r.ours,r.theirs,i),r.theirs,i)}catch{return[]}}async function o(e,t,n,i){try{return await r(e,t,n,i)}catch{return null}}async function s(e,t,r){try{return await n(e,t,r)}catch{return null}}export{i as buildSnapshots};

package/dist/resolver/deps.d.ts

@@ -1,5 +1,6 @@
 import { ConflictGitPort } from "../ports/git.js";
 import { ConflictModelPort, ResolverConfig } from "../ports/model.js";
+import { ParserPort } from "../ports/parser.js";
 import { ResolutionVerifier } from "../ports/verify.js";
 import { ConflictProgressEvent } from "../types/events.js";
 
@@ -11,6 +12,7 @@ interface ResolverDeps<C extends ResolverConfig = ResolverConfig> {
   onProgress?: (event: ConflictProgressEvent) => void;
   signal?: AbortSignal;
   verifier?: ResolutionVerifier;
+  parser?: ParserPort;
 }
 //#endregion
 export { ResolverDeps };

package/dist/resolver/resolve-conflicts.js

@@ -1 +1 @@
-import{AIError as e}from"../errors/ai.js";import{unmergedEntries as t}from"../git/port-dispatch.js";import{extractConflict as n}from"../extraction/extract.js";import{createResolution as r}from"../resolution/create-resolution.js";import{takeOurs as i,takeTheirs as a}from"../resolution/take-strategy.js";import{resolveConflict as o}from"./resolve-conflict.js";import s from"picomatch";function c(e){let t=e.map(e=>{let t=(Array.isArray(e.match)?e.match:[e.match]).map(e=>s(e,{basename:!e.includes(`/`)}));return{isMatch:e=>t.some(t=>t(e)),strategy:e.strategy}});return e=>{for(let{isMatch:n,strategy:r}of t)if(n(e))return r}}async function l(e,o){let s=e.config?.rules??[],l=e.config?.defaultStrategy??`ai`,f=c(s),p=await t(e.git,{signal:e.signal}),m={...o??{}},h=[],g=[],_=[];for(let t of p){if(e.signal?.aborted)break;let o=f(t.path)??l;if(o===`skip`){_.push({filePath:t.path,reason:`excluded`}),e.onProgress?.({type:`conflict:excluded`,filePath:t.path});continue}let s;try{s=await n(t.path,{git:e.git,signal:e.signal},t.reason)}catch(e){g.push({filePath:t.path,error:d(e)});continue}if(!s){_.push({filePath:t.path,reason:`no-markers`}),e.onProgress?.({type:`conflict:skipped`,filePath:t.path,reason:`no-markers`,entryReason:t.reason});continue}e.onProgress?.({type:`conflict:found`,filePath:s.filePath,conflictType:s.type,markerCount:s.markers.length});let c=null;c=o===`take-ours`?i(s):o===`take-theirs`?a(s):o===`deleted`?r(s,[],{confidence:1,fileStrategy:`deleted`}):await u(s,m,e,g),c&&(m.previousResolutions=[...m.previousResolutions??[],c],h.push(c),e.onProgress?.({type:`resolution:applied`,filePath:c.filePath,strategy:c.strategy,confidence:c.confidence,description:c.description}))}return{resolutions:h,errors:g,skipped:_}}async function u(t,n,r,s){try{return await o(t,n,{model:r.model,git:r.git,config:r.config,onProgress:r.onProgress,signal:r.signal,verifier:r.verifier})}catch(n){let o=d(n),c=r.config?.fallbackStrategy;return c?(r.onProgress?.({type:`resolution:fallback`,filePath:t.filePath,error:o,cause:o instanceof e?o.code:void 0}),{...c===`take-ours`?i(t):a(t),confidence:0}):(s.push({filePath:t.filePath,error:o}),r.onProgress?.({type:`resolution:failed`,filePath:t.filePath,error:o}),null)}}function d(e){return e instanceof Error?e:Error(String(e))}export{l as resolveConflicts};
+import{AIError as e}from"../errors/ai.js";import{unmergedEntries as t}from"../git/port-dispatch.js";import{extractConflict as n}from"../extraction/extract.js";import{detect as r}from"../reference-integrity/detect.js";import{createResolution as i}from"../resolution/create-resolution.js";import{takeOurs as a,takeTheirs as o}from"../resolution/take-strategy.js";import{resolveConflict as s}from"./resolve-conflict.js";import c from"picomatch";function l(e){let t=e.map(e=>{let t=(Array.isArray(e.match)?e.match:[e.match]).map(e=>c(e,{basename:!e.includes(`/`)}));return{isMatch:e=>t.some(t=>t(e)),strategy:e.strategy}});return e=>{for(let{isMatch:n,strategy:r}of t)if(n(e))return r}}async function u(e,s){let c=e.config?.rules??[],u=e.config?.defaultStrategy??`ai`,p=l(c),m=await t(e.git,{signal:e.signal}),h={...s??{}},g=[],_=[],v=[];for(let t of m){if(e.signal?.aborted)break;let r=p(t.path)??u;if(r===`skip`){v.push({filePath:t.path,reason:`excluded`}),e.onProgress?.({type:`conflict:excluded`,filePath:t.path});continue}let s;try{s=await n(t.path,{git:e.git,signal:e.signal},t.reason)}catch(e){_.push({filePath:t.path,error:f(e)});continue}if(!s){v.push({filePath:t.path,reason:`no-markers`}),e.onProgress?.({type:`conflict:skipped`,filePath:t.path,reason:`no-markers`,entryReason:t.reason});continue}e.onProgress?.({type:`conflict:found`,filePath:s.filePath,conflictType:s.type,markerCount:s.markers.length});let c=null;c=r===`take-ours`?a(s):r===`take-theirs`?o(s):r===`deleted`?i(s,[],{confidence:1,fileStrategy:`deleted`}):await d(s,h,e,_),c&&(h.previousResolutions=[...h.previousResolutions??[],c],g.push(c),e.onProgress?.({type:`resolution:applied`,filePath:c.filePath,strategy:c.strategy,confidence:c.confidence,description:c.description}))}return{resolutions:g,errors:_,skipped:v,detection:await r(g,h,{git:e.git,parser:e.parser,signal:e.signal})}}async function d(t,n,r,i){try{return await s(t,n,{model:r.model,git:r.git,config:r.config,onProgress:r.onProgress,signal:r.signal,verifier:r.verifier})}catch(n){let s=f(n),c=r.config?.fallbackStrategy;return c?(r.onProgress?.({type:`resolution:fallback`,filePath:t.filePath,error:s,cause:s instanceof e?s.code:void 0}),{...c===`take-ours`?a(t):o(t),confidence:0}):(i.push({filePath:t.filePath,error:s}),r.onProgress?.({type:`resolution:failed`,filePath:t.filePath,error:s}),null)}}function f(e){return e instanceof Error?e:Error(String(e))}export{u as resolveConflicts};

package/dist/types/findings.d.ts

@@ -0,0 +1,39 @@
+//#region src/types/findings.d.ts
+type FindingCategory = 'broken-reference' | 'duplicate-definition' | 'syntax-error' | 'dropped-side';
+type FindingTier = 'file' | 'project';
+interface Finding {
+  category: FindingCategory;
+  severity: 'error' | 'warning';
+  tier: FindingTier;
+  location: {
+    file: string;
+    line: number;
+    symbol?: string;
+  };
+  /** Present for `broken-reference`: the pre-merge side that still resolved the reference, and where. */
+  provenance?: {
+    side: 'ours' | 'theirs';
+    line: number;
+  };
+  message: string;
+}
+/** Why a check produced its result — lets a consumer tell "ran, clean" apart from "did not run".
+ *  `errored` means the parser was present but threw; `partial-unsupported-language` means some files
+ *  in scope could not be parsed. */
+type CheckStatus = 'ran' | 'skipped-no-parser' | 'skipped-no-refs' | 'partial-unsupported-language' | 'errored';
+interface DetectionReport {
+  findings: Finding[];
+  checks: {
+    referenceIntegrity: CheckStatus;
+    structural: CheckStatus;
+  };
+  /** How many files were analyzed and whether the scope was capped — an honest coverage signal so
+   *  empty findings on a truncated scope are not read as "clean". Present only when the reference
+   *  check ran (refs available). */
+  scope?: {
+    analyzed: number;
+    truncated: boolean;
+  };
+}
+//#endregion
+export { CheckStatus, DetectionReport, Finding, FindingCategory, FindingTier };

package/dist/types/findings.js

@@ -0,0 +1 @@
+export{};

package/dist/types/resolution.d.ts

@@ -69,6 +69,10 @@ interface ResolutionContext {
   prDescription?: string;
   previousResolutions?: Resolution[];
   fileNeighbors?: string[];
+  /** Files the merge/sync touched beyond the conflict set (chiefly auto-merged incoming changes).
+   *  Usually left unset — the reference-integrity detector discovers this set itself from `refs`.
+   *  When provided, it overrides auto-discovery and defines the incoming detection scope. */
+  touchedFiles?: string[];
   refs?: ResolutionRefs;
   threeWayDiff?: ThreeWayDiff;
   /** Free-text guidance from the user that applies to the whole file ("prefer logging across the

package/dist/types/step.d.ts

@@ -1,5 +1,6 @@
 import { Resolution } from "./resolution.js";
 import { ResolverConfig } from "../ports/model.js";
+import { DetectionReport } from "./findings.js";
 
 //#region src/types/step.d.ts
 interface StepResult {
@@ -12,6 +13,7 @@ interface StepResult {
     filePath: string;
     reason: string;
   }[];
+  detection?: DetectionReport;
 }
 interface FileRule {
   match: string | string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitkraken/conflict-tools",
-  "version": "0.2.3",
+  "version": "0.2.4-beta.2",
   "description": "AI-powered git conflict resolution.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Axosoft, LLC dba GitKraken",