@mrsf/cli 0.6.0 → 0.7.1

package/dist/lib/confidence-calibration.js

@@ -0,0 +1,120 @@
+/**
+ * Calibrate independent revision and structural evidence into a public result.
+ *
+ * Exact evidence is certain. Edited anchors are probable only when evidence
+ * agrees or one source has a decisive margin; conflicting evidence abstains.
+ */
+export function calibrateAnchorEvidence(commentId, selectedText, projected, contextual) {
+    if (projected?.exact) {
+        return {
+            band: "certain",
+            result: projectedResult(commentId, selectedText, projected),
+        };
+    }
+    if (contextual?.status === "anchored") {
+        return {
+            band: "certain",
+            result: contextualResult(commentId, selectedText, contextual),
+        };
+    }
+    if (projected && contextual) {
+        if (sameRange(projected, contextual)) {
+            const result = contextualResult(commentId, selectedText, contextual);
+            result.status = "fuzzy";
+            result.score = combineIndependentScores(projected.score, contextual.score);
+            result.reason =
+                `Probable anchor: revision projection and Markdown context agree `
+                    + `(confidence ${result.score.toFixed(3)}).`;
+            return { band: "probable", result };
+        }
+        if (contextual.status === "orphaned" && !isStrongProjection(projected)) {
+            return {
+                band: "orphaned",
+                result: contextualResult(commentId, selectedText, contextual),
+            };
+        }
+        if (contextual.status === "fuzzy"
+            && contextual.candidateMargin >= 0.15
+            && contextual.score >= projected.score + 0.1) {
+            return {
+                band: "probable",
+                result: contextualResult(commentId, selectedText, contextual),
+            };
+        }
+        return {
+            band: "ambiguous",
+            result: {
+                commentId,
+                status: "ambiguous",
+                score: Math.max(projected.score, contextual.score),
+                reason: `Ambiguous evidence: revision projection points to line `
+                    + `${projected.line}, while Markdown context points to `
+                    + `${contextual.line ?? "no location"}.`,
+            },
+        };
+    }
+    if (contextual) {
+        const band = contextual.status === "orphaned"
+            ? "orphaned"
+            : contextual.status === "ambiguous"
+                ? "ambiguous"
+                : "probable";
+        return {
+            band,
+            result: contextualResult(commentId, selectedText, contextual),
+        };
+    }
+    if (projected) {
+        if (!isStrongProjection(projected))
+            return undefined;
+        return {
+            band: "probable",
+            result: projectedResult(commentId, selectedText, projected),
+        };
+    }
+    return undefined;
+}
+function isStrongProjection(projected) {
+    return projected.contextSupport >= 3
+        || (projected.contextSupport >= 2 && projected.contextMargin >= 0.5);
+}
+function sameRange(projected, contextual) {
+    return projected.line === contextual.line
+        && projected.endLine === contextual.endLine;
+}
+function combineIndependentScores(left, right) {
+    return Math.min(0.95, (left + right) / 2 + 0.05);
+}
+function projectedResult(commentId, selectedText, projected) {
+    return {
+        commentId,
+        status: projected.exact ? "anchored" : "fuzzy",
+        score: projected.score,
+        newLine: projected.line,
+        newEndLine: projected.endLine,
+        newStartColumn: projected.startColumn,
+        newEndColumn: projected.endColumn,
+        anchoredText: projected.exact ? undefined : projected.text,
+        previousSelectedText: projected.exact ? undefined : selectedText,
+        reason: projected.reason,
+    };
+}
+function contextualResult(commentId, selectedText, contextual) {
+    return {
+        commentId,
+        status: contextual.status,
+        score: contextual.score,
+        newLine: contextual.line,
+        newEndLine: contextual.endLine,
+        newStartColumn: contextual.startColumn,
+        newEndColumn: contextual.endColumn,
+        anchoredText: contextual.status === "fuzzy"
+            ? contextual.text
+            : undefined,
+        previousSelectedText: contextual.status === "fuzzy"
+            ? selectedText
+            : undefined,
+        reason: contextual.reason,
+    };
+}
+//# sourceMappingURL=confidence-calibration.js.map

