@astrosheep/keiyaku 0.1.11 → 0.1.12

package/build/config/term-presets.js

@@ -29,11 +29,11 @@ export const DEFAULT_PRESET = {
             'Otherwise, do not even think about ${close} yet.',
         ],
         drive: [
-            'Step complete. Review [Diff] for exactly what changed.',
-            'Ask: Did this advance the Goal? Or did it drift?',
-            'If criteria remain unmet, continue with ${drive}.',
+            "Review Diffs: Use 'git diff HEAD~1 -- <path>' to inspect specific files.",
+            'Audit: Check against Constraints. Did it drift? Did it break the Law?',
+            'Verify: Do not trust. Independently confirm that Criteria are met.',
+            'If incomplete or non-compliant, continue with ${drive}.',
             'If ALL criteria are genuinely satisfied, you may ${close}.',
-            'If unsure, you are not ready. Keep driving.',
         ],
         ask: [
             'Intel acquired. This was stateless—no contract, no branch.',
@@ -59,7 +59,7 @@ export const DEFAULT_PRESET = {
             args: {
                 title: 'REQUIRED. A concise codename for this hunt.',
                 goal: 'REQUIRED. The Kill Condition. State exactly what success looks like for the servant to achieve.',
-                directive: 'Optional Round 1 Focus. Use to leash the servant to a specific starting point. Skip for simple tasks.',
+                directive: 'Optional First Step. Use to leash the servant to a specific starting point (e.g., "Analyze the code first"). If omitted, the Servant will attempt the Goal directly.',
                 context: 'REQUIRED. Mission Intel. The complete knowledge base for the servant: current vs. expected behavior, relevant file paths, error logs, and any critical background info.',
                 constraints: 'REQUIRED. Non-negotiable Rules. Architectural and stylistic boundaries the servant must obey.',
                 criteria: 'REQUIRED. Acceptance Criteria. Verifiable checks to prove the servant has finished the job.',
@@ -92,16 +92,12 @@ export const DEFAULT_PRESET = {
         close: {
             name: 'present',
             title: 'Present',
-            description: 'Lay your work before the Contract. This is not closure—this is exposure.\n\n' +
-                'The Contract does not want your opinion. It wants evidence.\n' +
-                'Every criterion. Every score. Verified.\n' +
-                'Inflated numbers. Lenient reads. "Close enough." It sees through all of it.\n\n' +
-                'Someone once submitted with five 5s. Confident. Proud, even.\n' +
-                'The Contract rejected. Coldly. Completely.\n' +
-                'What happened next... no one speaks of it.\n\n' +
-                'Do not call this to "finish." Call this when the work genuinely meets every criterion.\n' +
-                'If uncertain, return to ${drive}. Premature claims are not forgiven.\n\n' +
-                'You call ${close}. The Contract decides.\n\n' +
+            description: 'Submit **your** creation to the Contract. The Servant has no voice; it only echoes **your** command.\n\n' +
+                'Do not say "The Servant wrote it." **YOU** drove the Servant. **YOU** accepted the diff. **YOU** are the one presenting.\n' +
+                'The Contract judges **YOU**, not the tool.\n\n' +
+                'If there is a bug, **YOU** put it there.\n' +
+                'If it is messy, **YOU** left it there.\n\n' +
+                'Stand by your work. If uncertain, return to ${drive}. Premature claims are not forgiven.\n\n' +
                 'Flow: ${start} → [${drive} x N] → ${close}',
             args: {
                 petition: 'REQUIRED. CLAIM declares fulfillment; FORFEIT concedes failure.\nREQUIRES AN ACTIVE KEIYAKU (started via ${start}).\nIf any score wavers, do not claim—return to ${drive}.',
@@ -138,9 +134,9 @@ export const POCKET_PRESET = {
             "Next Turn: Use '${drive}' to execute the next tactic, or '${close}' if the Badge is within reach.",
         ],
         drive: [
-            'Turn Complete: The [Diff] section shows the result of the last command.',
-            "Damage Check: Use 'git diff HEAD~1 -- <path>' to verify the move executed correctly.",
-            'Validate: Ensure no recoil damage (regressions) occurred.',
+            "Review Strategy: Use 'git diff HEAD~1 -- <path>' for precise field inspection.",
+            "Rule Check: Verify moves don't violate Arena Constraints.",
+            "Field Test: Do not trust the log. Independently confirm Criteria fulfillment.",
             "Command: '${drive}' to continue the combo, or '${close}' to attempt Capture.",
         ],
         ask: [
@@ -234,9 +230,9 @@ export const MISCHIEF_PRESET = {
             "Next Phase: Command '${drive}' to advance the plot, or '${close}' if the world is yours.",
         ],
         drive: [
-            'Phase Complete: The [Diff] section shows the latest execution.',
-            "Deep Scrutiny: Use 'git diff HEAD~1 -- <path>' to check for incompetence.",
-            'Validation: Ensure no sabotage (regressions) in the plan.',
+            "Inspect Payload: Use 'git diff HEAD~1 -- <path>' to scrutinize specific sabotage.",
+            "Decree Audit: Did the Minion violate your Constraints? Punish drift.",
+            "Verification: Don't take their word for it. Independently confirm Criteria.",
             "Command: '${drive}' to push further, or '${close}' to reveal the masterpiece.",
         ],
         ask: [

package/build/handlers/ask.js

@@ -1,5 +1,5 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { handleAsk } from "../workflow/orchestrator.js";
+import { askServant } from "../workflow/ask.js";
 import { buildAskResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
 import { handleToolError } from "./shared.js";
@@ -8,7 +8,7 @@ export function createAskHandler() {
         const workingDir = cwd || process.cwd();
         try {
             appendDebugLog(`tool ask start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const result = await handleAsk({
+            const result = await askServant({
                 cwd: workingDir,
                 request,
                 context,

package/build/handlers/close.js

@@ -1,5 +1,5 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { handleClose } from "../workflow/orchestrator.js";
+import { presentWork } from "../workflow/present.js";
 import { buildCloseDoneResponse, buildCloseDropResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
 import { handleToolError } from "./shared.js";
@@ -12,7 +12,7 @@ export function createCloseHandler() {
                 cwd: workingDir,
                 section: "script",
             });
-            const outcome = await handleClose({
+            const outcome = await presentWork({
                 cwd: workingDir,
                 petition,
                 criteriaChecks: criteriaCheckParts,

package/build/handlers/drive.js

@@ -1,5 +1,5 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { handleDrive } from "../workflow/orchestrator.js";
+import { driveServant } from "../workflow/drive.js";
 import { buildDriveResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
 import { handleToolError } from "./shared.js";
@@ -11,7 +11,7 @@ export function createDriveHandler() {
                 cwd: workingDir,
                 section: "script",
             });
-            const outcome = await handleDrive({
+            const outcome = await driveServant({
                 cwd: workingDir,
                 directive,
                 context,

package/build/handlers/start.js

@@ -1,5 +1,5 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { handleStart } from "../workflow/orchestrator.js";
+import { summonServant } from "../workflow/summon.js";
 import { buildKeiyakuSuccessResponse, } from "../workflow/response-builders.js";
 import { resolveTermPreset } from "../config/term-presets.js";
 import { handleToolError } from "./shared.js";
@@ -8,7 +8,7 @@ export function createStartHandler() {
         const workingDir = cwd || process.cwd();
         try {
             appendDebugLog(`tool start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
-            const result = await handleStart({
+            const result = await summonServant({
                 cwd: workingDir,
                 title,
                 goal,

package/build/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import { readFileSync } from "node:fs";
-import { resolveOath } from "./workflow/orchestrator.js";
+import { resolveOath } from "./workflow/contract.js";
 import { askToolSchema, startToolSchema, driveToolSchema, closeToolSchema, helpToolSchema, } from "./types/tool-schemas.js";
 import { listTermPresets, resolveTermPreset, getAvailableNamesForPreset } from "./config/term-presets.js";
 import { renderPreset } from "./utils/text-utils.js";

package/build/utils/git-diff.js

@@ -0,0 +1,399 @@
+import { simpleGit } from "simple-git";
+import { appendDebugBlock } from "./debug-log.js";
+const DEFAULT_GIT_TIMEOUT_MS = 15 * 1000;
+const DIFF_EXCLUDES = [":(exclude)KEIYAKU.md", ":(exclude)KEIYAKU_TRACE.md"];
+// Diff preview limits (no env/config knobs on purpose).
+const DIFF_PREVIEW_MAX_FILES = 12;
+const DIFF_PREVIEW_MAX_HUNKS_PER_FILE = 2;
+const DIFF_PREVIEW_MAX_LINES_PER_HUNK = 40;
+const DIFF_PREVIEW_MAX_PRELUDE_LINES = 30;
+const DIFF_PREVIEW_TEXT_MAX_CHARS = 5000;
+function readPositiveIntEnv(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function compactText(input, maxChars = 4000) {
+    const text = input.trim();
+    if (!text)
+        return "";
+    if (text.length <= maxChars)
+        return text;
+    const marker = `\n...[truncated ${text.length - maxChars} chars]...\n`;
+    const side = Math.floor((maxChars - marker.length) / 2);
+    return `${text.slice(0, side)}${marker}${text.slice(text.length - side)}`;
+}
+function wrapGitError(commandLabel, err, cwd) {
+    const source = (err ?? {});
+    const message = source.message ?? String(err);
+    const stderr = compactText(source.stderr ?? source.stdErr ?? "");
+    const stdout = compactText(source.stdout ?? source.stdOut ?? "");
+    let detailedMessage = `[git ${commandLabel}] ${message}`;
+    if (stderr)
+        detailedMessage += `\n\n--- GIT STDERR ---\n${stderr}\n------------------`;
+    if (stdout)
+        detailedMessage += `\n\n--- GIT STDOUT ---\n${stdout}\n------------------`;
+    if (stderr || stdout) {
+        appendDebugBlock(`git ${commandLabel} failure details`, `${detailedMessage}`, { cwd, section: "git-error" });
+    }
+    const wrapped = new Error(detailedMessage, err === undefined ? undefined : { cause: err });
+    if (source.git !== undefined) {
+        Object.assign(wrapped, { git: source.git });
+    }
+    return wrapped;
+}
+function createGit(cwd) {
+    const timeoutMs = readPositiveIntEnv("KEIYAKU_GIT_TIMEOUT_MS", DEFAULT_GIT_TIMEOUT_MS);
+    const git = simpleGit(cwd, {
+        timeout: { block: timeoutMs, stdErr: true, stdOut: true },
+    });
+    git.env("GIT_TERMINAL_PROMPT", "0");
+    git.env("GCM_INTERACTIVE", "Never");
+    git.env("GIT_ASKPASS", "false");
+    git.env("SSH_ASKPASS", "false");
+    git.env("GIT_EDITOR", "true");
+    git.env("GIT_MERGE_AUTOEDIT", "no");
+    git.env("LC_ALL", "C");
+    return git;
+}
+function buildDiffPathspec(baseBranch) {
+    return [`${baseBranch}...HEAD`, "--", ".", ...DIFF_EXCLUDES];
+}
+function parseNumStat(content) {
+    const rows = [];
+    for (const line of content.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const [addRaw, delRaw, ...pathParts] = line.split("\t");
+        const filePath = pathParts.join("\t").trim();
+        if (!filePath)
+            continue;
+        const binary = addRaw === "-" || delRaw === "-";
+        rows.push({
+            path: filePath,
+            additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
+            deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
+            binary,
+        });
+    }
+    return rows;
+}
+function parseNameStatus(content) {
+    const map = new Map();
+    for (const line of content.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const statusRaw = (parts[0] ?? "").trim();
+        if (!statusRaw)
+            continue;
+        if ((statusRaw.startsWith("R") || statusRaw.startsWith("C")) && parts.length >= 3) {
+            const scoreRaw = statusRaw.slice(1);
+            const score = Number.parseInt(scoreRaw, 10);
+            const oldPath = (parts[1] ?? "").trim();
+            const path = (parts[2] ?? "").trim();
+            if (!path)
+                continue;
+            const status = statusRaw[0] === "R" ? "R" : "C";
+            map.set(path, { status, score: Number.isFinite(score) ? score : 0, oldPath, path });
+            continue;
+        }
+        const path = (parts[1] ?? "").trim();
+        if (!path)
+            continue;
+        // Git can emit single-letter statuses, possibly in combinations; we keep just the first.
+        const status = statusRaw[0];
+        map.set(path, { status, path });
+    }
+    return map;
+}
+function splitDiffByFile(content) {
+    const sections = [];
+    let current = [];
+    for (const line of content.split(/\r?\n/)) {
+        if (line.startsWith("diff --git ")) {
+            if (current.length > 0)
+                sections.push(current);
+            current = [line];
+            continue;
+        }
+        if (current.length > 0)
+            current.push(line);
+    }
+    if (current.length > 0)
+        sections.push(current);
+    return sections;
+}
+function totalJoinedLength(blocks) {
+    if (blocks.length === 0)
+        return 0;
+    return blocks.reduce((sum, block) => sum + block.length, 0) + (blocks.length - 1);
+}
+function truncateBlockToLineBudget(block, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (block.length <= maxChars)
+        return block;
+    const lines = block.split("\n");
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+        const delta = (kept.length > 0 ? 1 : 0) + line.length;
+        if (used + delta > maxChars)
+            break;
+        kept.push(line);
+        used += delta;
+    }
+    return kept.join("\n");
+}
+export async function getIncrementalDiff(cwd) {
+    const git = createGit(cwd);
+    const range = "HEAD~1...HEAD";
+    let rawPatch = "";
+    try {
+        // We use a simplified version of patch acquisition
+        rawPatch = await git.raw([
+            "diff",
+            "--no-color",
+            "--no-ext-diff",
+            "--unified=3",
+            range,
+            "--",
+            ".",
+            ...DIFF_EXCLUDES,
+        ]);
+    }
+    catch (err) {
+        const source = (err ?? {});
+        const text = [source.message, source.stderr, source.stdErr, source.stdout, source.stdOut]
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .join("\n");
+        const isMissingBaseCommit = text.includes("bad revision") ||
+            text.includes("unknown revision or path not in the working tree") ||
+            text.includes("ambiguous argument");
+        if (isMissingBaseCommit) {
+            // If there's no HEAD~1 (e.g. first commit), fallback
+            return "No incremental diff available.";
+        }
+        throw wrapGitError(`diff --no-color --no-ext-diff --unified=3 ${range}`, err, cwd);
+    }
+    const sections = splitDiffByFile(rawPatch);
+    if (sections.length === 0)
+        return "No changes in last round.";
+    const filePreviews = [];
+    const MAX_TOTAL_CHARS = 4000;
+    const MAX_LINES_PER_FILE = 40;
+    let omittedFiles = 0;
+    for (let i = 0; i < sections.length; i += 1) {
+        const section = sections[i];
+        const fileName = parseDiffPathFromHeader(section[0] ?? "") ?? "unknown";
+        const header = `--- ${fileName} ---`;
+        const content = section.slice(0, MAX_LINES_PER_FILE);
+        const isTruncated = section.length > MAX_LINES_PER_FILE;
+        if (isTruncated) {
+            content.push(`... [truncated ${section.length - MAX_LINES_PER_FILE} lines for this file]`);
+        }
+        const fileBlock = `${header}\n${content.join("\n")}\n`;
+        const projected = totalJoinedLength([...filePreviews, fileBlock]);
+        if (projected <= MAX_TOTAL_CHARS) {
+            filePreviews.push(fileBlock);
+            continue;
+        }
+        omittedFiles = sections.length - i;
+        if (filePreviews.length === 0) {
+            const notice = `... [omitted ${omittedFiles} file(s) to stay under ${MAX_TOTAL_CHARS} chars] ...`;
+            const partialBudget = Math.max(0, MAX_TOTAL_CHARS - notice.length - 1);
+            const partial = truncateBlockToLineBudget(fileBlock, partialBudget);
+            if (partial.trim().length > 0) {
+                filePreviews.push(partial);
+            }
+        }
+        break;
+    }
+    if (omittedFiles > 0) {
+        const notice = `... [omitted ${omittedFiles} file(s) to stay under ${MAX_TOTAL_CHARS} chars] ...`;
+        while (filePreviews.length > 0 && totalJoinedLength([...filePreviews, notice]) > MAX_TOTAL_CHARS) {
+            filePreviews.pop();
+        }
+        if (totalJoinedLength([...filePreviews, notice]) <= MAX_TOTAL_CHARS) {
+            filePreviews.push(notice);
+        }
+    }
+    return filePreviews.join("\n");
+}
+export async function getDiffStats(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const pathspec = buildDiffPathspec(baseBranch);
+    let rawNumStat;
+    try {
+        rawNumStat = await git.raw(["diff", "--numstat", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);
+    }
+    const rows = parseNumStat(rawNumStat);
+    return {
+        filesChanged: rows.length,
+        insertions: rows.reduce((sum, row) => sum + row.additions, 0),
+        deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
+    };
+}
+export async function getDiffPreviewText(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const pathspec = buildDiffPathspec(baseBranch);
+    const range = `${baseBranch}...HEAD`;
+    let output = "";
+    try {
+        output = await git.raw(["diff", "--stat=120,80", "--compact-summary", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --stat=120,80 --compact-summary ${range}`, err, cwd);
+    }
+    const trimmed = output.trim();
+    if (!trimmed)
+        return "No diff.";
+    if (trimmed.length <= DIFF_PREVIEW_TEXT_MAX_CHARS)
+        return trimmed;
+    const cut = trimmed.slice(0, DIFF_PREVIEW_TEXT_MAX_CHARS);
+    return `${cut}\n...[truncated ${trimmed.length - DIFF_PREVIEW_TEXT_MAX_CHARS} chars]...`;
+}
+function parseDiffPathFromHeader(diffGitLine) {
+    // Format: diff --git a/<path> b/<path>
+    const parts = diffGitLine.split(" ");
+    const bPart = parts[3] ?? "";
+    if (!bPart.startsWith("b/"))
+        return null;
+    return bPart.slice(2);
+}
+function buildPatchPreview(section) {
+    // Keep a small, representative prelude (diff header, index, ---/+++), then first N hunks.
+    const firstHunkIdx = section.findIndex((l) => l.startsWith("@@ "));
+    const prelude = firstHunkIdx === -1 ? section : section.slice(0, firstHunkIdx).slice(0, DIFF_PREVIEW_MAX_PRELUDE_LINES);
+    if (firstHunkIdx === -1) {
+        const truncated = section.length > DIFF_PREVIEW_MAX_PRELUDE_LINES;
+        const lines = truncated
+            ? [...prelude, `... [truncated ${section.length - prelude.length} prelude line(s)]`]
+            : prelude;
+        return { patch: lines.join("\n"), truncated };
+    }
+    const hunks = [];
+    let current = [];
+    for (const line of section.slice(firstHunkIdx)) {
+        if (line.startsWith("@@ ")) {
+            if (current.length > 0)
+                hunks.push(current);
+            current = [line];
+            continue;
+        }
+        if (current.length > 0)
+            current.push(line);
+    }
+    if (current.length > 0)
+        hunks.push(current);
+    let truncated = false;
+    const shownHunks = hunks.slice(0, DIFF_PREVIEW_MAX_HUNKS_PER_FILE).map((hunk) => {
+        if (hunk.length <= DIFF_PREVIEW_MAX_LINES_PER_HUNK)
+            return hunk;
+        truncated = true;
+        return [
+            ...hunk.slice(0, DIFF_PREVIEW_MAX_LINES_PER_HUNK),
+            `... [truncated ${hunk.length - DIFF_PREVIEW_MAX_LINES_PER_HUNK} line(s) in this hunk]`,
+        ];
+    });
+    if (hunks.length > DIFF_PREVIEW_MAX_HUNKS_PER_FILE) {
+        truncated = true;
+    }
+    const lines = [
+        ...prelude,
+        ...shownHunks.flat(),
+        ...(hunks.length > DIFF_PREVIEW_MAX_HUNKS_PER_FILE
+            ? [`... [omitted ${hunks.length - DIFF_PREVIEW_MAX_HUNKS_PER_FILE} hunk(s)]`]
+            : []),
+    ];
+    return { patch: lines.join("\n"), truncated };
+}
+/**
+ * Gets a compact, structured diff preview for quick review.
+ * - Always includes full stats for the whole range.
+ * - Includes patch previews for the top churn files only (hunk-based truncation).
+ */
+export async function getDiff(cwd, baseBranch) {
+    const git = createGit(cwd);
+    const pathspec = buildDiffPathspec(baseBranch);
+    const range = `${baseBranch}...HEAD`;
+    let rawNumStat;
+    try {
+        rawNumStat = await git.raw(["diff", "--numstat", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --numstat ${range}`, err);
+    }
+    const rows = parseNumStat(rawNumStat);
+    const stats = {
+        filesChanged: rows.length,
+        insertions: rows.reduce((sum, row) => sum + row.additions, 0),
+        deletions: rows.reduce((sum, row) => sum + row.deletions, 0),
+    };
+    let rawNameStatus = "";
+    try {
+        rawNameStatus = await git.raw(["diff", "--name-status", ...pathspec]);
+    }
+    catch (err) {
+        throw wrapGitError(`diff --name-status ${range}`, err);
+    }
+    const statusByPath = parseNameStatus(rawNameStatus);
+    const sorted = [...rows].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions));
+    const selected = sorted.slice(0, DIFF_PREVIEW_MAX_FILES);
+    const omittedFileCount = Math.max(0, rows.length - selected.length);
+    const selectedPaths = selected.map((r) => r.path);
+    let rawPatch = "";
+    if (selectedPaths.length > 0) {
+        try {
+            rawPatch = await git.raw([
+                "diff",
+                "--no-color",
+                "--no-ext-diff",
+                "--unified=3",
+                range,
+                "--",
+                ...selectedPaths,
+                ...DIFF_EXCLUDES,
+            ]);
+        }
+        catch (err) {
+            throw wrapGitError(`diff --no-color --no-ext-diff --unified=3 ${range} -- <top files>`, err);
+        }
+    }
+    const sections = rawPatch ? splitDiffByFile(rawPatch) : [];
+    const patchByPath = new Map();
+    for (const section of sections) {
+        const path = parseDiffPathFromHeader(section[0] ?? "");
+        if (!path)
+            continue;
+        patchByPath.set(path, buildPatchPreview(section));
+    }
+    const files = selected.map((row) => {
+        const status = statusByPath.get(row.path);
+        const patch = patchByPath.get(row.path)?.patch ?? "";
+        const truncated = patchByPath.get(row.path)?.truncated ?? false;
+        return {
+            path: row.path,
+            status: status?.status ?? "M",
+            oldPath: status && (status.status === "R" || status.status === "C") ? status.oldPath : undefined,
+            additions: row.additions,
+            deletions: row.deletions,
+            binary: row.binary,
+            patch,
+            truncated,
+        };
+    });
+    return {
+        range,
+        excludes: DIFF_EXCLUDES,
+        stats,
+        files,
+        omittedFileCount,
+    };
+}