diffninja 0.1.0

package/dist/review/input.d.ts

@@ -0,0 +1,10 @@
+import type { ReviewUnit } from "./types.js";
+/** Reject incomplete patches rather than silently omitting review work. */
+export declare function parseDiff(text: string): ReviewUnit[];
+export declare function resolveCommit(cwd: string, ref: string): string;
+export interface GitDiffInput {
+    diff: string;
+    from: string;
+    to: string;
+}
+export declare function gitDiff(cwd: string, from: string, to: string): GitDiffInput;

package/dist/review/input.js

@@ -0,0 +1,113 @@
+import { execFileSync } from "node:child_process";
+function pathName(raw) {
+    const value = raw.split("\t")[0];
+    if (value.startsWith('"')) {
+        // Keep Git's quoted path verbatim rather than guessing at octal escapes.
+        // A quoted path (or one containing " b/") therefore differs from the
+        // repo-relative path the engine reports, which downstream file matching and
+        // definition reads compare against.
+        return value;
+    }
+    return value.replace(/^[ab]\//, "");
+}
+/** Reject incomplete patches rather than silently omitting review work. */
+export function parseDiff(text) {
+    if (!text.trim())
+        return [];
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const units = [];
+    let file = "", metadata = [], found = false;
+    const add = (unit) => units.push({ ...unit, id: `hunk-${units.length + 1}` });
+    const flushMetadata = () => {
+        const important = metadata.filter(line => /^(old mode|new mode|rename |copy |similarity |dissimilarity |Binary files|GIT binary patch|Submodule|new file mode 120000|new file mode 160000)/.test(line));
+        if (important.length || (file && !found)) {
+            add({ file, header: "File metadata", diff: metadata.join("\n"), added: 0, removed: 0, oldStart: 0, newStart: 0,
+                special: "Binary, rename, mode, or metadata-only change needs manual review." });
+        }
+        metadata = [];
+        found = false;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("diff --git ")) {
+            flushMetadata();
+            file = / b\/(.*)$/.exec(line)?.[1] ?? line.slice(11);
+            metadata.push(line);
+            continue;
+        }
+        if (line.startsWith("diff --cc ") || line.startsWith("diff --combined ") || line.startsWith("@@@")) {
+            throw new Error("Combined merge diffs are unsupported. Supply a two-commit unified diff.");
+        }
+        if (line.startsWith("--- ") && lines[i + 1]?.startsWith("+++ ")) {
+            if (found)
+                flushMetadata();
+            const oldPath = pathName(line.slice(4));
+            const newPath = pathName(lines[++i].slice(4));
+            file = newPath === "/dev/null" ? oldPath : newPath;
+            metadata.push(line, lines[i]);
+            continue;
+        }
+        if (line.startsWith("@@")) {
+            if (!file)
+                throw new Error("Hunk has no file header.");
+            const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+            if (!match)
+                throw new Error(`Malformed hunk header: ${line}`);
+            let oldLeft = Number(match[2] ?? 1), newLeft = Number(match[4] ?? 1);
+            const body = [line];
+            let added = 0, removed = 0;
+            while (oldLeft > 0 || newLeft > 0) {
+                const next = lines[++i];
+                if (next === undefined)
+                    throw new Error(`Truncated hunk in ${file}`);
+                body.push(next);
+                if (next === "\")
+                    continue;
+                if (next.startsWith("+")) {
+                    newLeft--;
+                    added++;
+                }
+                else if (next.startsWith("-")) {
+                    oldLeft--;
+                    removed++;
+                }
+                else if (next.startsWith(" ")) {
+                    oldLeft--;
+                    newLeft--;
+                }
+                else
+                    throw new Error(`Invalid or truncated hunk in ${file}`);
+                if (oldLeft < 0 || newLeft < 0)
+                    throw new Error(`Hunk line counts do not match in ${file}`);
+            }
+            if (lines[i + 1] === "\")
+                body.push(lines[++i]);
+            const unit = { file, header: line, diff: body.join("\n"), added, removed,
+                oldStart: Number(match[1]), newStart: Number(match[3]) };
+            if (/^(new file mode|index).*\b(120000|160000)\b/m.test(metadata.join("\n"))) {
+                unit.special = "Symbolic link or submodule change needs manual review.";
+            }
+            add(unit);
+            found = true;
+            continue;
+        }
+        if (/^[ +-]/.test(line) && found && line.trim())
+            throw new Error(`Unexpected content outside hunk in ${file}`);
+        if (file)
+            metadata.push(line);
+        else if (line.trim())
+            throw new Error("Expected a unified diff with file headers.");
+    }
+    flushMetadata();
+    if (!units.length)
+        throw new Error("No reviewable changes found in input.");
+    return units;
+}
+export function resolveCommit(cwd, ref) {
+    return execFileSync("git", ["--no-replace-objects", "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd, encoding: "utf8" }).trim();
+}
+export function gitDiff(cwd, from, to) {
+    const base = resolveCommit(cwd, from), head = resolveCommit(cwd, to);
+    const diff = execFileSync("git", ["--no-replace-objects", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=5", base, head, "--"], { cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+    return { diff, from: base, to: head };
+}

package/dist/review/intent.d.ts

@@ -0,0 +1,4 @@
+import type { IntentCrossCheck, PullRequestIntent, ReviewAgendaEntry, AutomaticFinding } from "./evidence-types.js";
+import type { ReviewUnit } from "./types.js";
+/** Links are discovery aids, never a semantic entailment or a passing test. */
+export declare function crossCheckIntent(pr: PullRequestIntent | undefined, units: readonly ReviewUnit[], agenda: readonly ReviewAgendaEntry[], findings: readonly AutomaticFinding[]): IntentCrossCheck;

package/dist/review/intent.js

@@ -0,0 +1,75 @@
+const STOP_WORDS = Object.fromEntries("a about after all also an and any are as at be because been before being both but by can code could did do does during each either for from had has have if in into is it may might more most must no nor not of on only or other our over pr same should so some such than that the their them then there these they this those through to too under until up use using very was we were what when where which while who why will with would you your added add implementing implement introduced introduce updated update functionality capabilities comprehensive test tests coverage".split(" ").map(word => [word, true]));
+function terms(text) {
+    return new Set(text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().match(/[a-z][a-z0-9]+/g)?.filter(word => !Object.hasOwn(STOP_WORDS, word)).map(word => word.replace(/(?:ing|ies|s)$/u, "")).filter(word => word.length > 2) ?? []);
+}
+/** Keep author claims separate from generated release notes; never execute PR text. */
+function statements(pr) {
+    const claims = [];
+    if (pr.title.trim())
+        claims.push({ text: pr.title.trim(), origin: "title" });
+    let generatedComment = false;
+    let generatedHeadingDepth;
+    let comment = false;
+    let relevant = true;
+    for (const raw of pr.body.split(/\r?\n/u)) {
+        if (/<!--.*(?:auto-generated|release notes)/iu.test(raw))
+            generatedComment = true;
+        if (/<!--.*end of auto-generated/iu.test(raw)) {
+            generatedComment = false;
+            generatedHeadingDepth = undefined;
+            continue;
+        }
+        const heading = /^(#{1,6})\s/u.exec(raw);
+        if (heading) {
+            const depth = heading[1].length;
+            if (generatedHeadingDepth !== undefined && depth <= generatedHeadingDepth)
+                generatedHeadingDepth = undefined;
+            if (!generatedComment && /(?:ai[- ]generated|auto[- ]generated|summary by .*(?:bot|coderabbit|copilot))/iu.test(raw))
+                generatedHeadingDepth = depth;
+            relevant = generatedComment || generatedHeadingDepth !== undefined || !/(?:branch.*naming|pull request.*naming|what type of pr|what gif)/iu.test(raw);
+            continue;
+        }
+        if (raw.includes("<!--"))
+            comment = true;
+        if (comment) {
+            if (raw.includes("-->"))
+                comment = false;
+            continue;
+        }
+        const text = raw.trim().replace(/^[-*]\s+(?:\[[ xX]\]\s*)?/u, "");
+        if (!relevant || !text || /^<|^!\[|^\*\*[^*]+\*\*$/u.test(text))
+            continue;
+        claims.push({ text, origin: generatedComment || generatedHeadingDepth !== undefined ? "generated-summary" : "author" });
+    }
+    return claims;
+}
+/** Links are discovery aids, never a semantic entailment or a passing test. */
+export function crossCheckIntent(pr, units, agenda, findings) {
+    if (!pr || (!pr.title.trim() && !pr.body.trim()))
+        return {
+            verdict: "not-established",
+            summary: "Expected outcome not established: no PR title or description was supplied. Review the changed behavior and obtain explicit requirements before deciding whether this PR achieves its goal.",
+            claims: [],
+            obligations: ["Provide the expected behavior, including failure and boundary cases. No intended outcome was inferred from the diff."],
+        };
+    const indexed = units.map(unit => ({ unit, terms: terms(unit.file + "\n" + unit.diff.split("\n").filter(line => line.startsWith("+")).join("\n")) }));
+    const claims = statements(pr).map(claim => {
+        const wanted = [...terms(claim.text)];
+        const matches = indexed.map(({ unit, terms: actual }) => ({ unit, count: wanted.reduce((count, term) => count + (actual.has(term) ? 1 : 0), 0) }))
+            .filter(({ count }) => count >= Math.min(2, wanted.length) && wanted.length > 0)
+            .sort((a, b) => b.count - a.count || a.unit.file.localeCompare(b.unit.file) || a.unit.newStart - b.unit.newStart);
+        return { ...claim, status: matches.length ? "evidence-linked" : "not-established", unitIds: matches.slice(0, 8).map(({ unit }) => unit.id),
+            explanation: matches.length
+                ? "Changed code shares the named concepts below. These are navigation matches, not proof that the requirement is implemented correctly; inspect behavior and executable acceptance evidence."
+                : "No direct changed-code match was found. This is missing evidence, not proof that the claim is false." };
+    });
+    const obligations = [
+        "Confirm the intended success, partial-failure, and boundary outcomes. The PR text and static code do not establish end-to-end fulfillment.",
+        ...agenda.slice(0, 5).map(entry => entry.title),
+    ];
+    if (claims.some(claim => claim.origin === "generated-summary"))
+        obligations.push("Generated release notes are claims, not author-confirmed requirements or test-execution evidence.");
+    if (findings.length)
+        obligations.push("Resolve the automatic findings below within their stated scope; an unused error field or matching body alone does not prove that the intended outcome fails.");
+    return { verdict: "not-established", summary: "Implementation evidence is linked below, but achievement of the expected outcome is not established. Resolve the review decisions and verify the explicit behavior before concluding that the PR delivers its goal.", claims, obligations };
+}

package/dist/review/mcp-cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/review/mcp-cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createReviewServer } from "./mcp.js";
+try {
+    if (process.argv.length > 2)
+        throw new Error("diffninja-mcp accepts no arguments. Configure it as a stdio MCP server; pass inputs to review_diff.");
+    const server = createReviewServer();
+    // Closing the connection is what closes its connected review pages, and this
+    // transport cannot tell that the client hung up its end of the pipe, so EOF
+    // here is what ends the session. A signal still terminates the process the
+    // usual way, which takes the listener down with it.
+    let closing = false;
+    const shutdown = () => {
+        if (closing)
+            return;
+        closing = true;
+        void server.close().catch(() => { });
+    };
+    process.stdin.once("end", shutdown).once("close", shutdown);
+    await server.connect(new StdioServerTransport());
+}
+catch (error) {
+    console.error(`diffninja-mcp: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+}

package/dist/review/mcp.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface AnalysisScope {
+    readonly source: "repository" | "patch";
+    readonly note: string;
+}
+/**
+ * Rank a diff, or review one pull request. `mode` makes the caller's intent
+ * explicit: `auto` keeps the historical link detection, `connected` demands a
+ * link before anything is loaded, and `static` never navigates a link it finds
+ * inside a diff.
+ */
+export declare function createReviewServer(): McpServer;