@gguf/coder 0.3.0 → 0.3.1

package/source/utils/file-content-loader.spec.ts

@@ -0,0 +1,180 @@
+import {mkdir, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import test from 'ava';
+import {formatFileForContext, loadFileContent} from './file-content-loader.js';
+
+console.log(`\nfile-content-loader.spec.ts`);
+
+// Test setup - create temp directory for test files
+let testDir: string;
+
+test.before(async () => {
+	// Create a unique temp directory for our tests
+	testDir = join(tmpdir(), `coder-test-${Date.now()}`);
+	await mkdir(testDir, {recursive: true});
+
+	// Create test files
+	await writeFile(
+		join(testDir, 'test.txt'),
+		'Line 1\nLine 2\nLine 3\nLine 4\nLine 5',
+		'utf-8',
+	);
+
+	await writeFile(
+		join(testDir, 'app.tsx'),
+		'import React from "react";\n\nexport function App() {\n  return <div>Hello</div>;\n}',
+		'utf-8',
+	);
+});
+
+test.after.always(async () => {
+	// Clean up temp directory
+	try {
+		await rm(testDir, {recursive: true, force: true});
+	} catch {
+		// Ignore cleanup errors
+	}
+});
+
+// Tests for loadFileContent()
+test('loads file content successfully', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'));
+
+	t.true(result.success);
+	t.truthy(result.content);
+	t.is(result.metadata.lineCount, 5);
+	t.true(result.metadata.size > 0);
+});
+
+test('loads file with line range', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 2,
+		end: 4,
+	});
+
+	t.true(result.success);
+	t.truthy(result.content);
+	t.is(result.metadata.lineCount, 3); // Lines 2, 3, 4
+	t.deepEqual(result.metadata.lineRange, {start: 2, end: 4});
+});
+
+test('loads single line', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 3,
+	});
+
+	t.true(result.success);
+	t.is(result.metadata.lineCount, 1);
+	t.deepEqual(result.metadata.lineRange, {start: 3, end: undefined});
+});
+
+test('handles line range beyond file length', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 3,
+		end: 100,
+	});
+
+	t.true(result.success);
+	t.is(result.metadata.lineCount, 3); // Lines 3, 4, 5 (only 3 lines available)
+});
+
+test('handles line start beyond file length', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 100,
+		end: 200,
+	});
+
+	t.true(result.success);
+	t.is(result.metadata.lineCount, 0); // No lines available
+});
+
+test('handles non-existent file', async t => {
+	const result = await loadFileContent(join(testDir, 'nonexistent.txt'));
+
+	t.false(result.success);
+	t.truthy(result.error);
+	t.is(result.metadata.size, 0);
+	t.is(result.metadata.lineCount, 0);
+});
+
+test('formats content with line numbers', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 2,
+		end: 3,
+	});
+
+	t.true(result.success);
+	t.truthy(result.content);
+	// Should have line numbers like "   2: Line 2"
+	t.true(result.content!.includes('   2:'));
+	t.true(result.content!.includes('   3:'));
+});
+
+test('calculates token estimate', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'));
+
+	t.true(result.success);
+	t.true(result.metadata.tokens > 0);
+	// Rough token estimate should be ~1/4 of character count
+	t.true(result.metadata.tokens <= result.metadata.size);
+});
+
+test('stores absolute path in metadata', async t => {
+	const relativePath = join(testDir, 'test.txt');
+	const result = await loadFileContent(relativePath);
+
+	t.true(result.success);
+	t.is(result.metadata.path, relativePath);
+	t.truthy(result.metadata.absolutePath);
+	// Absolute path should be longer or equal (handles relative paths)
+	t.true(result.metadata.absolutePath.length >= relativePath.length);
+});
+
+// Tests for formatFileForContext()
+test('formats file for LLM context with header and footer', async t => {
+	const result = await loadFileContent(join(testDir, 'app.tsx'));
+	const formatted = formatFileForContext(result);
+
+	// The header includes the full path, not just filename
+	t.true(formatted.includes('=== File:'));
+	t.true(formatted.includes('app.tsx'));
+	t.true(formatted.includes('==='));
+	t.true(result.content ? formatted.includes(result.content) : false);
+});
+
+test('formats file with line range info', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 2,
+		end: 4,
+	});
+	const formatted = formatFileForContext(result);
+
+	t.true(formatted.includes('Lines 2-4'));
+	t.true(formatted.includes('(3 lines'));
+});
+
+test('formats file with single line info', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'), {
+		start: 3,
+	});
+	const formatted = formatFileForContext(result);
+
+	t.true(formatted.includes('Lines 3'));
+	t.false(formatted.includes('Lines 3-')); // Should not have a range
+});
+
+test('handles error in formatFileForContext', async t => {
+	const result = await loadFileContent(join(testDir, 'nonexistent.txt'));
+	const formatted = formatFileForContext(result);
+
+	t.true(formatted.includes('Error loading file'));
+});
+
+test('includes token estimate in formatted output', async t => {
+	const result = await loadFileContent(join(testDir, 'test.txt'));
+	const formatted = formatFileForContext(result);
+
+	t.true(formatted.includes('tokens'));
+	t.true(/~\d+ tokens/.test(formatted)); // Should have "~123 tokens" format
+});

