crewx 0.8.9-rc.2 → 0.8.9-rc.21

package/dist-server/domain/git/git.controller.js

@@ -0,0 +1,180 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const git_service_js_1 = require("./git.service.js");
+const workspace_decorator_js_1 = require("../../common/decorators/workspace.decorator.js");
+class CommitDto {
+    message;
+    filepaths;
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CommitDto.prototype, "message", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.IsString)({ each: true }),
+    __metadata("design:type", Array)
+], CommitDto.prototype, "filepaths", void 0);
+class PushDto {
+    remote;
+    branch;
+}
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], PushDto.prototype, "remote", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], PushDto.prototype, "branch", void 0);
+class RevertDto {
+    mode;
+    filepath;
+    commitSha;
+    backupSha;
+}
+__decorate([
+    (0, class_validator_1.IsIn)(['file', 'commit', 'restore-backup']),
+    __metadata("design:type", String)
+], RevertDto.prototype, "mode", void 0);
+__decorate([
+    (0, class_validator_1.ValidateIf)((o) => o.mode === 'file'),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RevertDto.prototype, "filepath", void 0);
+__decorate([
+    (0, class_validator_1.ValidateIf)((o) => o.mode === 'commit'),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RevertDto.prototype, "commitSha", void 0);
+__decorate([
+    (0, class_validator_1.ValidateIf)((o) => o.mode === 'restore-backup'),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RevertDto.prototype, "backupSha", void 0);
+let GitController = class GitController {
+    gitService;
+    constructor(gitService) {
+        this.gitService = gitService;
+    }
+    // GIT.STATUS: Get working tree status
+    async getStatus(_ws) {
+        const data = await this.gitService.getStatus();
+        return { success: true, data };
+    }
+    // GIT.HISTORY: Get commit history
+    async getHistory(_ws, filepath, depth) {
+        const depthNum = depth ? parseInt(depth, 10) : 50;
+        const commits = await this.gitService.getHistory(filepath, depthNum);
+        return { success: true, data: { commits } };
+    }
+    // GIT.DIFF: Get diff (working tree or specific commit)
+    async getDiff(_ws, commitSha, filepath) {
+        const diffs = await this.gitService.getFileDiff(commitSha, filepath);
+        return { success: true, data: { diffs } };
+    }
+    // GIT.COMMIT: Create a commit (save point)
+    async commit(_ws, dto) {
+        const sha = await this.gitService.commitFiles(dto.filepaths, dto.message);
+        return { success: true, data: { sha } };
+    }
+    // GIT.PUSH: Push local commits to remote origin
+    async push(_ws, dto) {
+        const data = await this.gitService.push({ remote: dto.remote, branch: dto.branch });
+        return { success: true, data };
+    }
+    // GIT.REVERT: Revert changes (file, commit, or restore backup)
+    async revert(_ws, dto) {
+        const data = await this.gitService.revert({
+            mode: dto.mode,
+            filepath: dto.filepath,
+            commitSha: dto.commitSha,
+            backupSha: dto.backupSha,
+        });
+        return { success: true, data };
+    }
+};
+exports.GitController = GitController;
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.STATUS', summary: 'Get workspace git status' }),
+    (0, common_1.Get)('status'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "getStatus", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.HISTORY', summary: 'Get commit history' }),
+    (0, swagger_1.ApiQuery)({ name: 'filepath', required: false }),
+    (0, swagger_1.ApiQuery)({ name: 'depth', required: false }),
+    (0, common_1.Get)('history'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __param(1, (0, common_1.Query)('filepath')),
+    __param(2, (0, common_1.Query)('depth')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "getHistory", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.DIFF', summary: 'Get file diff (working tree or commit)' }),
+    (0, swagger_1.ApiQuery)({ name: 'commitSha', required: false }),
+    (0, swagger_1.ApiQuery)({ name: 'filepath', required: false }),
+    (0, common_1.Get)('diff'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __param(1, (0, common_1.Query)('commitSha')),
+    __param(2, (0, common_1.Query)('filepath')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "getDiff", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.COMMIT', summary: 'Create a commit (save point)' }),
+    (0, common_1.Post)('commit'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, CommitDto]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "commit", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.PUSH', summary: 'Push local commits to remote origin (http(s) only)' }),
+    (0, common_1.Post)('push'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, PushDto]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "push", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ operationId: 'GIT.REVERT', summary: 'Revert changes with optional backup restore' }),
+    (0, common_1.Post)('revert'),
+    __param(0, (0, workspace_decorator_js_1.Workspace)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, RevertDto]),
+    __metadata("design:returntype", Promise)
+], GitController.prototype, "revert", null);
+exports.GitController = GitController = __decorate([
+    (0, swagger_1.ApiTags)('git'),
+    (0, common_1.Controller)('ws/:slug/git'),
+    __metadata("design:paramtypes", [git_service_js_1.GitService])
+], GitController);

package/dist-server/domain/git/git.module.js

@@ -9,12 +9,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitModule = void 0;
 const common_1 = require("@nestjs/common");
 const git_service_js_1 = require("./git.service.js");
+const git_controller_js_1 = require("./git.controller.js");
 let GitModule = class GitModule {
 };
 exports.GitModule = GitModule;
 exports.GitModule = GitModule = __decorate([
     (0, common_1.Module)({
         providers: [git_service_js_1.GitService],
+        controllers: [git_controller_js_1.GitController],
         exports: [git_service_js_1.GitService],
     })
 ], GitModule);

package/dist-server/domain/git/git.service.js

@@ -38,6 +38,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var GitService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitService = void 0;
@@ -45,6 +48,7 @@ const common_1 = require("@nestjs/common");
 const path_1 = require("path");
 const fs = __importStar(require("fs"));
 const git = __importStar(require("isomorphic-git"));
+const node_1 = __importDefault(require("isomorphic-git/http/node"));
 const workspace_context_store_js_1 = require("../../common/workspace-context.store.js");
 const AUTHOR = { name: 'CrewX', email: 'crewx@local' };
 let GitService = GitService_1 = class GitService {
@@ -54,10 +58,183 @@ let GitService = GitService_1 = class GitService {
     get dir() {
         return (0, workspace_context_store_js_1.getWorkspacePath)();
     }
+    /** Validate that filepath does not escape the workspace root. */
+    validateFilepath(filepath) {
+        const dir = this.dir;
+        const abs = (0, path_1.resolve)((0, path_1.join)(dir, filepath));
+        const normalizedDir = (0, path_1.normalize)(dir);
+        if (!abs.startsWith(normalizedDir + '/') && abs !== normalizedDir) {
+            throw new common_1.BadRequestException({ code: 'INVALID_PATH', message: 'Path traversal not allowed' });
+        }
+    }
+    /** Check whether the workspace directory is a valid git repo. */
+    async isGitRepo() {
+        try {
+            await git.currentBranch({ fs, dir: this.dir });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Return git status: isGitRepo flag, current branch, and list of changed files.
+     * Maps statusMatrix rows to GitStatusFile entries (modified/added/deleted/untracked).
+     */
+    async getStatus() {
+        if (!(await this.isGitRepo())) {
+            return { isGitRepo: false, branch: null, files: [], remoteBranch: null, remoteHeadSha: null, ahead: null, behind: null };
+        }
+        const branch = (await git.currentBranch({ fs, dir: this.dir })) ?? null;
+        // statusMatrix row: [filepath, HEAD, workdir, stage]
+        // HEAD=0 absent from index, 1=identical to index, 2=different from index
+        // workdir=0 absent, 1=same as index, 2=different from index
+        // stage=0 absent, 1=same as HEAD, 2=same as workdir, 3=different from both
+        const matrix = await git.statusMatrix({ fs, dir: this.dir, cache: this.cache });
+        const files = [];
+        for (const [filepath, head, workdir, stage] of matrix) {
+            // Unchanged: HEAD=1, workdir=1, stage=1
+            if (head === 1 && workdir === 1 && stage === 1)
+                continue;
+            // Clean unmodified (index matches HEAD, workdir matches index)
+            if (head === 1 && workdir === 1 && stage === 0)
+                continue;
+            const isStaged = stage === 2 || stage === 3;
+            let status;
+            if (head === 0 && workdir === 2 && stage === 0) {
+                // Untracked: new file in workdir, not staged
+                status = 'untracked';
+            }
+            else if (head === 0) {
+                // Added: new file (staged)
+                status = 'added';
+            }
+            else if (workdir === 0) {
+                // Deleted: in HEAD, absent in workdir
+                status = 'deleted';
+            }
+            else {
+                // Modified
+                status = 'modified';
+            }
+            files.push({ filepath: filepath, status, staged: isStaged });
+        }
+        const remote = await this.resolveRemoteTracking(branch);
+        return { isGitRepo: true, branch, files, ...remote };
+    }
+    /**
+     * Derive remote-tracking info for the given branch from local refs only.
+     * Never performs a network fetch. Returns all-null when upstream is absent.
+     */
+    async resolveRemoteTracking(branch) {
+        const nullResult = { remoteBranch: null, remoteHeadSha: null, ahead: null, behind: null };
+        if (!branch)
+            return nullResult;
+        try {
+            const remoteName = (await git.getConfig({ fs, dir: this.dir, path: `branch.${branch}.remote` }));
+            const mergePath = (await git.getConfig({ fs, dir: this.dir, path: `branch.${branch}.merge` }));
+            if (!remoteName || !mergePath)
+                return nullResult;
+            // mergePath is e.g. 'refs/heads/main' — strip prefix to get short name
+            const remoteBranchName = mergePath.replace(/^refs\/heads\//, '');
+            const remoteBranch = `${remoteName}/${remoteBranchName}`;
+            const remoteRef = `refs/remotes/${remoteName}/${remoteBranchName}`;
+            let remoteHeadSha = null;
+            try {
+                remoteHeadSha = await git.resolveRef({ fs, dir: this.dir, ref: remoteRef });
+            }
+            catch {
+                // remote-tracking ref not present locally (never fetched)
+                return { remoteBranch, remoteHeadSha: null, ahead: null, behind: null };
+            }
+            // Compute ahead/behind via log set-difference (merge-base approximation)
+            const [localLog, remoteLog] = await Promise.all([
+                git.log({ fs, dir: this.dir, ref: 'HEAD', cache: this.cache }),
+                git.log({ fs, dir: this.dir, ref: remoteHeadSha, cache: this.cache }),
+            ]);
+            const remoteOids = new Set(remoteLog.map((c) => c.oid));
+            const localOids = new Set(localLog.map((c) => c.oid));
+            const ahead = localLog.filter((c) => !remoteOids.has(c.oid)).length;
+            const behind = remoteLog.filter((c) => !localOids.has(c.oid)).length;
+            return { remoteBranch, remoteHeadSha, ahead, behind };
+        }
+        catch {
+            return nullResult;
+        }
+    }
+    /**
+     * Stage all current changes and create a backup commit before a revert.
+     * Returns the backup commit SHA. (Not a stash — uses a real commit for untracked safety.)
+     */
+    async createBackupCommit(reason) {
+        const matrix = await git.statusMatrix({ fs, dir: this.dir, cache: this.cache });
+        for (const [filepath, head, workdir] of matrix) {
+            if (head === 1 && workdir === 1)
+                continue; // unchanged
+            const fp = filepath;
+            if (workdir === 0) {
+                await git.remove({ fs, dir: this.dir, filepath: fp });
+            }
+            else {
+                await git.add({ fs, dir: this.dir, filepath: fp });
+            }
+        }
+        const sha = await git.commit({
+            fs,
+            dir: this.dir,
+            message: `backup: before revert — ${reason}`,
+            author: AUTHOR,
+            cache: this.cache,
+        });
+        return sha;
+    }
+    /**
+     * Unified revert operation.
+     * - 'file': discard working tree changes for a single file (checkout from HEAD)
+     * - 'commit': restore working tree to the state at commitSha
+     * - 'restore-backup': restore working tree from a previous backup commit
+     *
+     * For 'file' and 'commit': creates a backup commit first and returns its SHA.
+     * For 'restore-backup': restores from backupSha and returns the same SHA.
+     */
+    async revert(opts) {
+        if (opts.mode === 'restore-backup') {
+            if (!opts.backupSha) {
+                throw new common_1.BadRequestException({ code: 'MISSING_BACKUP_SHA' });
+            }
+            await git.checkout({ fs, dir: this.dir, ref: opts.backupSha, force: true, cache: this.cache });
+            return { backupSha: opts.backupSha };
+        }
+        const label = opts.mode === 'file' ? (opts.filepath ?? 'file') : (opts.commitSha ?? 'commit');
+        const backupSha = await this.createBackupCommit(label);
+        if (opts.mode === 'file') {
+            if (!opts.filepath) {
+                throw new common_1.BadRequestException({ code: 'MISSING_FILEPATH' });
+            }
+            this.validateFilepath(opts.filepath);
+            await git.checkout({
+                fs,
+                dir: this.dir,
+                ref: 'HEAD',
+                filepaths: [opts.filepath],
+                force: true,
+                cache: this.cache,
+            });
+        }
+        else {
+            // mode === 'commit'
+            if (!opts.commitSha) {
+                throw new common_1.BadRequestException({ code: 'MISSING_COMMIT_SHA' });
+            }
+            await git.checkout({ fs, dir: this.dir, ref: opts.commitSha, force: true, cache: this.cache });
+        }
+        return { backupSha };
+    }
     /**
      * Stage a file and create a commit. Returns the commit SHA.
      */
     async commitFile(filepath, message) {
+        this.validateFilepath(filepath);
         await git.add({ fs, dir: this.dir, filepath, cache: this.cache });
         const sha = await git.commit({
             fs,
@@ -68,6 +245,39 @@ let GitService = GitService_1 = class GitService {
         });
         return sha;
     }
+    /**
+     * Stage given files (or all changes when filepaths is empty/undefined) and create a commit.
+     */
+    async commitFiles(filepaths, message) {
+        if (filepaths && filepaths.length > 0) {
+            for (const fp of filepaths) {
+                this.validateFilepath(fp);
+                await git.add({ fs, dir: this.dir, filepath: fp, cache: this.cache });
+            }
+        }
+        else {
+            const matrix = await git.statusMatrix({ fs, dir: this.dir, cache: this.cache });
+            for (const [filepath, head, workdir] of matrix) {
+                if (head === 1 && workdir === 1)
+                    continue;
+                const fp = filepath;
+                if (workdir === 0) {
+                    await git.remove({ fs, dir: this.dir, filepath: fp });
+                }
+                else {
+                    await git.add({ fs, dir: this.dir, filepath: fp });
+                }
+            }
+        }
+        const sha = await git.commit({
+            fs,
+            dir: this.dir,
+            message,
+            author: AUTHOR,
+            cache: this.cache,
+        });
+        return sha;
+    }
     /**
      * Return commit history, optionally filtered by filepath.
      */
@@ -90,7 +300,7 @@ let GitService = GitService_1 = class GitService {
      * Restore a file to its state at the given commit SHA.
      */
     async rollbackFile(filepath, commitSha) {
-        // Read file blob at that commit
+        this.validateFilepath(filepath);
         const { blob } = await git.readBlob({
             fs,
             dir: this.dir,
@@ -100,14 +310,118 @@ let GitService = GitService_1 = class GitService {
         });
         const absPath = (0, path_1.join)(this.dir, filepath);
         fs.writeFileSync(absPath, new Uint8Array(Buffer.from(blob)));
-        // Commit the rollback
         await this.commitFile(filepath, `revert: restore ${filepath} to ${commitSha.slice(0, 7)}`);
     }
     /**
-     * Return diff entries for the given commit compared to its parent.
-     * If filepath is provided, only include that file.
+     * Return diff entries.
+     * - If commitSha is provided: compare that commit to its parent.
+     * - If commitSha is omitted: working tree diff (HEAD vs workdir).
+     * Optionally filtered by filepath.
      */
     async getFileDiff(commitSha, filepath) {
+        if (!commitSha) {
+            return this.getWorkingTreeDiff(filepath);
+        }
+        return this.getCommitDiff(commitSha, filepath);
+    }
+    /** Diff HEAD against current working tree. */
+    async getWorkingTreeDiff(filepath) {
+        const results = [];
+        const matrix = await git.statusMatrix({ fs, dir: this.dir, cache: this.cache });
+        for (const [fp, head, workdir] of matrix) {
+            if (filepath && fp !== filepath)
+                continue;
+            if (head === 1 && workdir === 1)
+                continue; // unchanged
+            const absPath = (0, path_1.join)(this.dir, fp);
+            let type;
+            if (head === 0) {
+                type = 'add';
+            }
+            else if (workdir === 0) {
+                type = 'delete';
+            }
+            else {
+                type = 'modify';
+            }
+            let beforeContent;
+            let afterContent;
+            if (type !== 'add') {
+                try {
+                    const headOid = await git.resolveRef({ fs, dir: this.dir, ref: 'HEAD' });
+                    const { blob } = await git.readBlob({ fs, dir: this.dir, oid: headOid, filepath: fp, cache: this.cache });
+                    beforeContent = Buffer.from(blob).toString('utf-8');
+                }
+                catch (e) {
+                    this.logger.warn(`Failed to read HEAD blob for ${fp}: ${e}`);
+                }
+            }
+            if (type !== 'delete') {
+                try {
+                    afterContent = fs.readFileSync(absPath, 'utf-8');
+                }
+                catch (e) {
+                    this.logger.warn(`Failed to read workdir file ${fp}: ${e}`);
+                }
+            }
+            results.push({ filepath: fp, type, before: beforeContent, after: afterContent });
+        }
+        return results;
+    }
+    /**
+     * Push local commits to a remote http(s) origin using an env token.
+     * Pre-guards reject: non-http remote, missing remote, behind > 0, missing token.
+     * force push is never used.
+     */
+    async push(opts = {}) {
+        const dir = this.dir;
+        if (!(await this.isGitRepo())) {
+            throw new common_1.BadRequestException({ code: 'NOT_GIT_REPO', message: 'Not a Git repository' });
+        }
+        const currentBranch = (await git.currentBranch({ fs, dir })) ?? null;
+        if (!currentBranch) {
+            throw new common_1.BadRequestException({ code: 'DETACHED_HEAD', message: 'No current branch (detached HEAD)' });
+        }
+        const remote = opts.remote ?? 'origin';
+        const branch = opts.branch ?? currentBranch;
+        const remoteUrl = (await git.getConfig({ fs, dir, path: `remote.${remote}.url` }));
+        if (!remoteUrl) {
+            throw new common_1.BadRequestException({ code: 'NO_REMOTE', message: 'No remote repository configured' });
+        }
+        if (!/^https?:\/\//i.test(remoteUrl)) {
+            throw new common_1.BadRequestException({ code: 'SSH_REMOTE', message: 'SSH remotes are not supported' });
+        }
+        const tracking = await this.resolveRemoteTracking(branch);
+        if (tracking.behind !== null && tracking.behind > 0) {
+            throw new common_1.BadRequestException({ code: 'BEHIND_REMOTE', message: 'Pull remote changes before pushing' });
+        }
+        // Read token without exposing it in any log or error path
+        const token = process.env['CREWX_GIT_TOKEN'] ?? process.env['GITHUB_TOKEN'];
+        if (!token) {
+            throw new common_1.BadRequestException({ code: 'NO_TOKEN', message: 'Git authentication token is required' });
+        }
+        try {
+            await git.push({
+                fs,
+                http: node_1.default,
+                dir,
+                remote,
+                ref: branch,
+                force: false,
+                onAuth: () => ({ username: token }),
+            });
+            return { ok: true };
+        }
+        catch (err) {
+            const raw = err instanceof Error ? err.message : String(err);
+            // Strip any embedded credentials from error messages before logging/throwing
+            const safe = raw.replace(/https?:\/\/[^@\s]*@/gi, 'https://***@');
+            this.logger.warn(`git push failed: ${safe}`);
+            throw new common_1.BadRequestException({ code: 'PUSH_FAILED', message: `Push failed: ${safe}` });
+        }
+    }
+    /** Diff a specific commit against its parent. */
+    async getCommitDiff(commitSha, filepath) {
         const commits = await git.log({
             fs,
             dir: this.dir,
@@ -130,25 +444,20 @@ let GitService = GitService_1 = class GitService {
             dir: this.dir,
             trees: walkerTrees,
             map: async (path, entries) => {
-                if (filepath && path !== filepath)
+                if (filepath && path !== '.' && path !== filepath && !filepath.startsWith(`${path}/`)) {
                     return null;
-                // When no parent: single walker entry means all files are "add"
+                }
                 if (!parentTree) {
                     const [current] = entries;
                     if (!current)
                         return null;
                     const entryType = await current.type();
                     if (entryType === 'tree')
-                        return null;
+                        return undefined;
                     const oid = await current.oid();
                     let afterContent;
                     try {
-                        const { blob } = await git.readBlob({
-                            fs,
-                            dir: this.dir,
-                            oid,
-                            cache: this.cache,
-                        });
+                        const { blob } = await git.readBlob({ fs, dir: this.dir, oid, cache: this.cache });
                         afterContent = Buffer.from(blob).toString('utf-8');
                     }
                     catch (e) {
@@ -159,13 +468,12 @@ let GitService = GitService_1 = class GitService {
                 const [before, after] = entries;
                 const beforeType = await before?.type();
                 const afterType = await after?.type();
-                // Skip directories
                 if (beforeType === 'tree' || afterType === 'tree')
-                    return null;
+                    return undefined;
                 const beforeOid = await before?.oid();
                 const afterOid = await after?.oid();
                 if (beforeOid === afterOid)
-                    return null; // No change
+                    return null;
                 let type;
                 if (!before || beforeType === undefined) {
                     type = 'add';
@@ -180,33 +488,18 @@ let GitService = GitService_1 = class GitService {
                 let afterContent;
                 try {
                     if (type !== 'add' && beforeOid) {
-                        const { blob } = await git.readBlob({
-                            fs,
-                            dir: this.dir,
-                            oid: beforeOid,
-                            cache: this.cache,
-                        });
+                        const { blob } = await git.readBlob({ fs, dir: this.dir, oid: beforeOid, cache: this.cache });
                         beforeContent = Buffer.from(blob).toString('utf-8');
                     }
                     if (type !== 'delete' && afterOid) {
-                        const { blob } = await git.readBlob({
-                            fs,
-                            dir: this.dir,
-                            oid: afterOid,
-                            cache: this.cache,
-                        });
+                        const { blob } = await git.readBlob({ fs, dir: this.dir, oid: afterOid, cache: this.cache });
                         afterContent = Buffer.from(blob).toString('utf-8');
                     }
                 }
                 catch (e) {
                     this.logger.warn(`Failed to read blob for ${path}: ${e}`);
                 }
-                return {
-                    filepath: path,
-                    type,
-                    before: beforeContent,
-                    after: afterContent,
-                };
+                return { filepath: path, type, before: beforeContent, after: afterContent };
             },
         });
         for (const entry of changes) {