@gguf/coder 0.2.9 → 0.3.1

package/source/utils/file-autocomplete.ts

@@ -0,0 +1,196 @@
+import {exec} from 'node:child_process';
+import {existsSync, readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {promisify} from 'node:util';
+import {BUFFER_FILE_LIST_BYTES, CACHE_FILE_LIST_TTL_MS} from '@/constants';
+import ignore from 'ignore';
+import {formatError} from './error-formatter';
+import {fuzzyScoreFilePath} from './fuzzy-matching';
+import {getLogger} from './logging';
+
+const execAsync = promisify(exec);
+
+interface FileCompletion {
+	path: string; // Relative path from cwd
+	displayPath: string; // Shortened for display
+	score: number; // Fuzzy match score (higher = better match)
+	isDirectory: boolean;
+}
+
+/**
+ * Load and parse .gitignore file, returns an ignore instance
+ */
+function loadGitignore(cwd: string): ReturnType<typeof ignore> {
+	const ig = ignore();
+	const gitignorePath = join(cwd, '.gitignore');
+
+	// Always ignore common directories
+	ig.add([
+		'node_modules',
+		'.git',
+		'dist',
+		'build',
+		'coverage',
+		'.next',
+		'.nuxt',
+		'out',
+		'.cache',
+	]);
+
+	// Load .gitignore if it exists
+	if (existsSync(gitignorePath)) {
+		try {
+			const gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+			ig.add(gitignoreContent);
+		} catch {
+			// Silently fail if we can't read .gitignore
+			// The hardcoded ignores above will still apply
+		}
+	}
+
+	return ig;
+}
+
+// Simple cache for file list
+interface FileListCache {
+	files: string[];
+	timestamp: number;
+}
+
+let fileListCache: FileListCache | null = null;
+
+/**
+ * Get list of all files in the project (respecting gitignore)
+ */
+async function getAllFiles(cwd: string): Promise<string[]> {
+	// Check cache
+	const now = Date.now();
+	if (fileListCache && now - fileListCache.timestamp < CACHE_FILE_LIST_TTL_MS) {
+		return fileListCache.files;
+	}
+
+	try {
+		const ig = loadGitignore(cwd);
+
+		// Use find to list all files, excluding common large directories
+		const {stdout} = await execAsync(
+			`find . -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" -not -path "*/build/*" -not -path "*/coverage/*" -not -path "*/.next/*" -not -path "*/.nuxt/*" -not -path "*/out/*" -not -path "*/.cache/*"`,
+			{cwd, maxBuffer: BUFFER_FILE_LIST_BYTES},
+		);
+
+		const allFiles = stdout
+			.trim()
+			.split('\n')
+			.filter(Boolean)
+			.map(line => line.replace(/^\.\//, '')) // Remove leading "./"
+			.filter(file => !ig.ignores(file)); // Filter by gitignore
+
+		// Update cache
+		fileListCache = {
+			files: allFiles,
+			timestamp: now,
+		};
+
+		return allFiles;
+	} catch (error) {
+		// If find fails, return empty array
+		const logger = getLogger();
+		logger.error({error: formatError(error)}, 'Failed to list files');
+		return [];
+	}
+}
+
+/**
+ * Extract the current @mention being typed at cursor position
+ * Returns the mention text and its position in the input
+ */
+export function getCurrentFileMention(
+	input: string,
+	cursorPosition?: number,
+): {mention: string; startIndex: number; endIndex: number} | null {
+	const pos = cursorPosition ?? input.length;
+
+	// Find the last @ before cursor
+	let startIndex = -1;
+	for (let i = pos - 1; i >= 0; i--) {
+		if (input[i] === '@') {
+			startIndex = i;
+			break;
+		}
+		// Stop if we hit whitespace (except for path separators)
+		if (input[i] === ' ' || input[i] === '\t' || input[i] === '\n') {
+			break;
+		}
+	}
+
+	if (startIndex === -1) {
+		return null;
+	}
+
+	// Find the end of the mention (next whitespace or end of string)
+	let endIndex = pos;
+	for (let i = pos; i < input.length; i++) {
+		if (
+			input[i] === ' ' ||
+			input[i] === '\t' ||
+			input[i] === '\n' ||
+			input[i] === '@'
+		) {
+			break;
+		}
+		endIndex = i + 1;
+	}
+
+	// Extract mention text (without the @)
+	const fullText = input.substring(startIndex, endIndex);
+	const mention = fullText.substring(1); // Remove @ prefix
+
+	// Remove line range suffix if present (e.g., ":10-20")
+	const mentionWithoutRange = mention.replace(/:\d+(-\d+)?$/, '');
+
+	return {
+		mention: mentionWithoutRange,
+		startIndex,
+		endIndex,
+	};
+}
+
+/**
+ * Get file completions for a partial path
+ */
+export async function getFileCompletions(
+	partialPath: string,
+	cwd: string,
+	maxResults: number = 20,
+): Promise<FileCompletion[]> {
+	// Get all files
+	const allFiles = await getAllFiles(cwd);
+
+	// Score each file
+	const scoredFiles = allFiles
+		.map(file => ({
+			path: file,
+			displayPath: file.length > 50 ? '...' + file.slice(-47) : file,
+			score: fuzzyScoreFilePath(file, partialPath),
+			isDirectory: false, // We're only listing files, not directories
+		}))
+		.filter(f => f.score > 0) // Only include matches
+		.sort((a, b) => {
+			// Sort by score (descending)
+			if (b.score !== a.score) {
+				return b.score - a.score;
+			}
+			// If scores are equal, sort alphabetically
+			return a.path.localeCompare(b.path);
+		})
+		.slice(0, maxResults); // Limit results
+
+	return scoredFiles;
+}
+
+/**
+ * Clear the file list cache (useful for testing or when files change)
+ */
+export function clearFileListCache(): void {
+	fileListCache = null;
+}

package/source/utils/file-cache.spec.ts

@@ -0,0 +1,309 @@
+import test from 'ava';
+import {mkdtemp, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {
+	getCachedFileContent,
+	invalidateCache,
+	clearCache,
+	getCacheSize,
+	MAX_CACHE_SIZE,
+} from './file-cache';
+
+// Helper to create a temp directory for tests
+async function createTempDir(): Promise<string> {
+	return mkdtemp(join(tmpdir(), 'file-cache-test-'));
+}
+
+// Helper to clean up temp directory
+async function cleanupTempDir(dir: string): Promise<void> {
+	await rm(dir, {recursive: true, force: true});
+}
+
+// Helper to add small delay
+function delay(ms: number): Promise<void> {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+test.beforeEach(() => {
+	clearCache();
+});
+
+test('getCachedFileContent - cache miss reads from disk', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'test.txt');
+		await writeFile(filePath, 'hello world', 'utf-8');
+
+		const result = await getCachedFileContent(filePath);
+
+		t.is(result.content, 'hello world');
+		t.deepEqual(result.lines, ['hello world']);
+		t.is(typeof result.mtime, 'number');
+		t.is(typeof result.cachedAt, 'number');
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - cache hit returns same content', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'test.txt');
+		await writeFile(filePath, 'cached content', 'utf-8');
+
+		const result1 = await getCachedFileContent(filePath);
+		const result2 = await getCachedFileContent(filePath);
+
+		// Should return exact same object reference (cache hit)
+		t.is(result1, result2);
+		t.is(result1.content, 'cached content');
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - mtime change triggers re-read', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'test.txt');
+		await writeFile(filePath, 'original content', 'utf-8');
+
+		const result1 = await getCachedFileContent(filePath);
+		t.is(result1.content, 'original content');
+
+		// Modify file (changes mtime)
+		await delay(10); // Ensure different mtime
+		await writeFile(filePath, 'modified content', 'utf-8');
+
+		const result2 = await getCachedFileContent(filePath);
+
+		// Should have re-read from disk
+		t.is(result2.content, 'modified content');
+		t.not(result1, result2); // Different object
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - splits content into lines', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'multiline.txt');
+		await writeFile(filePath, 'line 1\nline 2\nline 3', 'utf-8');
+
+		const result = await getCachedFileContent(filePath);
+
+		t.deepEqual(result.lines, ['line 1', 'line 2', 'line 3']);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('invalidateCache - removes cache entry', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'test.txt');
+		await writeFile(filePath, 'content', 'utf-8');
+
+		await getCachedFileContent(filePath);
+		t.is(getCacheSize(), 1);
+
+		invalidateCache(filePath);
+		t.is(getCacheSize(), 0);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('invalidateCache - handles non-existent entry gracefully', t => {
+	t.notThrows(() => {
+		invalidateCache('/non/existent/path');
+	});
+});
+
+test('clearCache - removes all entries', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const file1 = join(tempDir, 'test1.txt');
+		const file2 = join(tempDir, 'test2.txt');
+		await writeFile(file1, 'content1', 'utf-8');
+		await writeFile(file2, 'content2', 'utf-8');
+
+		await getCachedFileContent(file1);
+		await getCachedFileContent(file2);
+		t.is(getCacheSize(), 2);
+
+		clearCache();
+		t.is(getCacheSize(), 0);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - concurrent access is deduplicated', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'concurrent.txt');
+		await writeFile(filePath, 'concurrent content', 'utf-8');
+
+		// Launch multiple concurrent reads - they should be deduplicated
+		const [result1, result2, result3] = await Promise.all([
+			getCachedFileContent(filePath),
+			getCachedFileContent(filePath),
+			getCachedFileContent(filePath),
+		]);
+
+		// All should return the same content
+		t.is(result1.content, 'concurrent content');
+		t.is(result2.content, 'concurrent content');
+		t.is(result3.content, 'concurrent content');
+
+		// All should return the exact same object (deduplicated read)
+		t.is(result1, result2);
+		t.is(result2, result3);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - throws on non-existent file', async t => {
+	await t.throwsAsync(
+		async () => getCachedFileContent('/non/existent/file.txt'),
+		{code: 'ENOENT'},
+	);
+});
+
+test('getCachedFileContent - cache hit within TTL window returns same object', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'ttl-test.txt');
+		await writeFile(filePath, 'original', 'utf-8');
+
+		const result1 = await getCachedFileContent(filePath);
+		t.is(result1.content, 'original');
+
+		// Verify entry exists in cache
+		t.is(getCacheSize(), 1);
+
+		// Second read within TTL window should return same object
+		const result2 = await getCachedFileContent(filePath);
+		t.is(result1, result2); // Same object reference = cache hit
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - handles empty file', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'empty.txt');
+		await writeFile(filePath, '', 'utf-8');
+
+		const result = await getCachedFileContent(filePath);
+
+		t.is(result.content, '');
+		t.deepEqual(result.lines, ['']);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - LRU eviction when cache exceeds MAX_CACHE_SIZE', async t => {
+	const tempDir = await createTempDir();
+	try {
+		// Create MAX_CACHE_SIZE + 1 files to trigger eviction
+		const filePaths: string[] = [];
+		for (let i = 0; i <= MAX_CACHE_SIZE; i++) {
+			const filePath = join(tempDir, `file-${i}.txt`);
+			await writeFile(filePath, `content-${i}`, 'utf-8');
+			filePaths.push(filePath);
+		}
+
+		// Cache the first MAX_CACHE_SIZE files
+		for (let i = 0; i < MAX_CACHE_SIZE; i++) {
+			await getCachedFileContent(filePaths[i]!);
+		}
+		t.is(getCacheSize(), MAX_CACHE_SIZE);
+
+		// Access file-0 again to make it recently used
+		await getCachedFileContent(filePaths[0]!);
+
+		// Add one more file - this should evict the LRU entry (file-1, not file-0)
+		await getCachedFileContent(filePaths[MAX_CACHE_SIZE]!);
+
+		// Cache size should still be MAX_CACHE_SIZE (one was evicted)
+		t.is(getCacheSize(), MAX_CACHE_SIZE);
+
+		// file-0 should still be cached (was recently accessed)
+		const result0 = await getCachedFileContent(filePaths[0]!);
+		t.is(result0.content, 'content-0');
+
+		// The newest file should be cached
+		const resultNew = await getCachedFileContent(filePaths[MAX_CACHE_SIZE]!);
+		t.is(resultNew.content, `content-${MAX_CACHE_SIZE}`);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+// ============================================================================
+// Tests for Retry Mechanism and Edge Cases
+// ============================================================================
+
+test('getCachedFileContent - concurrent reads with mtime change get consistent result', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'concurrent-mtime.txt');
+		await writeFile(filePath, 'original', 'utf-8');
+
+		// First, cache the file
+		const initial = await getCachedFileContent(filePath);
+		t.is(initial.content, 'original');
+
+		// Modify the file to trigger mtime change
+		await delay(10);
+		await writeFile(filePath, 'modified', 'utf-8');
+
+		// Launch multiple concurrent reads - they should all see the modified content
+		// and should be deduplicated (not cause multiple disk reads)
+		const [result1, result2, result3] = await Promise.all([
+			getCachedFileContent(filePath),
+			getCachedFileContent(filePath),
+			getCachedFileContent(filePath),
+		]);
+
+		// All should have the modified content
+		t.is(result1.content, 'modified');
+		t.is(result2.content, 'modified');
+		t.is(result3.content, 'modified');
+
+		// All should be the same object (deduplication worked)
+		t.is(result1, result2);
+		t.is(result2, result3);
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});
+
+test('getCachedFileContent - handles rapid sequential modifications', async t => {
+	const tempDir = await createTempDir();
+	try {
+		const filePath = join(tempDir, 'rapid-mods.txt');
+		await writeFile(filePath, 'v1', 'utf-8');
+
+		// Cache initial version
+		const v1 = await getCachedFileContent(filePath);
+		t.is(v1.content, 'v1');
+
+		// Rapidly modify and read multiple times
+		for (let i = 2; i <= 5; i++) {
+			await delay(10); // Ensure different mtime
+			await writeFile(filePath, `v${i}`, 'utf-8');
+			const result = await getCachedFileContent(filePath);
+			t.is(result.content, `v${i}`, `Should see version ${i}`);
+		}
+	} finally {
+		await cleanupTempDir(tempDir);
+	}
+});

package/source/utils/file-cache.ts

@@ -0,0 +1,195 @@
+import {readFile, stat} from 'node:fs/promises';
+import {CACHE_FILE_TTL_MS, MAX_FILE_READ_RETRIES} from '@/constants';
+
+/**
+ * File content cache to reduce duplicate file reads during tool confirmation flow.
+ *
+ * The cache stores file content with mtime tracking to ensure data freshness.
+ * Entries auto-expire after TTL_MS and are invalidated if file mtime changes.
+ */
+
+/** Maximum number of files to cache (exported for testing) */
+export const MAX_CACHE_SIZE = 50;
+
+export interface CachedFile {
+	content: string;
+	lines: string[];
+	mtime: number;
+	cachedAt: number;
+}
+
+interface CacheEntry {
+	data: CachedFile;
+	accessOrder: number;
+}
+
+// Internal cache storage
+const cache = new Map<string, CacheEntry>();
+let accessCounter = 0;
+
+// Track pending reads to deduplicate concurrent requests for the same file
+const pendingReads = new Map<string, Promise<CachedFile>>();
+
+/**
+ * Get file content from cache or read from disk.
+ * Automatically checks mtime to ensure freshness.
+ * Deduplicates concurrent requests for the same file.
+ *
+ * @param absPath - Absolute path to the file
+ * @returns Cached file data with content, lines array, and mtime
+ */
+export async function getCachedFileContent(
+	absPath: string,
+): Promise<CachedFile> {
+	const now = Date.now();
+	const entry = cache.get(absPath);
+
+	if (entry) {
+		const {data} = entry;
+
+		// Check if cache entry has expired (TTL)
+		if (now - data.cachedAt > CACHE_FILE_TTL_MS) {
+			cache.delete(absPath);
+		} else {
+			// Check if file mtime has changed
+			try {
+				const fileStat = await stat(absPath);
+				const currentMtime = fileStat.mtimeMs;
+
+				if (currentMtime === data.mtime) {
+					// Cache hit - update access order for LRU
+					entry.accessOrder = ++accessCounter;
+					return data;
+				}
+				// File was modified, invalidate cache and re-read
+				cache.delete(absPath);
+
+				// Check for pending read before starting a new one (deduplication)
+				let pending = pendingReads.get(absPath);
+				if (!pending) {
+					// Reuse the stat we just did to avoid double stat
+					pending = readAndCacheFile(absPath, now, fileStat.mtimeMs);
+					pendingReads.set(absPath, pending);
+				}
+
+				try {
+					return await pending;
+				} finally {
+					pendingReads.delete(absPath);
+				}
+			} catch {
+				// File may have been deleted, invalidate cache
+				cache.delete(absPath);
+			}
+		}
+	}
+
+	// Check if there's already a pending read for this file
+	const pending = pendingReads.get(absPath);
+	if (pending) {
+		return pending;
+	}
+
+	// Cache miss - read from disk with deduplication
+	const readPromise = readAndCacheFile(absPath, now);
+	pendingReads.set(absPath, readPromise);
+
+	try {
+		return await readPromise;
+	} finally {
+		pendingReads.delete(absPath);
+	}
+}
+
+/**
+ * Read file from disk and cache it.
+ * Verifies mtime didn't change during read to prevent race conditions.
+ * Retries up to MAX_READ_RETRIES times if file changes during read.
+ */
+async function readAndCacheFile(
+	absPath: string,
+	now: number,
+	knownMtime?: number,
+	retryCount = 0,
+): Promise<CachedFile> {
+	// Get mtime before reading (or use known mtime from caller)
+	const mtimeBefore = knownMtime ?? (await stat(absPath)).mtimeMs;
+
+	const content = await readFile(absPath, 'utf-8');
+
+	// Verify mtime didn't change during read
+	const mtimeAfter = (await stat(absPath)).mtimeMs;
+	if (mtimeAfter !== mtimeBefore) {
+		if (retryCount >= MAX_FILE_READ_RETRIES) {
+			throw new Error(
+				`File ${absPath} is being modified too frequently, giving up after ${MAX_FILE_READ_RETRIES} retries`,
+			);
+		}
+		// File changed during read, retry with fresh timestamp
+		return readAndCacheFile(absPath, Date.now(), undefined, retryCount + 1);
+	}
+
+	const cachedFile: CachedFile = {
+		content,
+		lines: content.split('\n'),
+		mtime: mtimeAfter,
+		cachedAt: now,
+	};
+
+	// Enforce max cache size with LRU eviction
+	if (cache.size >= MAX_CACHE_SIZE) {
+		evictLRU();
+	}
+
+	cache.set(absPath, {
+		data: cachedFile,
+		accessOrder: ++accessCounter,
+	});
+
+	return cachedFile;
+}
+
+/**
+ * Invalidate cache entry for a specific file.
+ * Should be called after write operations complete.
+ *
+ * @param absPath - Absolute path to the file to invalidate
+ */
+export function invalidateCache(absPath: string): void {
+	cache.delete(absPath);
+}
+
+/**
+ * Clear all cache entries.
+ */
+export function clearCache(): void {
+	cache.clear();
+	pendingReads.clear();
+	accessCounter = 0;
+}
+
+/**
+ * Get current cache size (for testing/debugging).
+ */
+export function getCacheSize(): number {
+	return cache.size;
+}
+
+/**
+ * Evict the least recently used entry from the cache.
+ */
+function evictLRU(): void {
+	let oldestKey: string | null = null;
+	let oldestOrder = Infinity;
+
+	for (const [key, entry] of cache) {
+		if (entry.accessOrder < oldestOrder) {
+			oldestOrder = entry.accessOrder;
+			oldestKey = key;
+		}
+	}
+
+	if (oldestKey) {
+		cache.delete(oldestKey);
+	}
+}