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
|
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import { useState, useEffect, useCallback } from 'react';
import * as fs from 'fs/promises';
import * as path from 'path';
import { isNodeError } from '@gemini-cli/core';
const HISTORY_DIR = '.gemini';
const HISTORY_FILE = 'shell_history';
const MAX_HISTORY_LENGTH = 100;
async function getHistoryFilePath(projectRoot: string): Promise<string> {
const historyDir = path.join(projectRoot, HISTORY_DIR);
return path.join(historyDir, HISTORY_FILE);
}
async function readHistoryFile(filePath: string): Promise<string[]> {
try {
const content = await fs.readFile(filePath, 'utf-8');
return content.split('\n').filter(Boolean);
} catch (error) {
if (isNodeError(error) && error.code === 'ENOENT') {
return [];
}
console.error('Error reading shell history:', error);
return [];
}
}
async function writeHistoryFile(
filePath: string,
history: string[],
): Promise<void> {
try {
await fs.mkdir(path.dirname(filePath), { recursive: true });
await fs.writeFile(filePath, history.join('\n'));
} catch (error) {
console.error('Error writing shell history:', error);
}
}
export function useShellHistory(projectRoot: string) {
const [history, setHistory] = useState<string[]>([]);
const [historyIndex, setHistoryIndex] = useState(-1);
const [historyFilePath, setHistoryFilePath] = useState<string | null>(null);
useEffect(() => {
async function loadHistory() {
const filePath = await getHistoryFilePath(projectRoot);
setHistoryFilePath(filePath);
const loadedHistory = await readHistoryFile(filePath);
setHistory(loadedHistory.reverse()); // Newest first
}
loadHistory();
}, [projectRoot]);
const addCommandToHistory = useCallback(
(command: string) => {
if (!command.trim() || !historyFilePath) {
return;
}
const newHistory = [command, ...history.filter((c) => c !== command)]
.slice(0, MAX_HISTORY_LENGTH)
.filter(Boolean);
setHistory(newHistory);
// Write to file in reverse order (oldest first)
writeHistoryFile(historyFilePath, [...newHistory].reverse());
setHistoryIndex(-1);
},
[history, historyFilePath],
);
const getPreviousCommand = useCallback(() => {
if (history.length === 0) {
return null;
}
const newIndex = Math.min(historyIndex + 1, history.length - 1);
setHistoryIndex(newIndex);
return history[newIndex] ?? null;
}, [history, historyIndex]);
const getNextCommand = useCallback(() => {
if (historyIndex < 0) {
return null;
}
const newIndex = historyIndex - 1;
setHistoryIndex(newIndex);
if (newIndex < 0) {
return '';
}
return history[newIndex] ?? null;
}, [history, historyIndex]);
return {
addCommandToHistory,
getPreviousCommand,
getNextCommand,
resetHistoryPosition: () => setHistoryIndex(-1),
};
}
|
