@mrsf/cli 0.1.0

package/dist/lib/fuzzy.js

@@ -0,0 +1,277 @@
+/**
+ * MRSF Fuzzy Matching Engine
+ *
+ * Provides exact, normalized, token-level LCS, and character-level
+ * Levenshtein matching for re-anchoring selected_text.
+ */
+import { distance as levenshtein } from "fastest-levenshtein";
+// ---------------------------------------------------------------------------
+// Exact matching
+// ---------------------------------------------------------------------------
+/**
+ * Find all exact occurrences of `needle` in lines (1-based array).
+ */
+export function exactMatch(lines, needle) {
+    if (!needle)
+        return [];
+    const results = [];
+    const needleLines = needle.split("\n");
+    const needleLineCount = needleLines.length;
+    // Slide a window across the document
+    for (let startLine = 1; startLine <= lines.length - needleLineCount; startLine++) {
+        // Build the text for this window
+        const windowLines = lines.slice(startLine, startLine + needleLineCount);
+        const windowText = windowLines.join("\n");
+        // Check if the needle appears anywhere within this window (for single-line)
+        if (needleLineCount === 1) {
+            let col = 0;
+            const line = windowLines[0];
+            while (col < line.length) {
+                const idx = line.indexOf(needle, col);
+                if (idx === -1)
+                    break;
+                results.push({
+                    text: needle,
+                    line: startLine,
+                    endLine: startLine,
+                    startColumn: idx,
+                    endColumn: idx + needle.length,
+                    score: 1.0,
+                });
+                col = idx + 1;
+            }
+        }
+        else {
+            // Multi-line: check if the window contains the exact needle
+            const idx = windowText.indexOf(needle);
+            if (idx !== -1) {
+                // Calculate start column
+                const beforeMatch = windowText.slice(0, idx);
+                const linesBeforeEnd = beforeMatch.split("\n");
+                const startCol = linesBeforeEnd[linesBeforeEnd.length - 1].length;
+                // Calculate end column
+                const afterMatch = needle.split("\n");
+                const endCol = afterMatch[afterMatch.length - 1].length;
+                if (startCol === 0 || linesBeforeEnd.length === 1) {
+                    results.push({
+                        text: needle,
+                        line: startLine + linesBeforeEnd.length - 1,
+                        endLine: startLine + linesBeforeEnd.length - 1 + afterMatch.length - 1,
+                        startColumn: startCol,
+                        endColumn: endCol,
+                        score: 1.0,
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Normalized matching (collapse whitespace)
+// ---------------------------------------------------------------------------
+function normalize(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+/**
+ * Find matches after normalizing whitespace.
+ */
+export function normalizedMatch(lines, needle) {
+    const normNeedle = normalize(needle);
+    if (!normNeedle)
+        return [];
+    const results = [];
+    // Try expanding windows of varying sizes
+    const needleLineEstimate = needle.split("\n").length;
+    const minWindow = Math.max(1, needleLineEstimate - 1);
+    const maxWindow = Math.min(lines.length - 1, needleLineEstimate + 2);
+    for (let winSize = minWindow; winSize <= maxWindow; winSize++) {
+        for (let startLine = 1; startLine + winSize - 1 < lines.length; startLine++) {
+            const windowLines = lines.slice(startLine, startLine + winSize);
+            const windowText = windowLines.join("\n");
+            const normWindow = normalize(windowText);
+            if (normWindow.includes(normNeedle)) {
+                results.push({
+                    text: windowText,
+                    line: startLine,
+                    endLine: startLine + winSize - 1,
+                    startColumn: 0,
+                    endColumn: windowLines[windowLines.length - 1].length,
+                    score: 0.95,
+                });
+            }
+        }
+    }
+    return deduplicateCandidates(results);
+}
+// ---------------------------------------------------------------------------
+// Token-level LCS
+// ---------------------------------------------------------------------------
+function tokenize(text) {
+    return text.split(/\s+/).filter((t) => t.length > 0);
+}
+/**
+ * Longest Common Subsequence length of two token arrays.
+ */
+function lcsLength(a, b) {
+    const m = a.length;
+    const n = b.length;
+    // Optimize: use two rows instead of full matrix
+    let prev = new Array(n + 1).fill(0);
+    let curr = new Array(n + 1).fill(0);
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (a[i - 1] === b[j - 1]) {
+                curr[j] = prev[j - 1] + 1;
+            }
+            else {
+                curr[j] = Math.max(prev[j], curr[j - 1]);
+            }
+        }
+        [prev, curr] = [curr, prev];
+        curr.fill(0);
+    }
+    return prev[n];
+}
+/**
+ * Score two texts using token-level LCS.
+ * Returns 0.0–1.0.
+ */
+export function tokenLcsScore(a, b) {
+    const tokA = tokenize(a);
+    const tokB = tokenize(b);
+    if (tokA.length === 0 && tokB.length === 0)
+        return 1.0;
+    if (tokA.length === 0 || tokB.length === 0)
+        return 0.0;
+    const lcs = lcsLength(tokA, tokB);
+    return lcs / Math.max(tokA.length, tokB.length);
+}
+// ---------------------------------------------------------------------------
+// Character-level Levenshtein score
+// ---------------------------------------------------------------------------
+/**
+ * Normalized Levenshtein similarity 0.0–1.0.
+ */
+export function levenshteinScore(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 1.0;
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0)
+        return 1.0;
+    const dist = levenshtein(a, b);
+    return 1 - dist / maxLen;
+}
+// ---------------------------------------------------------------------------
+// Combined fuzzy scoring
+// ---------------------------------------------------------------------------
+/**
+ * Compute a combined similarity score between two text fragments.
+ * Blends token LCS (structural) and Levenshtein (character-level).
+ */
+export function combinedScore(needle, candidate) {
+    const tScore = tokenLcsScore(needle, candidate);
+    // Full Levenshtein is expensive for long texts; only use for short ones
+    let lScore;
+    if (needle.length < 500 && candidate.length < 500) {
+        lScore = levenshteinScore(needle, candidate);
+    }
+    else {
+        lScore = tScore; // fall back to token score only
+    }
+    // Weight: 60% token LCS, 40% Levenshtein
+    return tScore * 0.6 + lScore * 0.4;
+}
+// ---------------------------------------------------------------------------
+// Fuzzy search across document
+// ---------------------------------------------------------------------------
+/**
+ * Search the document for fuzzy matches of `needle`.
+ *
+ * @param lines     1-based line array (index 0 unused).
+ * @param needle    The original selected_text.
+ * @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 [];
+    const needleLines = needle.split("\n");
+    const needleLineCount = needleLines.length;
+    const candidates = [];
+    // 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 windowLines = lines.slice(startLine, startLine + winSize);
+            const windowText = windowLines.join("\n");
+            const score = combinedScore(needle, windowText);
+            if (score >= threshold) {
+                candidates.push({
+                    text: windowText,
+                    line: startLine,
+                    endLine: startLine + winSize - 1,
+                    startColumn: 0,
+                    endColumn: windowLines[windowLines.length - 1].length,
+                    score,
+                });
+            }
+        }
+    }
+    // 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++) {
+            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++) {
+                for (let col = 0; col + len <= line.length; col++) {
+                    const sub = line.substring(col, col + len);
+                    const score = combinedScore(needle, sub);
+                    if (score >= threshold) {
+                        candidates.push({
+                            text: sub,
+                            line: lineNum,
+                            endLine: lineNum,
+                            startColumn: col,
+                            endColumn: col + len,
+                            score,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Deduplicate and sort
+    let deduped = deduplicateCandidates(candidates);
+    // Apply proximity bonus if hintLine is provided
+    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) };
+        });
+    }
+    return deduped.sort((a, b) => b.score - a.score);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function deduplicateCandidates(candidates) {
+    const seen = new Map();
+    for (const c of candidates) {
+        const key = `${c.line}:${c.startColumn}:${c.endLine}:${c.endColumn}`;
+        const existing = seen.get(key);
+        if (!existing || c.score > existing.score) {
+            seen.set(key, c);
+        }
+    }
+    return Array.from(seen.values());
+}
+//# sourceMappingURL=fuzzy.js.map

package/dist/lib/git.d.ts

@@ -0,0 +1,68 @@
+/**
+ * MRSF Git Integration — Git-aware operations for re-anchoring and discovery.
+ *
+ * Uses child_process.execFile (no shell) for safety.
+ * All functions degrade gracefully when Git is unavailable.
+ */
+import type { DiffHunk } from "./types.js";
+/**
+ * Check whether `git` is available on PATH.
+ */
+export declare function isGitAvailable(): Promise<boolean>;
+/** Reset cached availability (for testing). */
+export declare function resetGitCache(): void;
+/**
+ * Find the Git repository root from a given directory.
+ * Returns null if not in a Git repo.
+ */
+export declare function findRepoRoot(cwd?: string): Promise<string | null>;
+/**
+ * Get the full HEAD commit SHA.
+ */
+export declare function getCurrentCommit(repoRoot: string): Promise<string | null>;
+/**
+ * Check if a commit hash is the same as HEAD.
+ */
+export declare function isStale(commentCommit: string, repoRoot: string): Promise<boolean>;
+/**
+ * Parse unified diff output into structured hunks.
+ */
+export declare function parseDiffHunks(diffOutput: string): DiffHunk[];
+/**
+ * Get diff hunks between two commits for a specific file.
+ */
+export declare function getDiff(fromCommit: string, toCommit: string, filePath: string, repoRoot: string): Promise<DiffHunk[]>;
+/**
+ * Calculate the net line shift for a given original line number
+ * based on diff hunks.
+ *
+ * Returns the number of lines to add to the original line number,
+ * or null if the line itself was modified/deleted.
+ */
+export declare function getLineShift(hunks: DiffHunk[], originalLine: number): {
+    shift: number;
+    modified: boolean;
+};
+/**
+ * Get the contents of a file at a specific commit.
+ * Returns null if unavailable.
+ */
+export declare function getFileAtCommit(commit: string, filePath: string, repoRoot: string): Promise<string | null>;
+/**
+ * Get list of staged files matching a pattern.
+ */
+export declare function getStagedFiles(repoRoot: string, pattern?: string): Promise<string[]>;
+/**
+ * Get staged diff hunks for a specific file.
+ */
+export declare function getStagedDiff(filePath: string, repoRoot: string): Promise<DiffHunk[]>;
+/**
+ * Detect file renames between two commits.
+ * Returns a map of old path → new path.
+ */
+export declare function detectRenames(fromCommit: string, toCommit: string, repoRoot: string): Promise<Map<string, string>>;
+/**
+ * Stage a file for commit.
+ */
+export declare function stageFile(filePath: string, repoRoot: string): Promise<void>;
+//# sourceMappingURL=git.d.ts.map

package/dist/lib/git.js

@@ -0,0 +1,246 @@
+/**
+ * MRSF Git Integration — Git-aware operations for re-anchoring and discovery.
+ *
+ * Uses child_process.execFile (no shell) for safety.
+ * All functions degrade gracefully when Git is unavailable.
+ */
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+const GIT_TIMEOUT = 10_000; // 10s
+// ---------------------------------------------------------------------------
+// Availability
+// ---------------------------------------------------------------------------
+let _gitAvailable = null;
+/**
+ * Check whether `git` is available on PATH.
+ */
+export async function isGitAvailable() {
+    if (_gitAvailable != null)
+        return _gitAvailable;
+    try {
+        await execFile("git", ["--version"], { timeout: GIT_TIMEOUT });
+        _gitAvailable = true;
+    }
+    catch {
+        _gitAvailable = false;
+    }
+    return _gitAvailable;
+}
+/** Reset cached availability (for testing). */
+export function resetGitCache() {
+    _gitAvailable = null;
+}
+// ---------------------------------------------------------------------------
+// Repository info
+// ---------------------------------------------------------------------------
+/**
+ * Find the Git repository root from a given directory.
+ * Returns null if not in a Git repo.
+ */
+export async function findRepoRoot(cwd) {
+    if (!(await isGitAvailable()))
+        return null;
+    try {
+        const { stdout } = await execFile("git", ["rev-parse", "--show-toplevel"], { cwd: cwd ?? process.cwd(), timeout: GIT_TIMEOUT });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the full HEAD commit SHA.
+ */
+export async function getCurrentCommit(repoRoot) {
+    if (!(await isGitAvailable()))
+        return null;
+    try {
+        const { stdout } = await execFile("git", ["rev-parse", "HEAD"], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a commit hash is the same as HEAD.
+ */
+export async function isStale(commentCommit, repoRoot) {
+    const head = await getCurrentCommit(repoRoot);
+    if (!head)
+        return false; // can't tell, assume not stale
+    // Normalize: compare by prefix match (short vs long SHA)
+    const minLen = Math.min(commentCommit.length, head.length);
+    return commentCommit.slice(0, minLen) !== head.slice(0, minLen);
+}
+// ---------------------------------------------------------------------------
+// Diff operations
+// ---------------------------------------------------------------------------
+/**
+ * Parse unified diff output into structured hunks.
+ */
+export function parseDiffHunks(diffOutput) {
+    const hunks = [];
+    const lines = diffOutput.split("\n");
+    let current = null;
+    for (const line of lines) {
+        const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+        if (hunkMatch) {
+            current = {
+                oldStart: parseInt(hunkMatch[1], 10),
+                oldCount: hunkMatch[2] != null ? parseInt(hunkMatch[2], 10) : 1,
+                newStart: parseInt(hunkMatch[3], 10),
+                newCount: hunkMatch[4] != null ? parseInt(hunkMatch[4], 10) : 1,
+                lines: [],
+            };
+            hunks.push(current);
+            continue;
+        }
+        if (current && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
+            current.lines.push(line);
+        }
+    }
+    return hunks;
+}
+/**
+ * Get diff hunks between two commits for a specific file.
+ */
+export async function getDiff(fromCommit, toCommit, filePath, repoRoot) {
+    if (!(await isGitAvailable()))
+        return [];
+    try {
+        const { stdout } = await execFile("git", [
+            "diff",
+            `${fromCommit}..${toCommit}`,
+            "--unified=0",
+            "--no-color",
+            "--",
+            filePath,
+        ], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        return parseDiffHunks(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Calculate the net line shift for a given original line number
+ * based on diff hunks.
+ *
+ * Returns the number of lines to add to the original line number,
+ * or null if the line itself was modified/deleted.
+ */
+export function getLineShift(hunks, originalLine) {
+    let cumulativeShift = 0;
+    for (const hunk of hunks) {
+        const oldEnd = hunk.oldStart + hunk.oldCount - 1;
+        // Hunk is entirely after our line — stop
+        if (hunk.oldStart > originalLine)
+            break;
+        // Our line falls within this hunk — it was modified
+        if (originalLine >= hunk.oldStart && originalLine <= oldEnd) {
+            return { shift: cumulativeShift, modified: true };
+        }
+        // Hunk is entirely before our line — accumulate shift
+        if (oldEnd < originalLine) {
+            cumulativeShift += hunk.newCount - hunk.oldCount;
+        }
+    }
+    return { shift: cumulativeShift, modified: false };
+}
+// ---------------------------------------------------------------------------
+// File at commit
+// ---------------------------------------------------------------------------
+/**
+ * Get the contents of a file at a specific commit.
+ * Returns null if unavailable.
+ */
+export async function getFileAtCommit(commit, filePath, repoRoot) {
+    if (!(await isGitAvailable()))
+        return null;
+    try {
+        const { stdout } = await execFile("git", ["show", `${commit}:${filePath}`], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Staged files
+// ---------------------------------------------------------------------------
+/**
+ * Get list of staged files matching a pattern.
+ */
+export async function getStagedFiles(repoRoot, pattern) {
+    if (!(await isGitAvailable()))
+        return [];
+    try {
+        const args = ["diff", "--cached", "--name-only", "--diff-filter=d"];
+        if (pattern)
+            args.push("--", pattern);
+        const { stdout } = await execFile("git", args, {
+            cwd: repoRoot,
+            timeout: GIT_TIMEOUT,
+        });
+        return stdout
+            .trim()
+            .split("\n")
+            .filter((f) => f.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get staged diff hunks for a specific file.
+ */
+export async function getStagedDiff(filePath, repoRoot) {
+    if (!(await isGitAvailable()))
+        return [];
+    try {
+        const { stdout } = await execFile("git", ["diff", "--cached", "--unified=0", "--no-color", "--", filePath], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        return parseDiffHunks(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Rename detection
+// ---------------------------------------------------------------------------
+/**
+ * Detect file renames between two commits.
+ * Returns a map of old path → new path.
+ */
+export async function detectRenames(fromCommit, toCommit, repoRoot) {
+    if (!(await isGitAvailable()))
+        return new Map();
+    try {
+        const { stdout } = await execFile("git", ["diff", "--name-status", "-M", `${fromCommit}..${toCommit}`], { cwd: repoRoot, timeout: GIT_TIMEOUT });
+        const renames = new Map();
+        for (const line of stdout.trim().split("\n")) {
+            const match = line.match(/^R\d*\t(.+)\t(.+)$/);
+            if (match) {
+                renames.set(match[1], match[2]);
+            }
+        }
+        return renames;
+    }
+    catch {
+        return new Map();
+    }
+}
+/**
+ * Stage a file for commit.
+ */
+export async function stageFile(filePath, repoRoot) {
+    if (!(await isGitAvailable()))
+        return;
+    await execFile("git", ["add", filePath], {
+        cwd: repoRoot,
+        timeout: GIT_TIMEOUT,
+    });
+}
+//# sourceMappingURL=git.js.map

package/dist/lib/parser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * MRSF Parser — load and parse MRSF sidecar files (YAML or JSON).
+ */
+import type { MrsfDocument } from "./types.js";
+/**
+ * Parse an MRSF sidecar file from disk.
+ */
+export declare function parseSidecar(filePath: string): Promise<MrsfDocument>;
+/**
+ * Parse MRSF sidecar content from a string.
+ * Detects JSON vs YAML based on content or optional filename hint.
+ */
+export declare function parseSidecarContent(content: string, filenameHint?: string): MrsfDocument;
+/**
+ * Read a Markdown document from disk and return its lines.
+ * Lines are 1-indexed in the returned array (index 0 is unused).
+ */
+export declare function readDocumentLines(filePath: string): Promise<string[]>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/lib/parser.js

@@ -0,0 +1,56 @@
+/**
+ * MRSF Parser — load and parse MRSF sidecar files (YAML or JSON).
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+/**
+ * Parse an MRSF sidecar file from disk.
+ */
+export async function parseSidecar(filePath) {
+    const abs = path.resolve(filePath);
+    const content = await readFile(abs, "utf-8");
+    return parseSidecarContent(content, abs);
+}
+/**
+ * Parse MRSF sidecar content from a string.
+ * Detects JSON vs YAML based on content or optional filename hint.
+ */
+export function parseSidecarContent(content, filenameHint) {
+    const trimmed = content.trim();
+    let parsed;
+    // Detect JSON by content or filename
+    const isJson = trimmed.startsWith("{") ||
+        (filenameHint && filenameHint.endsWith(".review.json"));
+    if (isJson) {
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse JSON: ${e.message}`);
+        }
+    }
+    else {
+        try {
+            parsed = yaml.load(trimmed);
+        }
+        catch (e) {
+            throw new Error(`Failed to parse YAML: ${e.message}`);
+        }
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("MRSF sidecar must be a YAML/JSON object");
+    }
+    return parsed;
+}
+/**
+ * Read a Markdown document from disk and return its lines.
+ * Lines are 1-indexed in the returned array (index 0 is unused).
+ */
+export async function readDocumentLines(filePath) {
+    const content = await readFile(path.resolve(filePath), "utf-8");
+    const lines = content.split("\n");
+    // Prepend empty element so lines[1] = first line (1-based)
+    return ["", ...lines];
+}
+//# sourceMappingURL=parser.js.map