1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import * as fs from 'fs/promises';
import * as path from 'path';
import { isNodeError } from '../utils/errors.js';
import { exec } from 'node:child_process';
import { simpleGit, SimpleGit, CheckRepoActions } from 'simple-git';
import { Storage } from '../config/storage.js';
export class GitService {
private projectRoot: string;
private storage: Storage;
constructor(projectRoot: string, storage: Storage) {
this.projectRoot = path.resolve(projectRoot);
this.storage = storage;
}
private getHistoryDir(): string {
return this.storage.getHistoryDir();
}
async initialize(): Promise<void> {
const gitAvailable = await this.verifyGitAvailability();
if (!gitAvailable) {
throw new Error(
'Checkpointing is enabled, but Git is not installed. Please install Git or disable checkpointing to continue.',
);
}
this.setupShadowGitRepository();
}
verifyGitAvailability(): Promise<boolean> {
return new Promise((resolve) => {
exec('git --version', (error) => {
if (error) {
resolve(false);
} else {
resolve(true);
}
});
});
}
/**
* 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 = [email protected]\n[commit]\n gpgsign = false\n';
await fs.writeFile(gitConfigPath, gitConfigContent);
const repo = simpleGit(repoDir);
const isRepoDefined = await repo.checkIsRepo(CheckRepoActions.IS_REPO_ROOT);
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);
}
private get shadowGitRepository(): SimpleGit {
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(): Promise<string> {
const hash = await this.shadowGitRepository.raw('rev-parse', 'HEAD');
return hash.trim();
}
async createFileSnapshot(message: string): Promise<string> {
const repo = this.shadowGitRepository;
await repo.add('.');
const commitResult = await repo.commit(message);
return commitResult.commit;
}
async restoreProjectFromSnapshot(commitHash: string): Promise<void> {
const repo = this.shadowGitRepository;
await repo.raw(['restore', '--source', commitHash, '.']);
// Removes any untracked files that were introduced post snapshot.
await repo.clean('f', ['-d']);
}
}
|
