/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import * as fs from 'node:fs/promises';
import * as path from 'node:path';
import { isNodeError } from '../utils/errors.js';
import { spawnAsync } from '../utils/shell-utils.js';
import { simpleGit, CheckRepoActions } from 'simple-git';
import { debugLogger } from '../utils/debugLogger.js';
export class GitService {
    projectRoot;
    storage;
    constructor(projectRoot, storage) {
        this.projectRoot = path.resolve(projectRoot);
        this.storage = storage;
    }
    getHistoryDir() {
        return this.storage.getHistoryDir();
    }
    async initialize() {
        const gitAvailable = await GitService.verifyGitAvailability();
        if (!gitAvailable) {
            throw new Error('Checkpointing is enabled, but Git is not installed. Please install Git or disable checkpointing to continue.');
        }
        try {
            await this.setupShadowGitRepository();
        }
        catch (error) {
            throw new Error(`Failed to initialize checkpointing: ${error instanceof Error ? error.message : 'Unknown error'}. Please check that Git is working properly or disable checkpointing.`);
        }
    }
    static async verifyGitAvailability() {
        try {
            await spawnAsync('git', ['--version']);
            return true;
        }
        catch (_error) {
            return false;
        }
    }
    /**
     * Creates a hidden git repository in the project root.
     * The Git repository is used to support checkpointing.
     */
    async setupShadowGitRepository() {
        const repoDir = this.getHistoryDir();
        const gitConfigPath = path.join(repoDir, '.gitconfig');
        await fs.mkdir(repoDir, { recursive: true });
        // We don't want to inherit the user's name, email, or gpg signing
        // preferences for the shadow repository, so we create a dedicated gitconfig.
        const gitConfigContent = '[user]\n  name = Gemini CLI\n  email = gemini-cli@google.com\n[commit]\n  gpgsign = false\n';
        await fs.writeFile(gitConfigPath, gitConfigContent);
        const repo = simpleGit(repoDir);
        let isRepoDefined = false;
        try {
            isRepoDefined = await repo.checkIsRepo(CheckRepoActions.IS_REPO_ROOT);
        }
        catch (error) {
            // If checkIsRepo fails (e.g., on certain Git versions like macOS 2.39.5),
            // log the error and assume repo is not defined, then proceed with initialization
            debugLogger.debug(`checkIsRepo failed, will initialize repository: ${error instanceof Error ? error.message : String(error)}`);
        }
        if (!isRepoDefined) {
            await repo.init(false, {
                '--initial-branch': 'main',
            });
            await repo.commit('Initial commit', { '--allow-empty': null });
        }
        const userGitIgnorePath = path.join(this.projectRoot, '.gitignore');
        const shadowGitIgnorePath = path.join(repoDir, '.gitignore');
        let userGitIgnoreContent = '';
        try {
            userGitIgnoreContent = await fs.readFile(userGitIgnorePath, 'utf-8');
        }
        catch (error) {
            if (isNodeError(error) && error.code !== 'ENOENT') {
                throw error;
            }
        }
        await fs.writeFile(shadowGitIgnorePath, userGitIgnoreContent);
    }
    get shadowGitRepository() {
        const repoDir = this.getHistoryDir();
        return simpleGit(this.projectRoot).env({
            GIT_DIR: path.join(repoDir, '.git'),
            GIT_WORK_TREE: this.projectRoot,
            // Prevent git from using the user's global git config.
            HOME: repoDir,
            XDG_CONFIG_HOME: repoDir,
        });
    }
    async getCurrentCommitHash() {
        const hash = await this.shadowGitRepository.raw('rev-parse', 'HEAD');
        return hash.trim();
    }
    async createFileSnapshot(message) {
        try {
            const repo = this.shadowGitRepository;
            await repo.add('.');
            const status = await repo.status();
            if (status.isClean()) {
                // If no changes are staged, return the current HEAD commit hash
                return await this.getCurrentCommitHash();
            }
            const commitResult = await repo.commit(message, {
                '--no-verify': null,
            });
            return commitResult.commit;
        }
        catch (error) {
            throw new Error(`Failed to create checkpoint snapshot: ${error instanceof Error ? error.message : 'Unknown error'}. Checkpointing may not be working properly.`);
        }
    }
    async restoreProjectFromSnapshot(commitHash) {
        const repo = this.shadowGitRepository;
        await repo.raw(['restore', '--source', commitHash, '.']);
        // Removes any untracked files that were introduced post snapshot.
        await repo.clean('f', ['-d']);
    }
}
//# sourceMappingURL=gitService.js.map