package/dist/lib/fuzzy.d.ts

@@ -5,6 +5,13 @@
  * Levenshtein matching for re-anchoring selected_text.
  */
 import type { FuzzyCandidate } from "./types.js";
+export declare const MAX_FUZZY_CANDIDATE_LINES = 64;
+export interface FuzzySearchIndex {
+    lines: string[];
+    tokenPostings: Map<string, number[]>;
+    trigramPostings: Map<string, number[]>;
+}
+export declare function createFuzzySearchIndex(lines: string[]): FuzzySearchIndex;
 /**
  * Find all exact occurrences of `needle` in lines (1-based array).
  */
@@ -35,5 +42,11 @@ export declare function combinedScore(needle: string, candidate: string): number
  * @param threshold Minimum score to include (0.0–1.0).
  * @param hintLine  Optional original line number for proximity scoring.
  */
-export declare function fuzzySearch(lines: string[], needle: string, threshold?: number, hintLine?: number): FuzzyCandidate[];
+export declare function fuzzySearch(lines: string[], needle: string, threshold?: number, hintLine?: number, index?: FuzzySearchIndex): FuzzyCandidate[];
+/**
+ * Compute fuzzy candidates once and partition them by their unadjusted
+ * similarity thresholds. Proximity remains a ranking bonus and does not make
+ * a candidate eligible for a threshold it did not originally satisfy.
+ */
+export declare function fuzzySearchThresholds(lines: string[], needle: string, thresholds: number[], hintLine?: number, index?: FuzzySearchIndex): Map<number, FuzzyCandidate[]>;
 //# sourceMappingURL=fuzzy.d.ts.map

package/dist/lib/fuzzy.js

@@ -5,6 +5,16 @@
  * Levenshtein matching for re-anchoring selected_text.
  */
 import { distance as levenshtein } from "fastest-levenshtein";
+export const MAX_FUZZY_CANDIDATE_LINES = 64;
+export function createFuzzySearchIndex(lines) {
+    const tokenPostings = new Map();
+    const trigramPostings = new Map();
+    for (let line = 1; line < lines.length; line += 1) {
+        addPostingSignals(tokenPostings, lexicalTokens(lines[line]), line);
+        addPostingSignals(trigramPostings, characterTrigrams(lines[line]), line);
+    }
+    return { lines, tokenPostings, trigramPostings };
+}
 // ---------------------------------------------------------------------------
 // Exact matching
 // ---------------------------------------------------------------------------
