@mcarvin/smart-diff 1.0.2 → 1.0.4

package/dist/index.umd.js

@@ -0,0 +1,666 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('node:path'), require('simple-git')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'node:path', 'simple-git'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jsTemplate = {}, global.node_path, global.simpleGit));
+})(this, (function (exports, node_path, simpleGit) { 'use strict';
+
+    /******************************************************************************
+    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 commitMessagePassesFilters(message, includeRes, excludeRes) {
+        for (const ex of excludeRes) {
+            if (ex.test(message))
+                return false;
+        }
+        if (includeRes.length > 0 && !includeRes.some((r) => r.test(message)))
+            return false;
+        return true;
+    }
+    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) => commitMessagePassesFilters(c.message, includeRes, excludeRes));
+    }
+    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);
+        });
+    }
+    const GIT_STATUS_BY_FIRST_CHAR = {
+        A: 'added',
+        D: 'deleted',
+        R: 'renamed',
+        C: 'copied',
+        T: 'type-changed',
+        M: 'modified',
+    };
+    function mapGitStatus(statusCode) {
+        var _a;
+        return (_a = GIT_STATUS_BY_FIRST_CHAR[statusCode.charAt(0)]) !== null && _a !== void 0 ? _a : '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 parseNameStatusLine(line) {
+        var _a;
+        const parts = line.split('\t');
+        let entry = null;
+        if (parts.length >= 2) {
+            const statusToken = (_a = parts[0]) !== null && _a !== void 0 ? _a : '';
+            const status = mapGitStatus(statusToken);
+            const isRenameOrCopy = statusToken.startsWith('R') || statusToken.startsWith('C');
+            if (isRenameOrCopy && parts.length >= 3) {
+                const oldPath = parts[1];
+                const newPath = parts[2];
+                if (oldPath !== undefined && newPath !== undefined) {
+                    entry = { path: newPath, status, oldPath };
+                }
+            }
+            else if (!isRenameOrCopy) {
+                const pathOnly = parts[1];
+                if (pathOnly !== undefined) {
+                    entry = { path: pathOnly, status };
+                }
+            }
+        }
+        return entry;
+    }
+    function parseNameStatusLines(nameStatusOutput) {
+        const entries = [];
+        for (const rawLine of nameStatusOutput.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            const entry = parseNameStatusLine(line);
+            if (entry)
+                entries.push(entry);
+        }
+        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 parseNumStatLine(line) {
+        var _a, _b;
+        const parts = line.split('\t');
+        if (parts.length < 3)
+            return null;
+        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);
+        return { key, additions, deletions };
+    }
+    function accumulateNumStat(numStatOutput, into) {
+        var _a;
+        for (const rawLine of numStatOutput.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            const parsed = parseNumStatLine(line);
+            if (!parsed)
+                continue;
+            const prev = (_a = into.get(parsed.key)) !== null && _a !== void 0 ? _a : { additions: 0, deletions: 0 };
+            into.set(parsed.key, { additions: prev.additions + parsed.additions, deletions: prev.deletions + parsed.deletions });
+        }
+    }
+    const STATUS_TO_SYNTHETIC_PREFIX = {
+        added: 'A',
+        deleted: 'D',
+        renamed: 'R100',
+        copied: 'C100',
+        'type-changed': 'T',
+        modified: 'M',
+        unknown: 'X',
+    };
+    function diffStatusToSyntheticPrefix(status) {
+        return STATUS_TO_SYNTHETIC_PREFIX[status];
+    }
+    function buildSyntheticDiffLine(meta, counts) {
+        const prefix = diffStatusToSyntheticPrefix(meta.status);
+        if (meta.oldPath) {
+            return `${prefix}\t${counts.additions}\t${counts.deletions}\t${meta.oldPath}\t${meta.path}`;
+        }
+        return `${prefix}\t${counts.additions}\t${counts.deletions}\t${meta.path}`;
+    }
+    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 };
+            syntheticLines.push(buildSyntheticDiffLine(meta, counts));
+        }
+        return parseDiffSummary(syntheticLines.join('\n'));
+    }
+    function parseTabDiffSummaryLine(line) {
+        var _a;
+        const parts = line.split('\t');
+        if (parts.length < 3)
+            return null;
+        const statusToken = (_a = parts.shift()) !== null && _a !== void 0 ? _a : '';
+        const status = mapGitStatus(statusToken);
+        const add0 = parts[0];
+        const del0 = parts[1];
+        const additions = add0 && add0 !== '-' ? Number.parseInt(add0, 10) || 0 : 0;
+        const deletions = del0 && del0 !== '-' ? Number.parseInt(del0, 10) || 0 : 0;
+        if (parts.length === 3) {
+            return { status, additions, deletions, newPath: parts[2] };
+        }
+        if (parts.length === 4) {
+            return { status, additions, deletions, oldPath: parts[2], newPath: parts[3] };
+        }
+        return null;
+    }
+    function mergeParsedDiffSummaryLine(fileMap, p) {
+        var _a, _b;
+        const { newPath, status, additions, deletions, oldPath } = p;
+        const existing = fileMap.get(newPath);
+        if (existing) {
+            existing.additions += additions;
+            existing.deletions += deletions;
+            existing.status = mergeStatus(existing.status, status);
+            if (oldPath)
+                existing.oldPath = (_a = existing.oldPath) !== null && _a !== void 0 ? _a : oldPath;
+            existing.newPath = (_b = existing.newPath) !== null && _b !== void 0 ? _b : newPath;
+        }
+        else {
+            fileMap.set(newPath, {
+                path: newPath,
+                status,
+                additions,
+                deletions,
+                oldPath,
+                newPath: oldPath ? newPath : undefined,
+            });
+        }
+    }
+    function parseDiffSummary(diffOutput) {
+        const fileMap = new Map();
+        for (const rawLine of diffOutput.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            const parsed = parseTabDiffSummaryLine(line);
+            if (parsed)
+                mergeParsedDiffSummaryLine(fileMap, parsed);
+        }
+        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.umd.js.map