@gguf/coder 0.3.1 → 0.3.2

package/source/utils/file-autocomplete.ts

@@ -1,196 +0,0 @@
-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

@@ -1,309 +0,0 @@
-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

@@ -1,195 +0,0 @@
-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);
-	}
-}