@mcarvin/smart-diff 1.0.0

package/dist/index.cjs

@@ -0,0 +1,652 @@
+'use strict';
+
+var node_path = require('node:path');
+var simpleGit = require('simple-git');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function resolveLlmBaseUrl() {
+    var _a, _b, _c;
+    return (_b = (_a = process.env.LLM_BASE_URL) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : (_c = process.env.OPENAI_BASE_URL) === null || _c === void 0 ? void 0 : _c.trim();
+}
+function parseHeaderJsonObject(raw) {
+    const trimmed = raw === null || raw === void 0 ? void 0 : raw.trim();
+    if (!trimmed)
+        return {};
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            return {};
+        }
+        const out = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === 'string' && value.length > 0) {
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function parseLlmDefaultHeadersFromEnv() {
+    const base = parseHeaderJsonObject(process.env.OPENAI_DEFAULT_HEADERS);
+    const override = parseHeaderJsonObject(process.env.LLM_DEFAULT_HEADERS);
+    const merged = Object.assign(Object.assign({}, base), override);
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function findAuthorizationHeaderName(headers) {
+    return Object.keys(headers).find((k) => k.toLowerCase() === 'authorization');
+}
+function stripBearerPrefix(value) {
+    var _a;
+    const trimmed = value.trim();
+    const match = /^Bearer\s+(\S+)/i.exec(trimmed);
+    return (_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : trimmed;
+}
+function splitPromotableAuthorizationFromHeaders(headers) {
+    const authName = findAuthorizationHeaderName(headers);
+    if (!authName) {
+        return { defaultHeaders: headers };
+    }
+    const raw = headers[authName];
+    if (!raw) {
+        return { defaultHeaders: headers };
+    }
+    const token = stripBearerPrefix(raw);
+    const looksBearer = /^Bearer\s+\S+/i.test(raw.trim());
+    const looksOpenAiKey = /^sk-/i.test(token);
+    if (!looksBearer && !looksOpenAiKey) {
+        return { defaultHeaders: headers };
+    }
+    const next = Object.assign({}, headers);
+    delete next[authName];
+    return { defaultHeaders: next, apiKeyFromAuthHeader: token };
+}
+function shouldUseLlmGateway() {
+    var _a, _b, _c;
+    const apiKey = (_b = (_a = process.env.LLM_API_KEY) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : (_c = process.env.OPENAI_API_KEY) === null || _c === void 0 ? void 0 : _c.trim();
+    if (apiKey)
+        return true;
+    if (resolveLlmBaseUrl())
+        return true;
+    const jsonHeaders = parseLlmDefaultHeadersFromEnv();
+    if (jsonHeaders && Object.keys(jsonHeaders).length > 0)
+        return true;
+    return false;
+}
+function resolveOpenAiLikeClientInit() {
+    var _a, _b, _c, _d, _e;
+    const baseURL = resolveLlmBaseUrl();
+    const mergedHeaders = (_a = parseLlmDefaultHeadersFromEnv()) !== null && _a !== void 0 ? _a : {};
+    const envApiKey = (_e = (_c = (_b = process.env.LLM_API_KEY) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : (_d = process.env.OPENAI_API_KEY) === null || _d === void 0 ? void 0 : _d.trim()) !== null && _e !== void 0 ? _e : '';
+    let defaultHeaders;
+    let apiKey = envApiKey;
+    if (apiKey.length === 0) {
+        const split = splitPromotableAuthorizationFromHeaders(mergedHeaders);
+        if (split.apiKeyFromAuthHeader) {
+            apiKey = split.apiKeyFromAuthHeader;
+        }
+        defaultHeaders = Object.keys(split.defaultHeaders).length > 0 ? split.defaultHeaders : undefined;
+    }
+    else {
+        defaultHeaders = Object.keys(mergedHeaders).length > 0 ? mergedHeaders : undefined;
+    }
+    return Object.assign(Object.assign({ apiKey: apiKey.length > 0 ? apiKey : 'unused' }, (baseURL ? { baseURL } : {})), (defaultHeaders ? { defaultHeaders } : {}));
+}
+function createOpenAiLikeClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { default: OpenAI } = yield import('openai');
+        return new OpenAI(resolveOpenAiLikeClientInit());
+    });
+}
+
+const DEFAULT_LLM_MAX_DIFF_CHARS = 120000;
+function resolveLlmMaxDiffChars(cliOverride) {
+    var _a;
+    if (cliOverride !== undefined && Number.isFinite(cliOverride) && cliOverride > 0) {
+        return Math.trunc(cliOverride);
+    }
+    const raw = (_a = process.env.LLM_MAX_DIFF_CHARS) === null || _a === void 0 ? void 0 : _a.trim();
+    if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return DEFAULT_LLM_MAX_DIFF_CHARS;
+}
+function truncateUnifiedDiffForLlm(diffText, maxChars) {
+    if (diffText.length <= maxChars) {
+        return diffText;
+    }
+    const marker = `\n\n--- TRUNCATED: unified diff was ${diffText.length} characters; only the first ${maxChars} were sent. Narrow the ref range, adjust commit/path filters, or raise maxDiffChars / LLM_MAX_DIFF_CHARS only if your model context allows. ---\n`;
+    return diffText.slice(0, maxChars) + marker;
+}
+const DEFAULT_GIT_DIFF_SYSTEM_PROMPT = `You are a senior software engineer helping developers understand code and configuration changes from the git context they supplied.
+You receive: commit subject lines (when available), changed file paths, and unified git patch(es)—either one range diff or concatenated per-commit patches, depending on how the diff was produced. Patches may be truncated mid-section with an explicit marker—do not infer changes beyond visible lines.
+Explain what changed in terms of behavior, APIs, data, configuration, security, and operational risk. Tie claims to the patch when possible.
+Produce a concise, developer-focused summary in Markdown.
+Use sections that fit the change (for example: Highlights, Breaking or risky changes, API / contract changes, Data & schema, Configuration & infra, Security & auth, Tests & quality). Omit empty sections.
+Group related changes; do not list every individual file. When multiple commits appear in the context, briefly separate notable themes by commit when helpful.
+If the user message includes a Team line, use that exact team name in the summary title (for example: "## <Team> – Change summary" or similar).`;
+const LLM_GATEWAY_REQUIRED_MESSAGE = 'No LLM gateway configured. Set OPENAI_API_KEY or LLM_API_KEY, and/or LLM_BASE_URL or OPENAI_BASE_URL, ' +
+    'and/or JSON in OPENAI_DEFAULT_HEADERS or LLM_DEFAULT_HEADERS. ' +
+    'Alternatively pass openAiClientProvider to generateSummary or summarizeGitDiff.';
+function generateSummary(diffText, fileNames, commits, flags, openAiClientProvider, diffSummary) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!shouldUseLlmGateway() && openAiClientProvider === undefined) {
+            throw new Error(LLM_GATEWAY_REQUIRED_MESSAGE);
+        }
+        const maxDiffChars = resolveLlmMaxDiffChars(flags.maxDiffChars);
+        const diffForLlm = truncateUnifiedDiffForLlm(diffText, maxDiffChars);
+        const userContent = buildOpenAiUserContent(flags, commits, fileNames, diffForLlm, diffSummary);
+        return callOpenAi(userContent, (_a = flags.model) !== null && _a !== void 0 ? _a : 'gpt-4o-mini', (_b = flags.systemPrompt) !== null && _b !== void 0 ? _b : DEFAULT_GIT_DIFF_SYSTEM_PROMPT, openAiClientProvider !== null && openAiClientProvider !== void 0 ? openAiClientProvider : (() => __awaiter(this, void 0, void 0, function* () { return createOpenAiLikeClient(); })));
+    });
+}
+function formatRegexFilterLines(flags) {
+    var _a, _b;
+    const includes = ((_a = flags.commitMessageIncludeRegexes) !== null && _a !== void 0 ? _a : []).map((s) => s.trim()).filter(Boolean);
+    const excludes = ((_b = flags.commitMessageExcludeRegexes) !== null && _b !== void 0 ? _b : []).map((s) => s.trim()).filter(Boolean);
+    const incLine = includes.length > 0
+        ? `Commit message include regexes (OR): ${includes.map((r) => JSON.stringify(r)).join(', ')}\n`
+        : '';
+    const excLine = excludes.length > 0
+        ? `Commit message exclude regexes: ${excludes.map((r) => JSON.stringify(r)).join(', ')}\n`
+        : '';
+    if (!incLine && !excLine) {
+        return 'Commit message filters: none.\nGit context shape: single unified diff for the full ref range.\n';
+    }
+    return (`${incLine}${excLine}` +
+        'Git context shape: concatenated per-commit unified patches for commits that pass the message filters.\n');
+}
+function buildOpenAiUserContent(flags, commits, fileNames, diffText, diffSummary) {
+    var _a, _b;
+    const from = flags.from;
+    const to = (_a = flags.to) !== null && _a !== void 0 ? _a : 'HEAD';
+    const team = (_b = flags.team) === null || _b === void 0 ? void 0 : _b.trim();
+    const ts = new Date().toISOString();
+    const teamLine = team ? `Team: ${team}\n` : '';
+    const filterBlock = formatRegexFilterLines(flags);
+    const commitBlock = commits.length > 0
+        ? commits.map((c) => `- ${c.hash.slice(0, 7)} ${c.message.replace(/\r?\n/g, ' ')}`).join('\n')
+        : '- (no commits in range after filtering)';
+    const pathsBlock = fileNames.length > 0 ? fileNames.join('\n') : '(no paths in diff scope)';
+    const structuredDiffSection = diffSummary
+        ? `=== Structured git context (JSON summary) ===\n${JSON.stringify(diffSummary, null, 2)}\n\n`
+        : '';
+    return (`${teamLine}` +
+        `Date: ${ts}\n\n` +
+        `Git refs: ${from}..${to}\n` +
+        filterBlock +
+        '\n' +
+        '=== Included commits (subject lines) ===\n' +
+        `${commitBlock}\n\n` +
+        '=== Changed paths ===\n' +
+        `${pathsBlock}\n\n` +
+        structuredDiffSection +
+        '=== Git context (unified diff(s); patches may be truncated with an explicit marker) ===\n' +
+        diffText);
+}
+function callOpenAi(userContent, model, systemPrompt, openAiClientProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const client = yield openAiClientProvider();
+        const maxTokensRaw = (_a = process.env.LLM_MAX_TOKENS) !== null && _a !== void 0 ? _a : process.env.OPENAI_MAX_TOKENS;
+        const parsed = maxTokensRaw !== undefined ? Number.parseInt(maxTokensRaw, 10) : 4000;
+        const maxTokens = Number.isFinite(parsed) && parsed > 0 ? parsed : 4000;
+        const response = yield client.chat.completions.create({
+            model,
+            messages: [
+                {
+                    role: 'system',
+                    content: systemPrompt,
+                },
+                {
+                    role: 'user',
+                    content: userContent,
+                },
+            ],
+            temperature: 0.2,
+            max_tokens: maxTokens,
+        });
+        const typedResponse = response;
+        const text = (_f = (_e = (_d = (_c = (_b = typedResponse.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.message) === null || _d === void 0 ? void 0 : _d.content) === null || _e === void 0 ? void 0 : _e.trim()) !== null && _f !== void 0 ? _f : '';
+        return text.length > 0 ? text : 'No summary generated by OpenAI.';
+    });
+}
+
+function createGitClient(cwd = process.cwd()) {
+    return simpleGit.simpleGit(cwd);
+}
+function getCommits(git, from, to) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const logResult = yield git.log({ from, to });
+        return logResult.all;
+    });
+}
+function compileRegex(pattern, label) {
+    try {
+        return new RegExp(pattern, 'i');
+    }
+    catch (_a) {
+        throw new Error(`Invalid ${label} regular expression: ${JSON.stringify(pattern)}`);
+    }
+}
+function filterCommitsByMessageRegexes(commits, includePatterns, excludePatterns) {
+    const includes = (includePatterns !== null && includePatterns !== void 0 ? includePatterns : []).map((p) => p.trim()).filter((p) => p.length > 0);
+    const excludes = (excludePatterns !== null && excludePatterns !== void 0 ? excludePatterns : []).map((p) => p.trim()).filter((p) => p.length > 0);
+    const includeRes = includes.map((p, i) => compileRegex(p, `commit message include pattern[${i}]`));
+    const excludeRes = excludes.map((p, i) => compileRegex(p, `commit message exclude pattern[${i}]`));
+    return commits.filter((c) => {
+        for (const ex of excludeRes) {
+            if (ex.test(c.message))
+                return false;
+        }
+        if (includeRes.length > 0 && !includeRes.some((r) => r.test(c.message)))
+            return false;
+        return true;
+    });
+}
+function getRepoRoot(git) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const root = yield git.revparse(['--show-toplevel']);
+        return root.trim();
+    });
+}
+function normalizeRepoRelativePath(p) {
+    const trimmed = p.trim().replace(/\\/g, '/');
+    const noLeading = trimmed.replace(/^\/+/, '');
+    const noTrailingSlash = noLeading.replace(/\/+$/, '');
+    return noTrailingSlash.length > 0 ? noTrailingSlash : '.';
+}
+function assertPathUnderRepo(repoRoot, userPath) {
+    const abs = node_path.resolve(repoRoot, userPath);
+    const rel = node_path.relative(repoRoot, abs);
+    if (rel === '..') {
+        throw new Error(`Path escapes repository root: ${JSON.stringify(userPath)}`);
+    }
+    const segments = rel.split(/[/\\]/);
+    if (segments.includes('..')) {
+        throw new Error(`Path escapes repository root: ${JSON.stringify(userPath)}`);
+    }
+}
+function buildDiffPathspecs(repoRoot, pathFilter) {
+    var _a, _b, _c, _d;
+    const includeRaw = (_b = (_a = pathFilter === null || pathFilter === void 0 ? void 0 : pathFilter.includeFolders) === null || _a === void 0 ? void 0 : _a.filter((p) => p.trim().length > 0)) !== null && _b !== void 0 ? _b : [];
+    const excludeRaw = (_d = (_c = pathFilter === null || pathFilter === void 0 ? void 0 : pathFilter.excludeFolders) === null || _c === void 0 ? void 0 : _c.filter((p) => p.trim().length > 0)) !== null && _d !== void 0 ? _d : [];
+    const includes = includeRaw.map(normalizeRepoRelativePath).filter((p) => p !== '.' && p !== '');
+    const excludes = excludeRaw.map(normalizeRepoRelativePath).filter((p) => p !== '.' && p !== '');
+    const toValidate = includes.length > 0 ? includes : ['.'];
+    for (const inc of toValidate) {
+        assertPathUnderRepo(repoRoot, inc);
+    }
+    for (const exc of excludes) {
+        assertPathUnderRepo(repoRoot, exc);
+    }
+    const specs = [];
+    if (includes.length === 0) {
+        specs.push('.');
+    }
+    else {
+        for (const inc of includes) {
+            specs.push(inc);
+        }
+    }
+    for (const exc of excludes) {
+        specs.push(`:(exclude)${exc}`);
+    }
+    return specs;
+}
+function getDiffPathContext(git, pathFilter, repoRootOverride) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const repoRoot = repoRootOverride !== null && repoRootOverride !== void 0 ? repoRootOverride : (yield getRepoRoot(git));
+        const specs = buildDiffPathspecs(repoRoot, pathFilter);
+        return { repoRoot, specs };
+    });
+}
+function getDiff(git, from, to, commits, filterByCommits, pathFilter, repoRootOverride) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { specs } = yield getDiffPathContext(git, pathFilter, repoRootOverride);
+        if (!filterByCommits) {
+            return git.diff([`${from}..${to}`, '--', ...specs]);
+        }
+        const patches = yield Promise.all(commits.map((c) => git.diff([`${c.hash}^!`, '--', ...specs])));
+        return patches.filter(Boolean).join('\n');
+    });
+}
+function getDiffSummary(git, from, to, commits, filterByCommits, pathFilter, repoRootOverride) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { specs } = yield getDiffPathContext(git, pathFilter, repoRootOverride);
+        if (!filterByCommits) {
+            const [numOutput, nameOutput] = yield Promise.all([
+                git.diff(['--numstat', `${from}..${to}`, '--', ...specs]),
+                git.diff(['--name-status', `${from}..${to}`, '--', ...specs]),
+            ]);
+            return buildDiffSummaryFromGitOutputs(nameOutput, numOutput);
+        }
+        const pairs = yield Promise.all(commits.map((c) => __awaiter(this, void 0, void 0, function* () {
+            const range = `${c.hash}^!`;
+            const [numOutput, nameOutput] = yield Promise.all([
+                git.diff(['--numstat', range, '--', ...specs]),
+                git.diff(['--name-status', range, '--', ...specs]),
+            ]);
+            return { numOutput, nameOutput };
+        })));
+        const nameJoined = pairs
+            .map((p) => p.nameOutput)
+            .filter(Boolean)
+            .join('\n');
+        const numJoined = pairs
+            .map((p) => p.numOutput)
+            .filter(Boolean)
+            .join('\n');
+        return buildDiffSummaryFromGitOutputs(nameJoined, numJoined);
+    });
+}
+function getChangedFiles(git, from, to, commits, filterByCommits, pathFilter, repoRootOverride) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { specs } = yield getDiffPathContext(git, pathFilter, repoRootOverride);
+        if (!filterByCommits) {
+            const output = yield git.diff(['--name-only', `${from}..${to}`, '--', ...specs]);
+            return output
+                .split(/\r?\n/)
+                .map((f) => f.trim())
+                .filter(Boolean);
+        }
+        const fileSet = new Set();
+        yield Promise.all(commits.map((c) => __awaiter(this, void 0, void 0, function* () {
+            const output = yield git.show(['--name-only', '--pretty=format:', c.hash, '--', ...specs]);
+            output
+                .split(/\r?\n/)
+                .map((f) => f.trim())
+                .filter(Boolean)
+                .forEach((f) => fileSet.add(f));
+        })));
+        return Array.from(fileSet);
+    });
+}
+function mapGitStatus(statusCode) {
+    if (statusCode.startsWith('A'))
+        return 'added';
+    if (statusCode.startsWith('D'))
+        return 'deleted';
+    if (statusCode.startsWith('R'))
+        return 'renamed';
+    if (statusCode.startsWith('C'))
+        return 'copied';
+    if (statusCode.startsWith('T'))
+        return 'type-changed';
+    if (statusCode.startsWith('M'))
+        return 'modified';
+    return 'unknown';
+}
+function mergeStatus(existing, next) {
+    if (existing === next)
+        return existing;
+    const precedence = ['deleted', 'added', 'renamed', 'copied', 'type-changed', 'modified', 'unknown'];
+    return precedence.indexOf(existing) <= precedence.indexOf(next) ? existing : next;
+}
+function parseNameStatusLines(nameStatusOutput) {
+    var _a;
+    const entries = [];
+    for (const rawLine of nameStatusOutput.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const parts = line.split('\t');
+        if (parts.length < 2)
+            continue;
+        const statusToken = (_a = parts[0]) !== null && _a !== void 0 ? _a : '';
+        const status = mapGitStatus(statusToken);
+        if (statusToken.startsWith('R') || statusToken.startsWith('C')) {
+            if (parts.length < 3)
+                continue;
+            const oldPath = parts[1];
+            const newPath = parts[2];
+            if (oldPath === undefined || newPath === undefined)
+                continue;
+            entries.push({ path: newPath, status, oldPath });
+        }
+        else {
+            const pathOnly = parts[1];
+            if (pathOnly === undefined)
+                continue;
+            entries.push({ path: pathOnly, status });
+        }
+    }
+    return entries;
+}
+function mergeNameEntriesByPath(entries) {
+    var _a;
+    const byPath = new Map();
+    for (const e of entries) {
+        const existing = byPath.get(e.path);
+        if (!existing) {
+            byPath.set(e.path, Object.assign({}, e));
+        }
+        else {
+            existing.status = mergeStatus(existing.status, e.status);
+            if (e.oldPath) {
+                existing.oldPath = (_a = existing.oldPath) !== null && _a !== void 0 ? _a : e.oldPath;
+            }
+        }
+    }
+    return byPath;
+}
+function numStatPathToLookupKey(pathField) {
+    const brace = /^(.*)\{(.+) => (.+)\}$/.exec(pathField);
+    if (!brace) {
+        return pathField;
+    }
+    const dirRaw = brace[1];
+    const toSeg = brace[3].trim();
+    return `${dirRaw}${toSeg}`;
+}
+function accumulateNumStat(numStatOutput, into) {
+    var _a, _b, _c;
+    for (const rawLine of numStatOutput.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const parts = line.split('\t');
+        if (parts.length < 3)
+            continue;
+        const addStr = (_a = parts[0]) !== null && _a !== void 0 ? _a : '';
+        const delStr = (_b = parts[1]) !== null && _b !== void 0 ? _b : '';
+        const pathField = parts.slice(2).join('\t');
+        const additions = addStr !== '-' ? Number.parseInt(addStr, 10) || 0 : 0;
+        const deletions = delStr !== '-' ? Number.parseInt(delStr, 10) || 0 : 0;
+        const key = numStatPathToLookupKey(pathField);
+        const prev = (_c = into.get(key)) !== null && _c !== void 0 ? _c : { additions: 0, deletions: 0 };
+        into.set(key, { additions: prev.additions + additions, deletions: prev.deletions + deletions });
+    }
+}
+function diffStatusToSyntheticPrefix(status) {
+    switch (status) {
+        case 'added':
+            return 'A';
+        case 'deleted':
+            return 'D';
+        case 'renamed':
+            return 'R100';
+        case 'copied':
+            return 'C100';
+        case 'type-changed':
+            return 'T';
+        case 'modified':
+            return 'M';
+        default:
+            return 'X';
+    }
+}
+function buildDiffSummaryFromGitOutputs(nameStatusOutput, numStatOutput) {
+    var _a;
+    const numMap = new Map();
+    accumulateNumStat(numStatOutput, numMap);
+    const mergedName = mergeNameEntriesByPath(parseNameStatusLines(nameStatusOutput));
+    const syntheticLines = [];
+    for (const [path, meta] of mergedName) {
+        const counts = (_a = numMap.get(path)) !== null && _a !== void 0 ? _a : { additions: 0, deletions: 0 };
+        const prefix = diffStatusToSyntheticPrefix(meta.status);
+        if (meta.oldPath) {
+            syntheticLines.push(`${prefix}\t${counts.additions}\t${counts.deletions}\t${meta.oldPath}\t${path}`);
+        }
+        else {
+            syntheticLines.push(`${prefix}\t${counts.additions}\t${counts.deletions}\t${path}`);
+        }
+    }
+    return parseDiffSummary(syntheticLines.join('\n'));
+}
+function parseDiffSummary(diffOutput) {
+    var _a, _b, _c;
+    const fileMap = new Map();
+    for (const rawLine of diffOutput.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const parts = line.split('\t');
+        if (parts.length < 3)
+            continue;
+        const statusToken = (_a = parts.shift()) !== null && _a !== void 0 ? _a : '';
+        const status = mapGitStatus(statusToken);
+        const additions = parts[0] && parts[0] !== '-' ? Number.parseInt(parts[0], 10) || 0 : 0;
+        const deletions = parts[1] && parts[1] !== '-' ? Number.parseInt(parts[1], 10) || 0 : 0;
+        let oldPath;
+        let newPath;
+        if (parts.length === 3) {
+            newPath = parts[2];
+        }
+        else if (parts.length === 4) {
+            oldPath = parts[2];
+            newPath = parts[3];
+        }
+        else {
+            continue;
+        }
+        const path = newPath;
+        const existing = fileMap.get(path);
+        if (existing) {
+            existing.additions += additions;
+            existing.deletions += deletions;
+            existing.status = mergeStatus(existing.status, status);
+            if (oldPath)
+                existing.oldPath = (_b = existing.oldPath) !== null && _b !== void 0 ? _b : oldPath;
+            existing.newPath = (_c = existing.newPath) !== null && _c !== void 0 ? _c : newPath;
+        }
+        else {
+            fileMap.set(path, {
+                path,
+                status,
+                additions,
+                deletions,
+                oldPath,
+                newPath: oldPath ? newPath : undefined,
+            });
+        }
+    }
+    const files = Array.from(fileMap.values());
+    return {
+        files,
+        totalFiles: files.length,
+        totalAdditions: files.reduce((sum, file) => sum + file.additions, 0),
+        totalDeletions: files.reduce((sum, file) => sum + file.deletions, 0),
+    };
+}
+
+function hasNonEmptyTrimmed(arr) {
+    return (arr !== null && arr !== void 0 ? arr : []).some((s) => s.trim().length > 0);
+}
+function shouldFilterByCommits(allCommits, filtered, opts) {
+    if (hasNonEmptyTrimmed(opts.commitMessageIncludeRegexes) || hasNonEmptyTrimmed(opts.commitMessageExcludeRegexes)) {
+        return true;
+    }
+    return filtered.length !== allCommits.length;
+}
+function summarizeGitDiff(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const git = (_a = options.git) !== null && _a !== void 0 ? _a : createGitClient(options.cwd);
+        const from = options.from;
+        const to = (_b = options.to) !== null && _b !== void 0 ? _b : 'HEAD';
+        const pathFilter = hasNonEmptyTrimmed(options.includeFolders) || hasNonEmptyTrimmed(options.excludeFolders)
+            ? {
+                includeFolders: options.includeFolders,
+                excludeFolders: options.excludeFolders,
+            }
+            : undefined;
+        const allCommits = yield getCommits(git, from, to);
+        const filteredCommits = filterCommitsByMessageRegexes(allCommits, options.commitMessageIncludeRegexes, options.commitMessageExcludeRegexes);
+        const filterByCommits = shouldFilterByCommits(allCommits, filteredCommits, options);
+        const [diffText, fileNames, diffSummary] = yield Promise.all([
+            getDiff(git, from, to, filteredCommits, filterByCommits, pathFilter),
+            getChangedFiles(git, from, to, filteredCommits, filterByCommits, pathFilter),
+            getDiffSummary(git, from, to, filteredCommits, filterByCommits, pathFilter),
+        ]);
+        const summarizeFlags = {
+            from,
+            to,
+            team: options.teamName,
+            model: options.model,
+            maxDiffChars: options.maxDiffChars,
+            systemPrompt: options.systemPrompt,
+            commitMessageIncludeRegexes: options.commitMessageIncludeRegexes,
+            commitMessageExcludeRegexes: options.commitMessageExcludeRegexes,
+        };
+        return generateSummary(diffText, fileNames, filteredCommits, summarizeFlags, options.openAiClientProvider, diffSummary);
+    });
+}
+
+exports.DEFAULT_GIT_DIFF_SYSTEM_PROMPT = DEFAULT_GIT_DIFF_SYSTEM_PROMPT;
+exports.LLM_GATEWAY_REQUIRED_MESSAGE = LLM_GATEWAY_REQUIRED_MESSAGE;
+exports.buildDiffPathspecs = buildDiffPathspecs;
+exports.createGitClient = createGitClient;
+exports.createOpenAiLikeClient = createOpenAiLikeClient;
+exports.filterCommitsByMessageRegexes = filterCommitsByMessageRegexes;
+exports.generateSummary = generateSummary;
+exports.getChangedFiles = getChangedFiles;
+exports.getCommits = getCommits;
+exports.getDiff = getDiff;
+exports.getDiffSummary = getDiffSummary;
+exports.getRepoRoot = getRepoRoot;
+exports.parseLlmDefaultHeadersFromEnv = parseLlmDefaultHeadersFromEnv;
+exports.resolveLlmBaseUrl = resolveLlmBaseUrl;
+exports.resolveLlmMaxDiffChars = resolveLlmMaxDiffChars;
+exports.resolveOpenAiLikeClientInit = resolveOpenAiLikeClientInit;
+exports.shouldUseLlmGateway = shouldUseLlmGateway;
+exports.splitPromotableAuthorizationFromHeaders = splitPromotableAuthorizationFromHeaders;
+exports.summarizeGitDiff = summarizeGitDiff;
+exports.truncateUnifiedDiffForLlm = truncateUnifiedDiffForLlm;
+//# sourceMappingURL=index.cjs.map