package/source/utils/file-content-loader.ts

@@ -0,0 +1,179 @@
+import {readFile, stat} from 'node:fs/promises';
+import {resolve} from 'node:path';
+
+interface FileContentResult {
+	success: boolean;
+	content?: string;
+	error?: string;
+	metadata: {
+		path: string;
+		absolutePath: string;
+		size: number;
+		lineCount: number;
+		lineRange?: {start: number; end?: number};
+		tokens: number;
+	};
+}
+
+/**
+ * Load file content with optional line range
+ * Silently handles errors - returns success: false instead of throwing
+ */
+export async function loadFileContent(
+	filePath: string,
+	lineRange?: {start: number; end?: number},
+): Promise<FileContentResult> {
+	try {
+		const absPath = resolve(filePath);
+
+		// Check if file exists and get stats
+		const fileStats = await stat(absPath);
+
+		// Check if it's a file (not directory)
+		if (!fileStats.isFile()) {
+			return {
+				success: false,
+				error: 'Path is not a file',
+				metadata: {
+					path: filePath,
+					absolutePath: absPath,
+					size: 0,
+					lineCount: 0,
+					lineRange,
+					tokens: 0,
+				},
+			};
+		}
+
+		// Read file content
+		let content: string;
+		try {
+			content = await readFile(absPath, 'utf-8');
+		} catch {
+			// File might be binary or unreadable
+			return {
+				success: false,
+				error: 'Failed to read file (might be binary)',
+				metadata: {
+					path: filePath,
+					absolutePath: absPath,
+					size: fileStats.size,
+					lineCount: 0,
+					lineRange,
+					tokens: 0,
+				},
+			};
+		}
+
+		// Split into lines
+		const allLines = content.split('\n');
+		const totalLines = allLines.length;
+
+		// Extract line range if specified
+		let selectedLines: string[];
+		let actualLineRange: {start: number; end?: number} | undefined;
+
+		if (lineRange) {
+			const start = Math.max(1, lineRange.start);
+			const end = lineRange.end ? Math.min(totalLines, lineRange.end) : start;
+
+			// Validate range
+			if (start > totalLines) {
+				// Invalid range, return empty
+				selectedLines = [];
+			} else {
+				// Arrays are 0-indexed, but line numbers are 1-indexed
+				selectedLines = allLines.slice(start - 1, end);
+				actualLineRange = {start, end: lineRange.end ? end : undefined};
+			}
+		} else {
+			// No line range, use all lines
+			selectedLines = allLines;
+		}
+
+		// Format with line numbers
+		const formattedContent = formatFileContentWithLineNumbers(
+			selectedLines,
+			lineRange?.start || 1,
+		);
+
+		// Calculate metadata
+		const size = content.length;
+		const tokens = Math.ceil(formattedContent.length / 4); // Rough token estimate
+
+		return {
+			success: true,
+			content: formattedContent,
+			metadata: {
+				path: filePath,
+				absolutePath: absPath,
+				size,
+				lineCount: selectedLines.length,
+				lineRange: actualLineRange,
+				tokens,
+			},
+		};
+	} catch (error) {
+		// File doesn't exist or other error
+		const absPath = resolve(filePath);
+		return {
+			success: false,
+			error: error instanceof Error ? error.message : 'Unknown error',
+			metadata: {
+				path: filePath,
+				absolutePath: absPath,
+				size: 0,
+				lineCount: 0,
+				lineRange,
+				tokens: 0,
+			},
+		};
+	}
+}
+
+/**
+ * Format file lines with line numbers
+ */
+function formatFileContentWithLineNumbers(
+	lines: string[],
+	startLineNumber: number,
+): string {
+	let result = '';
+	for (let i = 0; i < lines.length; i++) {
+		const lineNum = String(startLineNumber + i).padStart(4, ' ');
+		result += `${lineNum}: ${lines[i]}\n`;
+	}
+	return result.slice(0, -1); // Remove trailing newline
+}
+
+/**
+ * Format file content with header for LLM context
+ * Used when assembling the prompt
+ */
+export function formatFileForContext(result: FileContentResult): string {
+	if (!result.success || !result.content) {
+		return `Error loading file: ${result.metadata.path}`;
+	}
+
+	const {path, lineCount, lineRange, tokens} = result.metadata;
+
+	let header: string;
+	if (lineRange) {
+		const rangeStr = lineRange.end
+			? `${lineRange.start}-${lineRange.end}`
+			: `${lineRange.start}`;
+		header = `=== File: ${path} (Lines ${rangeStr}) ===`;
+	} else {
+		header = `=== File: ${path} ===`;
+	}
+
+	const footer = '='.repeat(header.length);
+
+	const stats = lineRange
+		? `Lines: ${lineRange.start}${
+				lineRange.end ? `-${lineRange.end}` : ''
+			} (${lineCount} lines, ~${tokens} tokens)`
+		: `Lines: ${lineCount}, ~${tokens} tokens`;
+
+	return `${header}\n${stats}\n\n${result.content}\n${footer}`;
+}

