@gitkraken/conflict-tools 0.2.4-beta.8 → 0.3.0

package/dist/resolver/summarize-operation.js

@@ -1 +1 @@
-import{buildSummaryPrompt as e}from"./prompt.js";const t=.8;function n(e,n=t){let a={ai:0,"take-ours":0,"take-theirs":0,deleted:0,skipped:0},o=0,s=null,c=new Map;for(let t of e.resolutions)a[t.strategy]++,o+=t.chunks?.length??0,s=s===null?t.confidence:Math.min(s,t.confidence),t.confidence<n&&c.set(t.filePath,{filePath:t.filePath,confidence:t.confidence,reason:`low-confidence`});let l=e.detection,u=l?.findings??[],d=new Map;for(let e of u){if(e.severity!==`error`)continue;let t=d.get(e.location.file)??new Set;t.add(e.category),d.set(e.location.file,t)}for(let[e,t]of d){let n=c.get(e);c.set(e,{filePath:e,...n?.confidence==null?{}:{confidence:n.confidence},reason:`finding`,findingCategories:[...t].sort()})}let f=[...c.values()].sort(r),p=l!=null&&l.checks.referenceIntegrity===`ran`&&l.checks.structural===`ran`,m=i({hasErrorFinding:d.size>0,hasWarningFinding:u.some(e=>e.severity===`warning`),needsReview:f.length>0,detectionComplete:p,hasErrors:e.errors.length>0});return{files:e.resolutions.length,conflicts:o,byStrategy:a,minConfidence:s,needsReview:f,skipped:e.skipped?.length??0,errors:e.errors.length,detectionComplete:p,findingCount:u.length,verdict:m}}function r(e,t){return e.reason===t.reason?(e.confidence??1)-(t.confidence??1):e.reason===`finding`?-1:1}function i(e){return e.hasErrorFinding?`blocked`:e.needsReview||!e.detectionComplete||e.hasErrors||e.hasWarningFinding?`needs-review`:`clean`}async function a(r,i={}){let a=n(r,i.reviewThreshold??t);if(!i.model)return{digest:a};let{system:o,userMessage:s}=e(r,a),c=await i.model.generate({system:o,messages:[{role:`user`,content:s}],temperature:i.temperature??0,signal:i.signal}),l=c.text?.trim();return{digest:a,...l?{prose:l}:{},...c.usage?{usage:c.usage}:{}}}export{n as buildOperationDigest,a as summarizeOperation};
+import{buildSummaryPrompt as e}from"./prompt.js";const t=.8;function n(e,n=t){let s={ai:0,"take-ours":0,"take-theirs":0,deleted:0,skipped:0},c=0,l=null,u=new Map;for(let t of e.resolutions)s[t.strategy]++,c+=t.chunks?.length??0,l=l===null?t.confidence:Math.min(l,t.confidence),t.confidence<n&&u.set(t.filePath,{filePath:t.filePath,confidence:t.confidence,reason:`low-confidence`});let d=e.detection,f=d?.findings??[],p=new Map,m=!1;for(let e of f){e.severity===`error`&&(m=!0);let t=p.get(e.location.file)??new Set;t.add(e.category),p.set(e.location.file,t)}for(let[e,t]of p){let n=u.get(e);u.set(e,{filePath:e,...n?.confidence==null?{}:{confidence:n.confidence},reason:`finding`,findingCategories:[...t].sort()})}for(let t of e.skipped??[])t.reason!==`excluded`&&(u.has(t.filePath)||u.set(t.filePath,{filePath:t.filePath,reason:`unresolved`}));let h=[...u.values()].sort(a),g=d!=null&&r(d.checks.referenceIntegrity)&&r(d.checks.structural)&&i(d.scope),_=o({hasErrorFinding:m,hasWarningFinding:f.some(e=>e.severity===`warning`),needsReview:h.length>0,detectionComplete:g,hasResolutionErrors:e.errors.length>0});return{files:e.resolutions.length,conflicts:c,byStrategy:s,minConfidence:l,needsReview:h,skipped:e.skipped?.length??0,errors:e.errors.length,detectionComplete:g,findingCount:f.length,verdict:_}}function r(e){return e===`ran`||e===`partial-unsupported-language`}function i(e){return e?!e.truncated&&e.incomingDiscovered:!0}function a(e,t){return e.reason===t.reason?(e.confidence??1)-(t.confidence??1):e.reason===`finding`?-1:1}function o(e){return e.hasErrorFinding?`blocked`:e.needsReview||!e.detectionComplete||e.hasResolutionErrors||e.hasWarningFinding?`needs-review`:`clean`}async function s(r,i={}){let a=n(r,i.reviewThreshold??t);if(!i.model)return{digest:a};let{system:o,userMessage:s}=e(r,a),c=await i.model.generate({system:o,messages:[{role:`user`,content:s}],temperature:i.temperature??0,signal:i.signal}),l=c.text?.trim();return{digest:a,...l?{prose:l}:{},...c.usage?{usage:c.usage}:{}}}export{n as buildOperationDigest,s as summarizeOperation};