@@ -193,21 +203,47 @@ export function combinedScore(needle, candidate) {
  * @param threshold Minimum score to include (0.0–1.0).
  * @param hintLine  Optional original line number for proximity scoring.
  */
-export function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
-    if (!needle)
-        return [];
+export function fuzzySearch(lines, needle, threshold = 0.6, hintLine, index) {
+    return fuzzySearchThresholds(lines, needle, [threshold], hintLine, index).get(threshold) ?? [];
+}
+/**
+ * Compute fuzzy candidates once and partition them by their unadjusted
+ * similarity thresholds. Proximity remains a ranking bonus and does not make
+ * a candidate eligible for a threshold it did not originally satisfy.
+ */
+export function fuzzySearchThresholds(lines, needle, thresholds, hintLine, index = createFuzzySearchIndex(lines)) {
+    const uniqueThresholds = [...new Set(thresholds)];
+    const results = new Map();
+    if (uniqueThresholds.length === 0)
+        return results;
+    if (!needle) {
+        for (const threshold of uniqueThresholds)
+            results.set(threshold, []);
+        return results;
+    }
     const needleLines = needle.split("\n");
     const needleLineCount = needleLines.length;
     const candidates = [];
+    const minimumThreshold = Math.min(...uniqueThresholds);
+    const candidateLines = retrieveCandidateLines(index, needle, hintLine);
     // Window sizes: ±30% of original line count, minimum 1
     const minWindow = Math.max(1, Math.floor(needleLineCount * 0.7));
     const maxWindow = Math.min(lines.length - 1, Math.ceil(needleLineCount * 1.3) + 1);
     for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
-        for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+        const startLines = new Set();
+        for (const candidateLine of candidateLines) {
+            for (let offset = 0; offset < winSize; offset += 1) {
+                const startLine = candidateLine - offset;
+                if (startLine >= 1 && startLine + winSize - 1 < lines.length) {
+                    startLines.add(startLine);
+                }
+            }
+        }
+        for (const startLine of startLines) {
             const windowLines = lines.slice(startLine, startLine + winSize);
             const windowText = windowLines.join("\n");
             const score = combinedScore(needle, windowText);
-            if (score >= threshold) {
+            if (score >= minimumThreshold) {
                 candidates.push({
                     text: windowText,
                     line: startLine,
@@ -221,19 +257,19 @@ export function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
     }
     // For single-line needles, also try substring matching within each line
     if (needleLineCount === 1 && needle.length < 200) {
-        for (let lineNum = 1; lineNum < lines.length; lineNum++) {
+        for (const lineNum of candidateLines) {
             const line = lines[lineNum];
             if (!line)
                 continue;
-            // Sliding window within line
             const winLen = needle.length;
             const minWinLen = Math.max(3, Math.floor(winLen * 0.7));
             const maxWinLen = Math.min(line.length, Math.ceil(winLen * 1.3));
-            for (let len = minWinLen; len <= maxWinLen; len++) {
+            const lengths = evenlySpacedIntegers(minWinLen, maxWinLen, 7);
+            for (const len of lengths) {
                 for (let col = 0; col + len <= line.length; col++) {
                     const sub = line.substring(col, col + len);
                     const score = combinedScore(needle, sub);
-                    if (score >= threshold) {
+                    if (score >= minimumThreshold) {
                         candidates.push({
                             text: sub,
                             line: lineNum,
@@ -247,18 +283,93 @@ export function fuzzySearch(lines, needle, threshold = 0.6, hintLine) {
             }
         }
     }
-    // Deduplicate and sort
-    let deduped = deduplicateCandidates(candidates);
-    // Apply proximity bonus if hintLine is provided
+    const deduped = deduplicateCandidates(candidates);
+    const scored = deduped.map((candidate) => ({
+        baseScore: candidate.score,
+        candidate: applyProximityBonus(candidate, hintLine),
+    }));
+    for (const threshold of uniqueThresholds) {
+        results.set(threshold, scored
+            .filter((item) => item.baseScore >= threshold)
+            .map((item) => item.candidate)
+            .sort((left, right) => right.score - left.score));
+    }
+    return results;
+}
+function retrieveCandidateLines(index, needle, hintLine) {
+    const votes = new Map();
+    const lineCount = Math.max(0, index.lines.length - 1);
+    const signals = [
+        ...postingSignals(index.tokenPostings, lexicalTokens(needle), 2),
+        ...postingSignals(index.trigramPostings, characterTrigrams(needle), 1),
+    ]
+        .sort((left, right) => left.postings.length - right.postings.length)
+        .slice(0, 16);
+    for (const signal of signals) {
+        const rarity = Math.log1p(lineCount / signal.postings.length);
+        for (const line of signal.postings) {
+            votes.set(line, (votes.get(line) ?? 0) + signal.weight * rarity);
+        }
+    }
     if (hintLine != null) {
-        deduped = deduped.map((c) => {
-            const dist = Math.abs(c.line - hintLine);
-            // Small bonus for proximity (up to 0.1 for exact line match)
-            const proximityBonus = 0.1 * Math.max(0, 1 - dist / 50);
-            return { ...c, score: Math.min(1.0, c.score + proximityBonus) };
-        });
+        for (let offset = -4; offset <= 4; offset += 1) {
+            const line = hintLine + offset;
+            if (line >= 1 && line <= lineCount) {
+                votes.set(line, (votes.get(line) ?? 0) + 0.25);
+            }
+        }
+    }
+    if (votes.size === 0) {
+        return Array.from({ length: lineCount }, (_, index) => index + 1);
+    }
+    return [...votes.entries()]
+        .sort((left, right) => right[1] - left[1]
+        || distanceFromHint(left[0], hintLine) - distanceFromHint(right[0], hintLine)
+        || left[0] - right[0])
+        .slice(0, MAX_FUZZY_CANDIDATE_LINES)
+        .map(([line]) => line);
+}
+function postingSignals(postings, values, weight) {
+    return [...new Set(values)]
+        .map((value) => ({ postings: postings.get(value) ?? [], weight }))
+        .filter((signal) => signal.postings.length > 0);
+}
+function addPostingSignals(postings, values, line) {
+    for (const value of new Set(values)) {
+        const lines = postings.get(value);
+        if (lines) {
+            lines.push(line);
+        }
+        else {
+            postings.set(value, [line]);
+        }
+    }
+}
+function lexicalTokens(text) {
+    return text.toLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [];
+}
+function characterTrigrams(text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+    const characters = [...normalized];
+    if (characters.length < 3)
+        return normalized ? [normalized] : [];
+    const trigrams = [];
+    for (let index = 0; index <= characters.length - 3; index += 1) {
+        trigrams.push(characters.slice(index, index + 3).join(""));
     }
-    return deduped.sort((a, b) => b.score - a.score);
+    return trigrams;
+}
+function evenlySpacedIntegers(minimum, maximum, count) {
+    if (maximum <= minimum)
+        return [minimum];
+    const values = new Set();
+    for (let index = 0; index < count; index += 1) {
+        values.add(Math.round(minimum + (maximum - minimum) * index / (count - 1)));
+    }
+    return [...values];
+}
+function distanceFromHint(line, hintLine) {
+    return hintLine == null ? 0 : Math.abs(line - hintLine);
 }
 // ---------------------------------------------------------------------------
 // Helpers
@@ -274,4 +385,14 @@ function deduplicateCandidates(candidates) {
     }
     return Array.from(seen.values());
 }
+function applyProximityBonus(candidate, hintLine) {
+    if (hintLine == null)
+        return candidate;
+    const distance = Math.abs(candidate.line - hintLine);
+    const proximityBonus = 0.1 * Math.max(0, 1 - distance / 50);
+    return {
+        ...candidate,
+        score: Math.min(1.0, candidate.score + proximityBonus),
+    };
+}
 //# sourceMappingURL=fuzzy.js.map

package/dist/lib/git.d.ts

@@ -16,10 +16,19 @@ export declare function resetGitCache(): void;
  * Returns null if not in a Git repo.
  */
 export declare function findRepoRoot(cwd?: string): Promise<string | null>;
+/**
+ * Read the repository-local Git author name.
+ *
+ * Only `.git/config` is considered; global Git identity is intentionally
+ * ignored so callers can distinguish repository identity from user defaults.
+ */
+export declare function getGitUserName(repoRoot: string): Promise<string | null>;
 /**
  * Get the full HEAD commit SHA.
  */
 export declare function getCurrentCommit(repoRoot: string): Promise<string | null>;
+/** Resolve a revision name or abbreviated SHA to its canonical commit SHA. */
+export declare function resolveCommit(revision: string, repoRoot: string): Promise<string | null>;
 /**
  * Check if a commit hash is the same as HEAD.
  */

package/dist/lib/git.js

@@ -49,6 +49,24 @@ export async function findRepoRoot(cwd) {
         return null;
     }
 }
+/**
+ * Read the repository-local Git author name.
+ *
+ * Only `.git/config` is considered; global Git identity is intentionally
+ * ignored so callers can distinguish repository identity from user defaults.
+ */
+export async function getGitUserName(repoRoot) {
+    if (!(await isGitAvailable()))
+        return null;
+    try {
+        const { stdout } = await execFile("git", ["config", "--local", "--get", "user.name"], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        const name = stdout.trim();
+        return name || null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Get the full HEAD commit SHA.
  */
@@ -63,6 +81,18 @@ export async function getCurrentCommit(repoRoot) {
         return null;
     }
 }
+/** Resolve a revision name or abbreviated SHA to its canonical commit SHA. */
+export async function resolveCommit(revision, repoRoot) {
+    if (!(await isGitAvailable()))
+        return null;
+    try {
+        const { stdout } = await execFile("git", ["rev-parse", "--verify", `${revision}^{commit}`], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Check if a commit hash is the same as HEAD.
  */

package/dist/lib/global-reconciliation.d.ts

@@ -0,0 +1,11 @@
+import { type AnchorContextIndex } from "./anchor-context.js";
+import type { Comment, ReanchorResult } from "./types.js";
+/**
+ * Resolve uncertain comments from nearby high-confidence anchors.
+ *
+ * Each landmark votes for a local source-to-target displacement rather than
+ * global document order, allowing whole sections to move independently.
+ * Newly confirmed exact anchors become landmarks in subsequent rounds.
+ */
+export declare function reconcileCommentAnchors(comments: Comment[], results: ReanchorResult[], anchorContext: AnchorContextIndex): ReanchorResult[];
+//# sourceMappingURL=global-reconciliation.d.ts.map

package/dist/lib/global-reconciliation.js

@@ -0,0 +1,145 @@
+import { findContextAnchorCandidates, getAnchorContextScope, } from "./anchor-context.js";
+const LOCAL_LANDMARK_WINDOW = 30;
+const MIN_LANDMARK_SUPPORT = 0.65;
+const MIN_SUPPORTING_LANDMARKS = 2;
+const MIN_GLOBAL_MARGIN = 0.08;
+const MAX_RECONCILIATION_ROUNDS = 4;
+/**
+ * Resolve uncertain comments from nearby high-confidence anchors.
+ *
+ * Each landmark votes for a local source-to-target displacement rather than
+ * global document order, allowing whole sections to move independently.
+ * Newly confirmed exact anchors become landmarks in subsequent rounds.
+ */
+export function reconcileCommentAnchors(comments, results, anchorContext) {
+    const reconciled = results.map((result) => ({ ...result }));
+    if (comments.length < MIN_SUPPORTING_LANDMARKS + 1
+        || !reconciled.some((result) => result.status === "ambiguous")) {
+        return reconciled;
+    }
+    const resultIndexes = new Map(reconciled.map((result, index) => [result.commentId, index]));
+    const landmarks = collectLandmarks(comments, reconciled, anchorContext);
+    const landmarkCounts = new Map();
+    for (const landmark of landmarks) {
+        landmarkCounts.set(landmark.scope, (landmarkCounts.get(landmark.scope) ?? 0) + 1);
+    }
+    for (let round = 0; round < MAX_RECONCILIATION_ROUNDS; round += 1) {
+        let changed = false;
+        for (const comment of comments) {
+            if (comment.line == null || !comment.selected_text)
+                continue;
+            const scope = getAnchorContextScope(comment, anchorContext);
+            if (scope == null)
+                continue;
+            if ((landmarkCounts.get(scope) ?? 0) < MIN_SUPPORTING_LANDMARKS) {
+                continue;
+            }
+            const resultIndex = resultIndexes.get(comment.id);
+            if (resultIndex == null)
+                continue;
+            const result = reconciled[resultIndex];
+            if (result.status !== "ambiguous")
+                continue;
+            const candidates = deduplicateCandidates(findContextAnchorCandidates(comment, anchorContext)).slice(0, 8);
+            if (candidates.length < 2)
+                continue;
+            const ranked = candidates
+                .map((candidate) => scoreWithLandmarks(comment.line, scope, candidate, landmarks))
+                .sort((left, right) => right.globalScore - left.globalScore
+                || right.candidate.score - left.candidate.score
+                || left.candidate.line - right.candidate.line);
+            const best = ranked[0];
+            const second = ranked[1];
+            if (!best.candidate.exact
+                || best.supportingLandmarks < MIN_SUPPORTING_LANDMARKS
+                || best.support < MIN_LANDMARK_SUPPORT
+                || best.globalScore - second.globalScore < MIN_GLOBAL_MARGIN) {
+                continue;
+            }
+            reconciled[resultIndex] = {
+                commentId: comment.id,
+                status: "anchored",
+                score: Math.min(0.99, 0.8 + best.support * 0.19),
+                newLine: best.candidate.line,
+                newEndLine: best.candidate.endLine,
+                newStartColumn: best.candidate.startColumn,
+                newEndColumn: best.candidate.endColumn,
+                reason: `Global reconciliation selected this candidate from `
+                    + `${best.supportingLandmarks} nearby landmark(s) `
+                    + `(support ${best.support.toFixed(3)}, margin `
+                    + `${(best.globalScore - second.globalScore).toFixed(3)}).`,
+            };
+            changed = true;
+            landmarks.push({
+                sourceLine: comment.line,
+                targetLine: best.candidate.line,
+                scope,
+            });
+            landmarkCounts.set(scope, (landmarkCounts.get(scope) ?? 0) + 1);
+        }
+        if (!changed)
+            break;
+    }
+    return reconciled;
+}
+function collectLandmarks(comments, results, anchorContext) {
+    const resultMap = new Map(results.map((result) => [result.commentId, result]));
+    return comments.flatMap((comment) => {
+        const result = resultMap.get(comment.id);
+        if (comment.line == null
+            || result?.newLine == null
+            || (result.status !== "anchored" && result.status !== "shifted")
+            || result.score < 0.99) {
+            return [];
+        }
+        const scope = getAnchorContextScope(comment, anchorContext);
+        return scope == null
+            ? []
+            : [{ sourceLine: comment.line, targetLine: result.newLine, scope }];
+    });
+}
+function scoreWithLandmarks(sourceLine, scope, candidate, landmarks) {
+    let weightedSupport = 0;
+    let totalWeight = 0;
+    let supportingLandmarks = 0;
+    const candidateShift = candidate.line - sourceLine;
+    for (const landmark of landmarks) {
+        if (landmark.scope !== scope)
+            continue;
+        const sourceDistance = Math.abs(sourceLine - landmark.sourceLine);
+        if (sourceDistance === 0 || sourceDistance > LOCAL_LANDMARK_WINDOW)
+            continue;
+        const landmarkShift = landmark.targetLine - landmark.sourceLine;
+        const shiftError = Math.abs(candidateShift - landmarkShift);
+        const agreement = Math.max(0, 1 - shiftError / 8);
+        const weight = 1 / (1 + sourceDistance / 4);
+        weightedSupport += agreement * weight;
+        totalWeight += weight;
+        if (agreement >= MIN_LANDMARK_SUPPORT)
+            supportingLandmarks += 1;
+    }
+    const support = totalWeight > 0 ? weightedSupport / totalWeight : 0;
+    return {
+        candidate,
+        globalScore: candidate.score * 0.5 + support * 0.45 + (candidate.exact ? 0.05 : 0),
+        support,
+        supportingLandmarks,
+    };
+}
+function deduplicateCandidates(candidates) {
+    const unique = new Map();
+    for (const candidate of candidates) {
+        const key = [
+            candidate.line,
+            candidate.endLine,
+            candidate.startColumn ?? "",
+            candidate.endColumn ?? "",
+        ].join(":");
+        const existing = unique.get(key);
+        if (!existing || candidate.score > existing.score) {
+            unique.set(key, candidate);
+        }
+    }
+    return [...unique.values()].sort((left, right) => right.score - left.score || left.line - right.line);
+}
+//# sourceMappingURL=global-reconciliation.js.map

package/dist/lib/reanchor-core.d.ts

@@ -1,4 +1,7 @@
 import type { AnchorPosition, Comment, DiffHunk, MrsfDocument, ReanchorResult } from "./types.js";
+import { type FuzzySearchIndex } from "./fuzzy.js";
+import { type RevisionProjectionIndex } from "./revision-projection.js";
+import { type AnchorContextIndex } from "./anchor-context.js";
 export declare const HIGH_THRESHOLD = 0.8;
 export declare const DEFAULT_THRESHOLD = 0.6;
 /**
@@ -16,6 +19,10 @@ export declare function reanchorComment(comment: Comment, documentLines: string[
     threshold?: number;
     commitIsStale?: boolean;
     proximityWindow?: number;
+    revisionProjection?: RevisionProjectionIndex;
+    anchorContext?: AnchorContextIndex;
+    fuzzySearchIndex?: FuzzySearchIndex;
+    getFuzzySearchIndex?: () => FuzzySearchIndex;
 }): ReanchorResult;
 export declare function reanchorDocumentLines(doc: MrsfDocument, documentLines: string[], opts?: {
     threshold?: number;