package/source/utils/file-mention-handler.spec.ts

@@ -0,0 +1,261 @@
+import {mkdir, rm, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import test from 'ava';
+import {type PlaceholderContent, PlaceholderType} from '../types/hooks.js';
+import {
+	handleFileMention,
+	parseLineRangeFromMention,
+} from './file-mention-handler.js';
+
+console.log(`\nfile-mention-handler.spec.ts`);
+
+// Test setup - create temp directory for test files
+let testDir: string;
+
+test.before(async () => {
+	// Create a unique temp directory for our tests
+	testDir = join(tmpdir(), `coder-handler-test-${Date.now()}`);
+	await mkdir(testDir, {recursive: true});
+
+	// Create test files
+	await writeFile(
+		join(testDir, 'test.txt'),
+		'Line 1\nLine 2\nLine 3\nLine 4\nLine 5',
+		'utf-8',
+	);
+
+	await writeFile(
+		join(testDir, 'app.tsx'),
+		'import React from "react";\n\nexport function App() {\n  return <div>Hello</div>;\n}',
+		'utf-8',
+	);
+});
+
+test.after.always(async () => {
+	// Clean up temp directory
+	try {
+		await rm(testDir, {recursive: true, force: true});
+	} catch {
+		// Ignore cleanup errors
+	}
+});
+
+// Tests for handleFileMention()
+test('creates placeholder for existing file', async t => {
+	const filePath = join(testDir, 'test.txt');
+	const result = await handleFileMention(
+		filePath,
+		'Check @test.txt',
+		{},
+		'@test.txt',
+	);
+
+	t.truthy(result);
+	// Handler uses the filePath passed in for the placeholder display
+	t.is(result!.displayValue, `Check [@${filePath}]`);
+	t.is(Object.keys(result!.placeholderContent).length, 1);
+
+	const placeholder = Object.values(result!.placeholderContent)[0];
+	t.is(placeholder.type, PlaceholderType.FILE);
+	t.true(placeholder.content.includes('Line 1'));
+});
+
+test('creates placeholder with line range', async t => {
+	const filePath = join(testDir, 'test.txt');
+	const result = await handleFileMention(
+		filePath,
+		'Check @test.txt:2-4',
+		{},
+		'@test.txt:2-4',
+		{start: 2, end: 4},
+	);
+
+	t.truthy(result);
+	t.is(result!.displayValue, `Check [@${filePath}:2-4]`);
+
+	const placeholder = Object.values(result!.placeholderContent)[0];
+	t.true(placeholder.content.includes('Line 2'));
+	t.true(placeholder.content.includes('Line 4'));
+	t.false(placeholder.content.includes('Line 1'));
+});
+
+test('creates placeholder with single line', async t => {
+	const filePath = join(testDir, 'test.txt');
+	const result = await handleFileMention(
+		filePath,
+		'Check @test.txt:3',
+		{},
+		'@test.txt:3',
+		{start: 3},
+	);
+
+	t.truthy(result);
+	t.is(result!.displayValue, `Check [@${filePath}:3]`);
+
+	const placeholder = Object.values(result!.placeholderContent)[0];
+	t.true(placeholder.content.includes('Line 3'));
+});
+
+test('returns null for non-existent file', async t => {
+	const result = await handleFileMention(
+		join(testDir, 'nonexistent.txt'),
+		'Check @nonexistent.txt',
+		{},
+		'@nonexistent.txt',
+	);
+
+	t.is(result, null);
+});
+
+test('generates unique file IDs', async t => {
+	// First file mention
+	const result1 = await handleFileMention(
+		join(testDir, 'test.txt'),
+		'Check @test.txt',
+		{},
+		'@test.txt',
+	);
+
+	t.truthy(result1);
+	t.true(Object.keys(result1!.placeholderContent).includes('file_1'));
+
+	// Second file mention (with existing placeholder)
+	const result2 = await handleFileMention(
+		join(testDir, 'app.tsx'),
+		'Check @test.txt and @app.tsx',
+		result1!.placeholderContent,
+		'@app.tsx',
+	);
+
+	t.truthy(result2);
+	t.true(Object.keys(result2!.placeholderContent).includes('file_1'));
+	t.true(Object.keys(result2!.placeholderContent).includes('file_2'));
+});
+
+test('preserves existing placeholders', async t => {
+	const existingPlaceholder: Record<string, PlaceholderContent> = {
+		file_1: {
+			type: PlaceholderType.FILE,
+			displayText: '[@existing.txt]',
+			filePath: '/test/existing.txt',
+			content: 'existing content',
+			fileSize: 100,
+		} as PlaceholderContent,
+	};
+
+	const result = await handleFileMention(
+		join(testDir, 'test.txt'),
+		'Check @test.txt',
+		existingPlaceholder,
+		'@test.txt',
+	);
+
+	t.truthy(result);
+	t.is(Object.keys(result!.placeholderContent).length, 2);
+	t.truthy(result!.placeholderContent.file_1);
+	t.truthy(result!.placeholderContent.file_2);
+});
+
+test('replaces mention text in display value', async t => {
+	const filePath = join(testDir, 'app.tsx');
+	const result = await handleFileMention(
+		filePath,
+		'Please review the code in @app.tsx carefully',
+		{},
+		'@app.tsx',
+	);
+
+	t.truthy(result);
+	t.is(
+		result!.displayValue,
+		`Please review the code in [@${filePath}] carefully`,
+	);
+});
+
+test('handles multiple mentions in display value', async t => {
+	const testPath = join(testDir, 'test.txt');
+	const appPath = join(testDir, 'app.tsx');
+
+	// First mention
+	const result1 = await handleFileMention(
+		testPath,
+		'Compare @test.txt and @app.tsx',
+		{},
+		'@test.txt',
+	);
+
+	t.truthy(result1);
+
+	// Second mention
+	const result2 = await handleFileMention(
+		appPath,
+		result1!.displayValue,
+		result1!.placeholderContent,
+		'@app.tsx',
+	);
+
+	t.truthy(result2);
+	t.is(result2!.displayValue, `Compare [@${testPath}] and [@${appPath}]`);
+});
+
+test('stores absolute path in placeholder', async t => {
+	const relativePath = join(testDir, 'test.txt');
+	const result = await handleFileMention(
+		relativePath,
+		'Check @test.txt',
+		{},
+		'@test.txt',
+	);
+
+	t.truthy(result);
+	const placeholder = Object.values(result!.placeholderContent)[0];
+	// Absolute path should be stored
+	t.is(placeholder.type, PlaceholderType.FILE);
+	if (placeholder.type === PlaceholderType.FILE) {
+		t.true(placeholder.filePath.startsWith('/'));
+		t.true(placeholder.filePath.includes('test.txt'));
+	}
+});
+
+test('includes file content in placeholder', async t => {
+	const result = await handleFileMention(
+		join(testDir, 'app.tsx'),
+		'Check @app.tsx',
+		{},
+		'@app.tsx',
+	);
+
+	t.truthy(result);
+	const placeholder = Object.values(result!.placeholderContent)[0];
+	t.truthy(placeholder.content);
+	t.true(placeholder.content.length > 0);
+	t.true(placeholder.content.includes('React'));
+});
+
+// Tests for parseLineRangeFromMention()
+test('parseLineRangeFromMention parses range', t => {
+	const result = parseLineRangeFromMention('@file.ts:10-20');
+	t.deepEqual(result, {start: 10, end: 20});
+});
+
+test('parseLineRangeFromMention parses single line', t => {
+	const result = parseLineRangeFromMention('@file.ts:10');
+	t.deepEqual(result, {start: 10, end: undefined});
+});
+
+test('parseLineRangeFromMention returns undefined for no range', t => {
+	const result = parseLineRangeFromMention('@file.ts');
+	t.is(result, undefined);
+});
+
+test('parseLineRangeFromMention handles invalid range', t => {
+	const result = parseLineRangeFromMention('@file.ts:abc');
+	t.is(result, undefined);
+});
+
+test('parseLineRangeFromMention handles path with colons', t => {
+	// Should only parse the last colon as line range
+	const result = parseLineRangeFromMention('@src/path:to:file.ts:10-20');
+	t.deepEqual(result, {start: 10, end: 20});
+});

package/source/utils/file-mention-handler.ts

@@ -0,0 +1,84 @@
+import {
+	InputState,
+	PlaceholderContent,
+	PlaceholderType,
+} from '../types/hooks.js';
+import {loadFileContent} from './file-content-loader.js';
+
+/**
+ * Handle @file mention by creating a placeholder
+ * Called when file is selected from autocomplete or on message submit
+ *
+ * Returns null if file doesn't exist (silent failure per spec)
+ */
+export async function handleFileMention(
+	filePath: string,
+	currentDisplayValue: string,
+	currentPlaceholderContent: Record<string, PlaceholderContent>,
+	mentionText: string, // The original "@src/app.tsx:10-20" text to replace
+	lineRange?: {start: number; end?: number},
+): Promise<InputState | null> {
+	// Load file content
+	const fileResult = await loadFileContent(filePath, lineRange);
+
+	// If file doesn't exist or failed to load, return null (silently skip per spec)
+	if (!fileResult.success) {
+		return null;
+	}
+
+	// Generate unique ID for this file placeholder
+	const existingFileCount = Object.values(currentPlaceholderContent).filter(
+		content => content.type === PlaceholderType.FILE,
+	).length;
+	const fileId = `file_${existingFileCount + 1}`;
+
+	// Create compact placeholder for display
+	const placeholder = lineRange
+		? `[@${filePath}:${lineRange.start}${
+				lineRange.end ? `-${lineRange.end}` : ''
+			}]`
+		: `[@${filePath}]`;
+
+	// Create file placeholder content
+	// Use the existing FilePlaceholderContent interface
+	const fileContent: PlaceholderContent = {
+		type: PlaceholderType.FILE,
+		displayText: placeholder,
+		filePath: fileResult.metadata.absolutePath,
+		content: fileResult.content || '',
+		lastModified: Date.now(),
+		encoding: 'utf-8',
+		fileSize: fileResult.metadata.size,
+	};
+
+	const newPlaceholderContent = {
+		...currentPlaceholderContent,
+		[fileId]: fileContent,
+	};
+
+	// Replace the @mention text with placeholder in display
+	const newDisplayValue = currentDisplayValue.replace(mentionText, placeholder);
+
+	return {
+		displayValue: newDisplayValue,
+		placeholderContent: newPlaceholderContent,
+	};
+}
+
+/**
+ * Parse line range from mention text if present
+ * e.g., "@app.tsx:10-20" -> {start: 10, end: 20}
+ */
+export function parseLineRangeFromMention(
+	mentionText: string,
+): {start: number; end?: number} | undefined {
+	const match = mentionText.match(/:(\d+)(?:-(\d+))?$/);
+	if (!match) {
+		return undefined;
+	}
+
+	const start = parseInt(match[1], 10);
+	const end = match[2] ? parseInt(match[2], 10) : undefined;
+
+	return {start, end};
+}