git-history-ui 1.0.6 → 2.0.1

package/dist/backend/gitService.js

@@ -1,283 +1,383 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitService = void 0;
-const simple_git_1 = __importDefault(require("simple-git"));
-class GitService {
+exports.GitService = exports.NotARepositoryError = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const FIELD_SEP = "\x1f"; // Unit Separator (NUL is rejected by Node argv)
+const RECORD_SEP = '\x1e';
+const LOG_FORMAT = ['%H', '%h', '%an', '%ae', '%aI', '%P', '%s', '%b'].join(FIELD_SEP);
+const REF_INDEX_TTL_MS = 5_000;
+const COUNT_CACHE_TTL_MS = 10_000;
+class NotARepositoryError extends Error {
     constructor() {
-        this.git = (0, simple_git_1.default)();
+        super('Not a git repository');
+        this.name = 'NotARepositoryError';
     }
-    async getCommits(options = {}) {
+}
+exports.NotARepositoryError = NotARepositoryError;
+class GitService {
+    repoPath;
+    refIndexCache = null;
+    countCache = new Map();
+    repoCheckResult = null;
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+    }
+    async verifyRepository() {
+        if (this.repoCheckResult !== null)
+            return this.repoCheckResult;
         try {
-            const page = options.page || 1;
-            const pageSize = options.pageSize || 25;
-            const skip = (page - 1) * pageSize;
-            // Get total count first (without limit)
-            const countOptions = {
-                maxCount: 0 // Get all commits for counting
-            };
-            let totalLog;
-            if (options.file) {
-                totalLog = await this.git.log({
-                    ...countOptions,
-                    file: options.file
-                });
-            }
-            else if (options.since) {
-                totalLog = await this.git.log({
-                    ...countOptions,
-                    from: options.since
-                });
-            }
-            else if (options.author) {
-                totalLog = await this.git.log({
-                    ...countOptions,
-                    author: options.author
-                });
-            }
-            else {
-                totalLog = await this.git.log(countOptions);
-            }
-            const total = totalLog.all.length;
-            const totalPages = Math.ceil(total / pageSize);
-            // Get paginated commits
-            // For pagination, we need to get all commits and then slice them
-            // since simple-git doesn't support skip parameter properly
-            const allLogOptions = {
-                maxCount: 0 // Get all commits
-            };
-            let allLog;
-            if (options.file) {
-                allLog = await this.git.log({
-                    ...allLogOptions,
-                    file: options.file
-                });
-            }
-            else if (options.since) {
-                allLog = await this.git.log({
-                    ...allLogOptions,
-                    from: options.since
-                });
-            }
-            else if (options.author) {
-                allLog = await this.git.log({
-                    ...allLogOptions,
-                    author: options.author
-                });
+            await this.git(['rev-parse', '--is-inside-work-tree']);
+            this.repoCheckResult = true;
+        }
+        catch {
+            this.repoCheckResult = false;
+        }
+        return this.repoCheckResult;
+    }
+    async getRefIndex() {
+        const now = Date.now();
+        if (this.refIndexCache && now - this.refIndexCache.builtAt < REF_INDEX_TTL_MS) {
+            return this.refIndexCache;
+        }
+        const branchesByCommit = new Map();
+        const tagsByCommit = new Map();
+        const out = await this.git([
+            'for-each-ref',
+            '--format=%(objectname)\t%(refname:short)\t%(refname)',
+            'refs/heads',
+            'refs/tags',
+            'refs/remotes'
+        ]);
+        for (const line of out.split('\n')) {
+            if (!line)
+                continue;
+            const [hash, short, full] = line.split('\t');
+            if (!hash || !short)
+                continue;
+            if (full && full.startsWith('refs/tags/')) {
+                push(tagsByCommit, hash, short);
             }
             else {
-                allLog = await this.git.log(allLogOptions);
+                push(branchesByCommit, hash, short);
             }
-            // Apply pagination manually
-            const paginatedCommits = allLog.all.slice(skip, skip + pageSize);
-            const commits = await Promise.all(paginatedCommits.map(async (commit) => {
-                const [branches, tags] = await Promise.all([
-                    this.getBranchesForCommit(commit.hash),
-                    this.getTagsForCommit(commit.hash)
-                ]);
-                return {
-                    hash: commit.hash,
-                    author: commit.author_name,
-                    date: commit.date,
-                    message: commit.message,
-                    files: await this.getFilesForCommit(commit.hash),
-                    parents: [], // We'll get this from git show if needed
-                    branches,
-                    tags
-                };
-            }));
-            return {
-                commits,
-                total,
-                page,
-                pageSize,
-                totalPages,
-                hasNext: page < totalPages,
-                hasPrevious: page > 1
-            };
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get commits: ${errorMessage}`);
+        this.refIndexCache = { branchesByCommit, tagsByCommit, builtAt: now };
+        return this.refIndexCache;
+        function push(map, key, value) {
+            const list = map.get(key);
+            if (list)
+                list.push(value);
+            else
+                map.set(key, [value]);
         }
     }
-    async getCommit(hash) {
+    async getCommits(options = {}) {
+        if (!(await this.verifyRepository())) {
+            throw new NotARepositoryError();
+        }
+        const page = Math.max(1, options.page || 1);
+        const pageSize = clamp(options.pageSize || 25, 1, 500);
+        const skip = (page - 1) * pageSize;
+        const filterArgs = this.buildFilterArgs(options);
+        const cacheKey = filterArgs.join(' ');
+        const total = await this.getTotalCount(cacheKey, filterArgs);
+        const totalPages = Math.max(1, Math.ceil(total / pageSize));
+        const args = [
+            'log',
+            `--max-count=${pageSize}`,
+            `--skip=${skip}`,
+            `--pretty=format:${LOG_FORMAT}${RECORD_SEP}`,
+            ...filterArgs
+        ];
+        const out = await this.git(args, { maxBuffer: 64 * 1024 * 1024 });
+        const refs = await this.getRefIndex();
+        const commits = this.parseLog(out, refs);
+        return {
+            commits,
+            total,
+            page,
+            pageSize,
+            totalPages,
+            hasNext: page < totalPages,
+            hasPrevious: page > 1
+        };
+    }
+    async getTotalCount(cacheKey, filterArgs) {
+        const now = Date.now();
+        const cached = this.countCache.get(cacheKey);
+        if (cached && cached.expiresAt > now)
+            return cached.total;
+        // Insert HEAD before the pathspec separator so that --author/--since/--grep
+        // apply to the count. Otherwise rev-list would only honour pathspec filters.
+        const sepIdx = filterArgs.indexOf('--');
+        const revArgs = sepIdx >= 0
+            ? [...filterArgs.slice(0, sepIdx), 'HEAD', ...filterArgs.slice(sepIdx)]
+            : [...filterArgs, 'HEAD'];
+        let total = 0;
         try {
-            const log = await this.git.log({
-                from: hash,
-                to: hash,
-                maxCount: 1
-            });
-            if (log.all.length === 0) {
-                throw new Error('Commit not found');
-            }
-            const commit = log.all[0];
-            const [branches, tags] = await Promise.all([
-                this.getBranchesForCommit(hash),
-                this.getTagsForCommit(hash)
-            ]);
-            return {
-                hash: commit.hash,
-                author: commit.author_name,
-                date: commit.date,
-                message: commit.message,
-                files: await this.getFilesForCommit(hash),
-                parents: [], // We'll get this from git show if needed
+            const out = await this.git(['rev-list', '--count', ...revArgs]);
+            total = parseInt(out.trim(), 10) || 0;
+        }
+        catch {
+            const fallback = await this.git(['log', '--oneline', ...filterArgs]).catch(() => '');
+            total = fallback ? fallback.split('\n').filter(Boolean).length : 0;
+        }
+        this.countCache.set(cacheKey, { total, expiresAt: now + COUNT_CACHE_TTL_MS });
+        return total;
+    }
+    buildFilterArgs(options) {
+        const args = [];
+        if (options.author)
+            args.push(`--author=${options.author}`);
+        if (options.since)
+            args.push(`--since=${options.since}`);
+        if (options.until)
+            args.push(`--until=${options.until}`);
+        if (options.search)
+            args.push(`--grep=${options.search}`, '--regexp-ignore-case');
+        if (options.file)
+            args.push('--', options.file);
+        return args;
+    }
+    parseLog(raw, refs) {
+        if (!raw)
+            return [];
+        const commits = [];
+        for (const record of raw.split(RECORD_SEP)) {
+            const trimmed = record.trim();
+            if (!trimmed)
+                continue;
+            const fields = trimmed.split(FIELD_SEP);
+            if (fields.length < 8)
+                continue;
+            const [hash, shortHash, author, authorEmail, date, parentsStr, subject, ...rest] = fields;
+            const body = rest.join(FIELD_SEP);
+            const parents = parentsStr ? parentsStr.split(' ').filter(Boolean) : [];
+            const branches = refs.branchesByCommit.get(hash) ?? [];
+            const tags = refs.tagsByCommit.get(hash) ?? [];
+            commits.push({
+                hash,
+                shortHash,
+                author,
+                authorEmail,
+                date,
+                subject,
+                body,
+                message: body ? `${subject}\n\n${body}` : subject,
+                parents,
                 branches,
-                tags
-            };
+                tags,
+                isMerge: parents.length > 1
+            });
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get commit: ${errorMessage}`);
+        return commits;
+    }
+    async getCommit(hash) {
+        if (!isPlausibleHash(hash))
+            throw new Error('Invalid commit hash');
+        const out = await this.git([
+            'log',
+            '--max-count=1',
+            `--pretty=format:${LOG_FORMAT}${RECORD_SEP}`,
+            hash
+        ]);
+        const refs = await this.getRefIndex();
+        const commits = this.parseLog(out, refs);
+        if (commits.length === 0)
+            throw new Error('Commit not found');
+        return commits[0];
+    }
+    async getAuthors() {
+        const out = await this.git(['log', '--all', '--pretty=format:%an']);
+        const seen = new Set();
+        for (const line of out.split('\n')) {
+            const v = line.trim();
+            if (v)
+                seen.add(v);
         }
+        return Array.from(seen).sort((a, b) => a.localeCompare(b));
     }
     async getDiff(hash) {
-        try {
-            const diff = await this.git.diff([hash + '^', hash]);
-            return this.parseDiff(diff);
+        if (!isPlausibleHash(hash))
+            throw new Error('Invalid commit hash');
+        const parentsOut = await this.git(['log', '-1', '--pretty=format:%P', hash]);
+        const parents = parentsOut.trim().split(/\s+/).filter(Boolean);
+        let raw;
+        if (parents.length === 0) {
+            raw = await this.git(['diff-tree', '--root', '-p', '-M', '--no-color', hash]);
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get diff: ${errorMessage}`);
+        else {
+            raw = await this.git(['diff', '-M', '--no-color', `${hash}^1`, hash]);
         }
+        return parseUnifiedDiff(raw);
     }
     async getBlame(filePath) {
-        try {
-            const blame = await this.git.raw(['blame', '--porcelain', filePath]);
-            return this.parseBlame(blame);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get blame: ${errorMessage}`);
-        }
+        if (filePath.includes('\0'))
+            throw new Error('Invalid path');
+        const raw = await this.git(['blame', '--porcelain', '--', filePath]);
+        return parsePorcelainBlame(raw);
     }
     async getTags() {
-        try {
-            const tags = await this.git.tags();
-            return tags.all;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get tags: ${errorMessage}`);
-        }
+        const out = await this.git(['tag', '--list']);
+        return out.split('\n').map((s) => s.trim()).filter(Boolean);
     }
     async getBranches() {
+        const out = await this.git([
+            'for-each-ref',
+            '--format=%(refname:short)',
+            'refs/heads',
+            'refs/remotes'
+        ]);
+        return out.split('\n').map((s) => s.trim()).filter(Boolean);
+    }
+    async git(args, opts = {}) {
         try {
-            const branches = await this.git.branch();
-            return branches.all;
+            const { stdout } = await execFileAsync('git', args, {
+                cwd: this.repoPath,
+                maxBuffer: opts.maxBuffer ?? 16 * 1024 * 1024,
+                env: {
+                    ...process.env,
+                    GIT_PAGER: 'cat',
+                    GIT_TERMINAL_PROMPT: '0',
+                    LC_ALL: 'C'
+                },
+                encoding: 'utf8'
+            });
+            return stdout;
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to get branches: ${errorMessage}`);
+        catch (err) {
+            const e = err;
+            const msg = e.stderr?.toString().trim() || e.message;
+            throw new Error(`git ${args[0]} failed: ${msg}`);
         }
     }
-    async getFilesForCommit(hash) {
-        try {
-            const diff = await this.git.diff([hash + '^', hash, '--name-only']);
-            return diff.split('\n').filter(Boolean);
+}
+exports.GitService = GitService;
+function isPlausibleHash(hash) {
+    return typeof hash === 'string' && /^[0-9a-fA-F]{4,40}$/.test(hash);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function parseUnifiedDiff(raw) {
+    const files = [];
+    if (!raw)
+        return files;
+    let current = null;
+    let currentLines = [];
+    const flush = () => {
+        if (!current)
+            return;
+        current.changes = currentLines.join('\n');
+        files.push(current);
+        current = null;
+        currentLines = [];
+    };
+    for (const line of raw.split('\n')) {
+        if (line.startsWith('diff --git ')) {
+            flush();
+            const match = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+            const a = match?.[1];
+            const b = match?.[2];
+            current = {
+                file: b ?? a ?? '',
+                oldFile: a !== b ? a : undefined,
+                status: 'modified',
+                additions: 0,
+                deletions: 0,
+                changes: ''
+            };
+            currentLines = [line];
         }
-        catch (error) {
-            return [];
+        else if (!current) {
+            continue;
         }
-    }
-    async getBranchesForCommit(hash) {
-        try {
-            const branches = await this.git.branch(['--contains', hash]);
-            return branches.all;
+        else if (line.startsWith('new file mode')) {
+            current.status = 'added';
+            currentLines.push(line);
         }
-        catch (error) {
-            return [];
+        else if (line.startsWith('deleted file mode')) {
+            current.status = 'deleted';
+            currentLines.push(line);
         }
-    }
-    async getTagsForCommit(hash) {
-        try {
-            const tags = await this.git.raw(['tag', '--contains', hash]);
-            return tags.split('\n').filter(Boolean);
+        else if (line.startsWith('rename from ')) {
+            current.status = 'renamed';
+            current.oldFile = line.substring('rename from '.length);
+            currentLines.push(line);
         }
-        catch (error) {
-            return [];
+        else if (line.startsWith('rename to ')) {
+            current.file = line.substring('rename to '.length);
+            currentLines.push(line);
         }
-    }
-    parseDiff(diff) {
-        const files = [];
-        const lines = diff.split('\n');
-        let currentFile = null;
-        let currentFileLines = [];
-        for (const line of lines) {
-            if (line.startsWith('diff --git')) {
-                if (currentFile) {
-                    currentFile.changes = currentFileLines.join('\n');
-                    files.push(currentFile);
-                }
-                const fileMatch = line.match(/b\/(.+)$/);
-                currentFile = {
-                    file: fileMatch ? fileMatch[1] : '',
-                    additions: 0,
-                    deletions: 0,
-                    changes: ''
-                };
-                currentFileLines = [];
-            }
-            else if (line.startsWith('+') && !line.startsWith('+++')) {
-                if (currentFile)
-                    currentFile.additions++;
-                currentFileLines.push(line);
-            }
-            else if (line.startsWith('-') && !line.startsWith('---')) {
-                if (currentFile)
-                    currentFile.deletions++;
-                currentFileLines.push(line);
-            }
-            else if (line.startsWith('@@') || line.startsWith('---') || line.startsWith('+++') || line.trim() === '') {
-                // Include git diff headers and context lines
-                currentFileLines.push(line);
-            }
-            else if (line.startsWith(' ')) {
-                // Context lines (unchanged)
-                currentFileLines.push(line);
-            }
+        else if (line.startsWith('copy from ')) {
+            current.status = 'copied';
+            current.oldFile = line.substring('copy from '.length);
+            currentLines.push(line);
         }
-        if (currentFile) {
-            currentFile.changes = currentFileLines.join('\n');
-            files.push(currentFile);
+        else if (line.startsWith('Binary files')) {
+            current.status = 'binary';
+            currentLines.push(line);
+        }
+        else if (line.startsWith('+') && !line.startsWith('+++')) {
+            current.additions++;
+            currentLines.push(line);
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
+            current.deletions++;
+            currentLines.push(line);
+        }
+        else {
+            currentLines.push(line);
         }
-        return files;
     }
-    parseBlame(blame) {
-        const lines = [];
-        const blameLines = blame.split('\n');
-        let currentLine = null;
-        for (const line of blameLines) {
-            if (line.startsWith('author ')) {
-                if (currentLine) {
-                    lines.push(currentLine);
-                }
-                const hash = blameLines[blameLines.indexOf(line) - 1].split(' ')[0];
-                const author = line.substring(7);
-                const dateLine = blameLines[blameLines.indexOf(line) + 1];
-                const date = dateLine.startsWith('author-time ')
-                    ? new Date(parseInt(dateLine.substring(12)) * 1000).toISOString()
-                    : '';
-                currentLine = {
-                    line: lines.length + 1,
-                    hash,
-                    author,
-                    date,
-                    content: ''
-                };
-            }
-            else if (line.startsWith('\t') && currentLine) {
-                currentLine.content = line.substring(1);
-            }
+    flush();
+    return files;
+}
+function parsePorcelainBlame(raw) {
+    if (!raw)
+        return [];
+    const lines = raw.split('\n');
+    const out = [];
+    const meta = new Map();
+    let i = 0;
+    let lineNumber = 0;
+    while (i < lines.length) {
+        const header = lines[i];
+        if (!header) {
+            i++;
+            continue;
         }
-        if (currentLine) {
-            lines.push(currentLine);
+        const m = header.match(/^([0-9a-f]{40}) \d+ (\d+)(?: \d+)?$/);
+        if (!m) {
+            i++;
+            continue;
         }
-        return lines;
+        const hash = m[1];
+        lineNumber = parseInt(m[2], 10);
+        i++;
+        let author = meta.get(hash)?.author ?? '';
+        let epoch = meta.get(hash)?.epoch ?? 0;
+        while (i < lines.length && !lines[i].startsWith('\t')) {
+            const h = lines[i];
+            if (h.startsWith('author '))
+                author = h.substring(7);
+            else if (h.startsWith('author-time '))
+                epoch = parseInt(h.substring(12), 10);
+            i++;
+        }
+        meta.set(hash, { author, epoch });
+        const content = i < lines.length && lines[i].startsWith('\t') ? lines[i].substring(1) : '';
+        out.push({
+            line: lineNumber,
+            hash,
+            author,
+            date: epoch ? new Date(epoch * 1000).toISOString() : '',
+            content
+        });
+        i++;
     }
+    return out;
 }
-exports.GitService = GitService;
 //# sourceMappingURL=gitService.js.map