package/dist/resolver/validate.js

@@ -1,2 +1,2 @@
-const e=[/^<{7}(\s|$)/,/^\|{7}(\s|$)/,/^={7}(\s|$)/,/^>{7}(\s|$)/];function t(t,n){let r=[],i=n.markers.length,a=new Set;for(let e of t)a.has(e.markerIndex)&&r.push(`Duplicate markerIndex ${e.markerIndex}.`),a.add(e.markerIndex);for(let e=0;e<i;e++)n.markers[e]?.userResolution??(a.has(e)||r.push(`Missing resolution for marker ${e}.`));for(let n of t)if(n.strategy===`merged`){let t=n.content.split(`
+import{CONFLICT_MARKER_PATTERNS as e}from"../validation/markers.js";function t(t,n){let r=[],i=n.markers.length,a=new Set;for(let e of t)a.has(e.markerIndex)&&r.push(`Duplicate markerIndex ${e.markerIndex}.`),a.add(e.markerIndex);for(let e=0;e<i;e++)n.markers[e]?.userResolution??(a.has(e)||r.push(`Missing resolution for marker ${e}.`));for(let n of t)if(n.strategy===`merged`){let t=n.content.split(`
 `);for(let i of t)for(let t of e)t.test(i)&&r.push(`Marker ${n.markerIndex}: resolved content contains conflict marker "${i.trim()}".`)}return r.length===0?{valid:!0}:{valid:!1,issues:r.map(e=>({severity:`error`,message:e}))}}export{t as validateChunks};

package/dist/types/events.d.ts

@@ -1,6 +1,5 @@
 import { ResolutionStrategy, ResolvedChunk } from "./resolution.js";
 import { ConflictType } from "./conflict.js";
-import { Issue } from "./issue.js";
 import { AiTokenUsage } from "@gitkraken/shared-tools";
 
 //#region src/types/events.d.ts
@@ -91,14 +90,42 @@ type ConflictProgressEvent = {
   type: 'refine:failed';
   filePath: string;
   reason: string;
+} | {
+  type: 'refine:bailed';
+  filePath: string;
+  reason: string;
 } | {
   type: 'refine:touched-user-region';
   filePath: string;
   markerIndexes: number[];
 } | {
-  type: 'verification:issues';
+  type: 'fix:started';
+  filePath: string;
+  findingCount: number;
+}
+/** `iterations` counts refine rounds actually run for this file (0 = evaluated, nothing spent).
+ *  `remainingFindings` is the error findings still standing — named apart from the model-call budget's
+ *  `remaining`, which the sibling `fix:budget-exhausted` reports as `spent`/`limit`. */
+| {
+  type: 'fix:completed';
+  filePath: string;
+  iterations: number;
+  remainingFindings: number;
+}
+/** `filePath` is set when one file's fix threw and the phase carried on without it; absent when the
+ *  whole phase failed. */
+| {
+  type: 'fix:failed';
+  filePath?: string;
+  reason: string;
+} | {
+  type: 'fix:budget-exhausted';
+  spent: number;
+  limit: number;
+} | {
+  type: 'validation:failed';
   filePath: string;
-  issues: Issue[];
+  reason: string;
 } | {
   type: 'resolver:tool-result';
   filePath: string;

package/dist/types/findings.d.ts

@@ -1,13 +1,13 @@
 //#region src/types/findings.d.ts
-/** The package's own detection categories. `Finding.category` is an open `string` so consumer
- *  validators can contribute their own kinds (e.g. `'type-error'`, `'lint:no-console'`); these are the
- *  well-known values the package itself emits. */
+/** The package's own detection categories. `Finding.category` stays open so consumer validators can
+ *  contribute their own kinds (e.g. `'type-error'`, `'lint:no-console'`); these are the well-known
+ *  values the package itself emits. */
 type FindingCategory = 'broken-reference' | 'duplicate-definition' | 'syntax-error' | 'dropped-side';
 type FindingTier = 'file' | 'project';
 interface Finding {
-  /** Finding kind. Open string — the package emits {@link FindingCategory} values; a consumer
-   *  validator may use its own category strings. */
-  category: string;
+  /** Finding kind. The package emits {@link FindingCategory} values; a consumer validator may use its
+   *  own category strings, which is what the open half of the union allows. */
+  category: FindingCategory | (string & {});
   severity: 'error' | 'warning';
   tier: FindingTier;
   location: {
@@ -20,27 +20,37 @@ interface Finding {
     side: 'ours' | 'theirs';
     line: number;
   };
+  /** Present for a cross-file `broken-reference` when the parser reported the pre-merge resolution
+   *  target: the file whose definition the use site expected. Lets the cross-file fix pass show the
+   *  refining model what that file currently defines (a rename/move is otherwise invisible from the use
+   *  site alone). Absent when the backend does not fill reference targets. */
+  definitionFile?: string;
   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; `skipped-unreadable-source` means the parent snapshots came back
- *  empty (unreadable source), so the before/after comparison had nothing to compare against. */
-type CheckStatus = 'ran' | 'skipped-no-parser' | 'skipped-no-refs' | 'skipped-unreadable-source' | 'partial-unsupported-language' | 'errored';
+ *  in scope could not be parsed; `partial-no-cross-file-resolution` means the parser backend declared
+ *  it does not resolve references across files, so cross-file breaks are structurally out of reach;
+ *  `skipped-unreadable-source` means the parent snapshots came back empty (unreadable source), so the
+ *  before/after comparison had nothing to compare against. */
+type CheckStatus = 'ran' | 'skipped-no-parser' | 'skipped-no-refs' | 'skipped-unreadable-source' | 'partial-unsupported-language' | 'partial-no-cross-file-resolution' | 'errored';
 interface DetectionReport {
   findings: Finding[];
   checks: {
     referenceIntegrity: CheckStatus;
     structural: CheckStatus;
   };
-  /** Honest coverage signal so empty findings are not read as "clean": `analyzed` is the number of
-   *  files in scope, `readable` how many had loadable parent content (0 means the before/after
-   *  comparison had nothing to compare), and `truncated` whether the scope was capped. Present only
-   *  when the reference check ran (refs available). */
+  /** Honest coverage signal so empty findings are not read as "clean". Present only when the reference
+   *  check ran (refs available). */
   scope?: {
-    analyzed: number;
-    readable: number;
+    /** How many files the detector took into scope, after the cap. */inScope: number;
+    /** How many scope files had loadable parent content. 0 means the before/after comparison had
+     *  nothing to compare. */
+    readable: number; /** Whether the scope exceeded the cap and its tail was dropped. */
     truncated: boolean;
+    /** Whether the merge's incoming/auto-merged set could be discovered. `false` means the git port
+     *  could not answer, so scope fell back to the conflict set — a coverage gap, not an empty diff. */
+    incomingDiscovered: boolean;
   };
 }
 //#endregion

package/dist/types/resolution.d.ts

@@ -26,6 +26,17 @@ interface Resolution {
   confidence: number;
   description: string;
   note?: string;
+  /** Set when this resolution is the resolver's emergency fallback — a whole-side take after the AI
+   *  path failed, not a decision. Distinguishes it from an identical-looking rule or default take, and
+   *  from a genuine AI resolution that happened to pick one side; reference-integrity uses it to decide
+   *  whether discarding the other side was intentional. */
+  fallback?: true;
+  /** Set when this resolution is a deliberate whole-side discard chosen by a file rule or the default
+   *  strategy — the caller asked to take one side wholesale, so the fix phase must not refine it back
+   *  toward the discarded side. Distinct from `fallback` (an emergency take after the AI path failed)
+   *  and from an AI resolution that merely happened to pick one side unanimously (which the fix phase
+   *  may still refine). */
+  deliberateTake?: true;
   /** Non-blocking per-file findings from the consumer's validator port (post-refine). Folded into
    *  the operation's detection findings, hence into the verdict. */
   findings?: Finding[];

package/dist/types/step.d.ts

@@ -23,6 +23,33 @@ interface StepConfig extends ResolverConfig {
   defaultStrategy?: 'ai' | 'take-ours' | 'take-theirs' | 'skip' | 'deleted';
   rules?: FileRule[];
   fallbackStrategy?: 'take-ours' | 'take-theirs';
+  /** Escape hatch: apply the wholesale `fallbackStrategy` even when it would discard already-integrated
+   *  work. Off by default so a lossy fallback stops for manual resolution instead of completing silently. */
+  allowLossyFallback?: boolean;
+  /** Opt in to the fix phase (default `false` → report-only). When enabled, an AI-resolved file carrying
+   *  error-severity per-file findings is routed back through refine to attempt a fix; what it cannot fix
+   *  remains in the findings. Requires `ResolverDeps.parser` — without a parser the fix phase is a no-op
+   *  and the report-only detection path runs instead. Without `ResolutionContext.refs` (or
+   *  `detectionRefs`) the per-file stage still runs on what needs no parent content — syntax errors and
+   *  validator findings — but cross-file routing is skipped, since it is driven by the whole-set
+   *  before/after report. Off by default so the report-only path is unchanged. */
+  fix?: boolean;
+  /** Max per-file fix iterations (refine → re-detect the file) when `fix` is on. Default 3. */
+  fixLoopMaxIterations?: number;
+  /** Max cross-file fix rounds (route project-level breaks to their use-site file → re-detect the whole
+   *  set) when `fix` is on. Default 2. */
+  crossFileMaxIterations?: number;
+  /** Override the reference-integrity scope cap (default 400 files). Beyond the cap the scope is
+   *  `truncated`, which holds the verdict off `clean`; raise it so a large merge stays auto-applyable. */
+  maxDetectionScopeFiles?: number;
+  /** Global cap on `model.generate` calls for the whole operation (resolve + refine + fix). Default
+   *  `undefined` = unlimited. Primarily a backstop for the fix phase's multiplicative worst case
+   *  (files × fixLoopMaxIterations + crossFileMaxIterations × routable calls). When spent, the fix
+   *  phase stops attempting further fixes and leaves the remainder in findings — it never aborts the
+   *  operation. The resolve loop is not gated by this (it is already bounded by `maxSteps`); its calls
+   *  still count toward the cap. Batch-only: the fix phase is what enforces it, so it has no effect on
+   *  the single-file `resolveConflict`. */
+  maxModelCalls?: number;
 }
 //#endregion
 export { FileRule, StepConfig, StepResult };

package/dist/types/summary.d.ts

@@ -2,14 +2,18 @@ import { ResolutionStrategy } from "./resolution.js";
 import { AiTokenUsage } from "@gitkraken/shared-tools";
 
 //#region src/types/summary.d.ts
-/** A file flagged for human review. `reason` distinguishes a low file-confidence flag from a
- *  detection finding; `confidence` is absent for files flagged purely by a finding (e.g. an
- *  auto-merged file with no resolution of its own). */
+/** A file flagged for human review. `reason` distinguishes a low file-confidence flag, a detection
+ *  finding, and a file the tool left unmerged. `confidence` is absent for files flagged purely by a
+ *  finding (e.g. an auto-merged file with no resolution of its own) or as unresolved. */
 interface ReviewItem {
   filePath: string;
   confidence?: number;
-  reason: 'low-confidence' | 'finding';
-  /** Categories of the error-severity findings on this file; present when `reason` is `'finding'`. */
+  /** `unresolved` — an unmerged entry the tool did not resolve (no conflict markers to act on: a binary
+   *  add/add, an unparseable delete-modify). It is still unmerged on disk, so the operation is not
+   *  clean; a `skip`-rule exclusion is a deliberate human choice and is not flagged. */
+  reason: 'low-confidence' | 'finding' | 'unresolved';
+  /** Categories of the findings on this file, of any severity (error and warning alike); present when
+   *  `reason` is `'finding'`. */
   findingCategories?: string[];
 }
 /** Suggested honest verdict for the operation. `blocked` when any error-severity finding exists;
@@ -27,16 +31,19 @@ interface OperationDigest {
   byStrategy: Record<ResolutionStrategy, number>;
   /** Lowest file confidence across all resolutions; null when there are none. */
   minConfidence: number | null;
-  /** Files needing review — low-confidence resolutions and files with error findings, findings
-   *  first, then lowest confidence first. */
+  /** Files needing review — low-confidence resolutions and files carrying any finding (error or
+   *  warning), findings first, then lowest confidence first. */
   needsReview: ReviewItem[];
   /** Files skipped by rule or because they had no markers. */
   skipped: number;
   /** Files that errored during resolution. */
   errors: number;
-  /** Whether reference-integrity detection ran to completion (every check `ran`). `false` when no
-   *  detection was attached or any check was skipped/errored — so empty findings must NOT be read
-   *  as "clean". */
+  /** Whether detection achieved full coverage: both checks ran (a check that ran with some
+   *  unsupported-language files in scope still counts — non-code files carry no references to break)
+   *  *and* nothing was left unexamined (scope not truncated, incoming set discoverable). `false` when
+   *  no detection was attached, a check was skipped/errored, the backend cannot resolve cross-file
+   *  references, or part of the scope was never looked at — so empty findings must NOT be read as
+   *  "clean". */
   detectionComplete: boolean;
   /** Total detection findings across the operation. */
   findingCount: number;

package/dist/validation/findings.d.ts

@@ -0,0 +1,9 @@
+import { Finding } from "../types/findings.js";
+import { ValidatorFinding } from "../ports/validator.js";
+
+//#region src/validation/findings.d.ts
+/** Lifts a consumer finding into the package's `Finding` shape. Validators run per file, so everything
+ *  they report is `tier: 'file'`. */
+declare function toFileFinding(finding: ValidatorFinding): Finding;
+//#endregion
+export { toFileFinding };

package/dist/validation/findings.js

@@ -0,0 +1 @@
+function e(e){return{category:e.category,severity:e.severity,tier:`file`,location:{file:e.file,line:e.line??1},message:e.message}}export{e as toFileFinding};

package/dist/validation/markers.d.ts

@@ -0,0 +1,11 @@
+import { Issue } from "../types/issue.js";
+
+//#region src/validation/markers.d.ts
+interface VerificationResult {
+  valid: boolean;
+  issues?: Issue[];
+}
+declare const CONFLICT_MARKER_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+declare function checkResidualMarkers(_filePath: string, content: string): VerificationResult;
+//#endregion
+export { CONFLICT_MARKER_PATTERNS, VerificationResult, checkResidualMarkers };

package/dist/{ports/verify.js → validation/markers.js}

@@ -1,2 +1,2 @@
 const e=[/^<{7}(\s|$)/,/^\|{7}(\s|$)/,/^={7}(\s|$)/,/^>{7}(\s|$)/];function t(t,n){let r=n.split(`
-`),i=[];for(let t=0;t<r.length;t++){let n=r[t]??``;for(let r of e)if(r.test(n)){i.push(t+1);break}}return i.length===0?{valid:!0}:{valid:!1,issues:[{severity:`error`,message:`Residual conflict markers found at line(s) ${i.join(`, `)}.`}]}}export{t as checkResidualMarkers};
+`),i=[];for(let t=0;t<r.length;t++){let n=r[t]??``;for(let r of e)if(r.test(n)){i.push(t+1);break}}return i.length===0?{valid:!0}:{valid:!1,issues:[{severity:`error`,message:`Residual conflict markers found at line(s) ${i.join(`, `)}.`}]}}export{e as CONFLICT_MARKER_PATTERNS,t as checkResidualMarkers};

package/package.json

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

package/dist/ports/verify.d.ts

@@ -1,30 +0,0 @@
-import { SourceOverlay } from "./parser.js";
-import { Issue } from "../types/issue.js";
-
-//#region src/ports/verify.d.ts
-interface VerificationResult {
-  valid: boolean;
-  issues?: Issue[];
-}
-interface ValidatorFinding {
-  /** Open category string set by the consumer (e.g. `'type-error'`, `'lint:no-console'`). */
-  category: string;
-  severity: 'error' | 'warning';
-  file: string;
-  /** 1-indexed. */
-  line?: number;
-  message: string;
-}
-/**
- * The consumer's validation port (RFC stages 5/7). Plug in any checks — syntax, real import
- * resolution, types, lint, project rules. **Non-blocking**: runs post-refine over an overlay (one file
- * for per-file validation, or the whole touched set for cross-file); its findings are advisory (folded
- * into the operation's findings and verdict), never a re-resolve. The only blocking gate is residual
- * conflict markers, checked built-in by the resolver ({@link checkResidualMarkers}) — not this port.
- */
-interface Validator {
-  validate(sources: SourceOverlay): Promise<ValidatorFinding[]>;
-}
-declare function checkResidualMarkers(_filePath: string, content: string): VerificationResult;
-//#endregion
-export { Validator, ValidatorFinding, VerificationResult, checkResidualMarkers };