@gguf/coder 0.3.0 → 0.3.1

package/source/utils/paste-utils.ts

@@ -0,0 +1,52 @@
+import {
+	InputState,
+	PastePlaceholderContent,
+	PlaceholderContent,
+	PlaceholderType,
+} from '../types/hooks';
+
+export function handlePaste(
+	pastedText: string,
+	currentDisplayValue: string,
+	currentPlaceholderContent: Record<string, PlaceholderContent>,
+	detectionMethod?: 'rate' | 'size' | 'multiline',
+): InputState | null {
+	// No minimum threshold - any detected paste gets a placeholder
+	// This is especially important for multi-line pastes where only the first line
+	// may be captured by the input component
+	if (pastedText.length === 0) {
+		return null;
+	}
+
+	// Generate simple incrementing ID based on existing paste placeholders
+	const existingPasteCount = Object.values(currentPlaceholderContent).filter(
+		content => content.type === PlaceholderType.PASTE,
+	).length;
+	const pasteId = (existingPasteCount + 1).toString();
+	const placeholder = `[Paste #${pasteId}: ${pastedText.length} chars]`;
+
+	const pasteContent: PastePlaceholderContent = {
+		type: PlaceholderType.PASTE,
+		displayText: placeholder,
+		content: pastedText,
+		originalSize: pastedText.length,
+		detectionMethod,
+		timestamp: Date.now(),
+	};
+
+	const newPlaceholderContent = {
+		...currentPlaceholderContent,
+		[pasteId]: pasteContent,
+	};
+
+	// For CLI paste detection, we need to replace the pasted text in the display value
+	// If the pasted text is at the end, replace it. Otherwise append the placeholder.
+	const newDisplayValue = currentDisplayValue.includes(pastedText)
+		? currentDisplayValue.replace(pastedText, placeholder)
+		: currentDisplayValue + placeholder;
+
+	return {
+		displayValue: newDisplayValue,
+		placeholderContent: newPlaceholderContent,
+	};
+}

package/source/utils/programming-language-helper.spec.ts

@@ -0,0 +1,74 @@
+import test from 'ava';
+import { getLanguageFromExtension } from './programming-language-helper';
+
+test('getLanguageFromExtension - returns javascript for JavaScript files', t => {
+	t.is(getLanguageFromExtension('js'), 'javascript');
+	t.is(getLanguageFromExtension('jsx'), 'javascript');
+});
+
+test('getLanguageFromExtension - returns typescript for TypeScript files', t => {
+	t.is(getLanguageFromExtension('ts'), 'typescript');
+	t.is(getLanguageFromExtension('tsx'), 'typescript');
+});
+
+test('getLanguageFromExtension - returns correct language for scripting languages', t => {
+	t.is(getLanguageFromExtension('py'), 'python');
+	t.is(getLanguageFromExtension('rb'), 'ruby');
+	t.is(getLanguageFromExtension('go'), 'go');
+});
+
+test('getLanguageFromExtension - returns correct language for compiled languages', t => {
+	t.is(getLanguageFromExtension('rs'), 'rust');
+	t.is(getLanguageFromExtension('java'), 'java');
+	t.is(getLanguageFromExtension('cpp'), 'cpp');
+	t.is(getLanguageFromExtension('c'), 'c');
+	t.is(getLanguageFromExtension('cs'), 'csharp');
+	t.is(getLanguageFromExtension('php'), 'php');
+});
+
+test('getLanguageFromExtension - returns correct language for web technologies', t => {
+	t.is(getLanguageFromExtension('html'), 'html');
+	t.is(getLanguageFromExtension('css'), 'css');
+	t.is(getLanguageFromExtension('scss'), 'scss');
+});
+
+test('getLanguageFromExtension - returns correct language for data formats', t => {
+	t.is(getLanguageFromExtension('json'), 'json');
+	t.is(getLanguageFromExtension('yaml'), 'yaml');
+	t.is(getLanguageFromExtension('yml'), 'yaml');
+	t.is(getLanguageFromExtension('xml'), 'xml');
+	t.is(getLanguageFromExtension('md'), 'markdown');
+});
+
+test('getLanguageFromExtension - returns bash for all shell variants', t => {
+	t.is(getLanguageFromExtension('sh'), 'bash');
+	t.is(getLanguageFromExtension('bash'), 'bash');
+	t.is(getLanguageFromExtension('zsh'), 'bash');
+	t.is(getLanguageFromExtension('fish'), 'bash');
+});
+
+test('getLanguageFromExtension - returns sql for SQL files', t => {
+	t.is(getLanguageFromExtension('sql'), 'sql');
+});
+
+test('getLanguageFromExtension - returns javascript for undefined extension', t => {
+	t.is(getLanguageFromExtension(undefined), 'javascript');
+});
+
+test('getLanguageFromExtension - returns javascript for empty string extension', t => {
+	t.is(getLanguageFromExtension(''), 'javascript');
+});
+
+test('getLanguageFromExtension - returns javascript for unknown extensions', t => {
+	t.is(getLanguageFromExtension('unknown'), 'javascript');
+	t.is(getLanguageFromExtension('xyz'), 'javascript');
+	t.is(getLanguageFromExtension('exe'), 'javascript');
+	t.is(getLanguageFromExtension('txt'), 'javascript');
+});
+
+test('getLanguageFromExtension - is case sensitive', t => {
+	// The function doesn't convert to lowercase, so it should return javascript for uppercase
+	t.is(getLanguageFromExtension('JS'), 'javascript');
+	t.is(getLanguageFromExtension('TS'), 'javascript');
+	t.is(getLanguageFromExtension('PY'), 'javascript');
+});

package/source/utils/programming-language-helper.ts

@@ -0,0 +1,32 @@
+export function getLanguageFromExtension(ext?: string): string {
+	const languageMap: Record<string, string> = {
+		js: 'javascript',
+		jsx: 'javascript',
+		ts: 'typescript',
+		tsx: 'typescript',
+		py: 'python',
+		rb: 'ruby',
+		go: 'go',
+		rs: 'rust',
+		java: 'java',
+		cpp: 'cpp',
+		c: 'c',
+		cs: 'csharp',
+		php: 'php',
+		html: 'html',
+		css: 'css',
+		scss: 'scss',
+		json: 'json',
+		yaml: 'yaml',
+		yml: 'yaml',
+		xml: 'xml',
+		md: 'markdown',
+		sh: 'bash',
+		bash: 'bash',
+		zsh: 'bash',
+		fish: 'bash',
+		sql: 'sql',
+	};
+
+	return languageMap[ext || ''] || 'javascript';
+}

package/source/utils/prompt-assembly.spec.ts

@@ -0,0 +1,221 @@
+import test from 'ava';
+import type {
+	InputState,
+	PastePlaceholderContent,
+	PlaceholderContent,
+} from '../types/hooks';
+import {PlaceholderType} from '../types/hooks';
+
+console.log(`\nprompt-assembly.spec.ts`);
+
+// Minimal implementation for testing - avoids complex dependencies
+function assemblePrompt(inputState: InputState): string {
+	let assembledPrompt = inputState.displayValue;
+
+	// Replace each placeholder with its full content
+	Object.entries(inputState.placeholderContent).forEach(
+		([placeholderId, placeholder]) => {
+			if (placeholder.type === 'paste') {
+				const placeholderPattern = `\\[Paste #${placeholderId}: \\d+ chars\\]`;
+				const regex = new RegExp(placeholderPattern, 'g');
+				assembledPrompt = assembledPrompt.replace(regex, placeholder.content);
+			} else if (placeholder.type === 'file') {
+				// For file placeholders: [@filepath] or [@filepath:10-20]
+				const escapedPath = placeholder.displayText.replace(
+					/[.*+?^${}()|[\]\\]/g,
+					'\\$&',
+				);
+				const regex = new RegExp(escapedPath, 'g');
+
+				// Format file content with header (mimicking prompt-processor.ts)
+				const fileName =
+					placeholder.filePath.split('/').pop() || placeholder.filePath;
+				const header = `=== File: ${fileName} ===`;
+				const footer = '='.repeat(header.length);
+				const formattedContent = `${header}\n${placeholder.content}\n${footer}`;
+
+				assembledPrompt = assembledPrompt.replace(regex, formattedContent);
+			}
+		},
+	);
+
+	return assembledPrompt;
+}
+
+function extractPlaceholderIds(displayValue: string): string[] {
+	const placeholderRegex = /\[Paste #(\d+): \d+ chars\]/g;
+	const matches = [];
+	let match;
+
+	while ((match = placeholderRegex.exec(displayValue)) !== null) {
+		matches.push(match[1]); // The captured paste ID
+	}
+
+	return matches;
+}
+
+// Tests for prompt assembly
+test('assemblePrompt replaces single placeholder with content', t => {
+	const inputState: InputState = {
+		displayValue: 'Analyze this: [Paste #1640995200: 100 chars]',
+		placeholderContent: {
+			'1640995200': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #1640995200: 100 chars]',
+				content: 'function test() { return "hello world"; }',
+				originalSize: 100,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+	t.is(result, 'Analyze this: function test() { return "hello world"; }');
+});
+
+test('assemblePrompt handles multiple placeholders', t => {
+	const inputState: InputState = {
+		displayValue: 'Compare [Paste #123: 50 chars] with [Paste #456: 30 chars]',
+		placeholderContent: {
+			'123': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #123: 50 chars]',
+				content: 'first code snippet',
+				originalSize: 50,
+			} as PastePlaceholderContent,
+			'456': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #456: 30 chars]',
+				content: 'second code snippet',
+				originalSize: 30,
+			} as PastePlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+	t.is(result, 'Compare first code snippet with second code snippet');
+});
+
+test('assemblePrompt handles no placeholders', t => {
+	const inputState: InputState = {
+		displayValue: 'Regular text without placeholders',
+		placeholderContent: {},
+	};
+
+	const result = assemblePrompt(inputState);
+	t.is(result, 'Regular text without placeholders');
+});
+
+test('extractPlaceholderIds finds all placeholder IDs', t => {
+	const displayValue =
+		'Text [Paste #123: 100 chars] more text [Paste #456: 200 chars]';
+	const result = extractPlaceholderIds(displayValue);
+
+	t.deepEqual(result, ['123', '456']);
+});
+
+test('extractPlaceholderIds returns empty for no placeholders', t => {
+	const displayValue = 'Regular text without placeholders';
+	const result = extractPlaceholderIds(displayValue);
+
+	t.deepEqual(result, []);
+});
+
+// FILE placeholder tests
+test('assemblePrompt replaces file placeholder with formatted content', t => {
+	const inputState: InputState = {
+		displayValue: 'Check this file: [@src/app.tsx]',
+		placeholderContent: {
+			file_1: {
+				type: PlaceholderType.FILE,
+				displayText: '[@src/app.tsx]',
+				filePath: '/Users/test/project/src/app.tsx',
+				content:
+					'   1: import React from "react";\n   2: export function App() {}',
+				fileSize: 100,
+			} as PlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+
+	t.true(result.includes('=== File: app.tsx ==='));
+	t.true(result.includes('import React from "react"'));
+	// Footer should be same length as header
+	t.true(result.includes('='.repeat('=== File: app.tsx ==='.length)));
+});
+
+test('assemblePrompt handles file placeholder with line range', t => {
+	const inputState: InputState = {
+		displayValue: 'Review [@app.tsx:10-20]',
+		placeholderContent: {
+			file_1: {
+				type: PlaceholderType.FILE,
+				displayText: '[@app.tsx:10-20]',
+				filePath: '/Users/test/app.tsx',
+				content: '  10: function test() {\n  11:   return true;\n  12: }',
+				fileSize: 50,
+			} as PlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+
+	t.true(result.includes('=== File: app.tsx ==='));
+	t.true(result.includes('function test()'));
+});
+
+test('assemblePrompt handles multiple file placeholders', t => {
+	const inputState: InputState = {
+		displayValue: 'Compare [@a.ts] with [@b.ts]',
+		placeholderContent: {
+			file_1: {
+				type: PlaceholderType.FILE,
+				displayText: '[@a.ts]',
+				filePath: '/project/a.ts',
+				content: '   1: const a = 1;',
+				fileSize: 20,
+			} as PlaceholderContent,
+			file_2: {
+				type: PlaceholderType.FILE,
+				displayText: '[@b.ts]',
+				filePath: '/project/b.ts',
+				content: '   1: const b = 2;',
+				fileSize: 20,
+			} as PlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+
+	t.true(result.includes('=== File: a.ts ==='));
+	t.true(result.includes('const a = 1'));
+	t.true(result.includes('=== File: b.ts ==='));
+	t.true(result.includes('const b = 2'));
+});
+
+test('assemblePrompt handles mixed paste and file placeholders', t => {
+	const inputState: InputState = {
+		displayValue: 'Text [Paste #123: 20 chars] and [@file.ts]',
+		placeholderContent: {
+			'123': {
+				type: PlaceholderType.PASTE,
+				displayText: '[Paste #123: 20 chars]',
+				content: 'pasted code',
+				originalSize: 20,
+			} as PastePlaceholderContent,
+			file_1: {
+				type: PlaceholderType.FILE,
+				displayText: '[@file.ts]',
+				filePath: '/project/file.ts',
+				content: '   1: export const x = 1;',
+				fileSize: 30,
+			} as PlaceholderContent,
+		},
+	};
+
+	const result = assemblePrompt(inputState);
+
+	t.true(result.includes('pasted code'));
+	t.true(result.includes('=== File: file.ts ==='));
+	t.true(result.includes('export const x = 1'));
+});

package/source/utils/prompt-processor.ts

@@ -0,0 +1,173 @@
+import {existsSync, readFileSync} from 'fs';
+import {homedir, platform, release} from 'os';
+import {join} from 'path';
+import {promptPath} from '../config/index';
+import type {InputState} from '../types/hooks';
+import {PlaceholderType} from '../types/hooks';
+import {getLogger} from './logging';
+
+/**
+ * Get the default shell for the current platform
+ */
+function getDefaultShell(): string {
+	const shellEnv = process.env.SHELL;
+	if (shellEnv) {
+		return shellEnv;
+	}
+	switch (platform()) {
+		case 'win32':
+			return process.env.COMSPEC || 'cmd.exe';
+		case 'darwin':
+			return '/bin/zsh';
+		default:
+			return '/bin/bash';
+	}
+}
+
+/**
+ * Get a human-readable OS name
+ */
+function getOSName(): string {
+	const plat = platform();
+	switch (plat) {
+		case 'darwin':
+			return 'macOS';
+		case 'win32':
+			return 'Windows';
+		case 'linux':
+			return 'Linux';
+		default:
+			return plat;
+	}
+}
+
+/**
+ * Generate system information string
+ */
+function generateSystemInfo(): string {
+	const now = new Date();
+	const dateStr = now.toISOString().split('T')[0]; // YYYY-MM-DD
+	const timeStr = now.toTimeString().split(' ')[0]; // HH:MM:SS
+
+	return `Operating System: ${getOSName()}
+OS Version: ${release()}
+Platform: ${platform()}
+Default Shell: ${getDefaultShell()}
+Home Directory: ${homedir()}
+Current Working Directory: ${process.cwd()}
+Current Date: ${dateStr}
+Current Time: ${timeStr}`;
+}
+
+/**
+ * Inject system information into the prompt template
+ */
+function injectSystemInfo(prompt: string): string {
+	const systemInfo = generateSystemInfo();
+
+	return prompt.replace(
+		/<!-- DYNAMIC_SYSTEM_INFO_START -->[\s\S]*?<!-- DYNAMIC_SYSTEM_INFO_END -->/,
+		systemInfo,
+	);
+}
+
+/**
+ * Process the main prompt template by injecting system info
+ */
+export function processPromptTemplate(): string {
+	let systemPrompt = 'You are a helpful AI assistant.'; // fallback
+
+	// Load base prompt
+	if (existsSync(promptPath)) {
+		try {
+			systemPrompt = readFileSync(promptPath, 'utf-8');
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			const logger = getLogger();
+			logger.warn(
+				`Failed to load system prompt from ${promptPath}: ${errorMessage}`,
+			);
+		}
+	}
+
+	// Inject system information
+	systemPrompt = injectSystemInfo(systemPrompt);
+
+	// Check for AGENTS.md in current working directory and append it
+	const agentsPath = join(process.cwd(), 'AGENTS.md');
+	if (existsSync(agentsPath)) {
+		try {
+			const agentsContent = readFileSync(agentsPath, 'utf-8');
+			systemPrompt += `\n\nAdditional Context...\n\n${agentsContent}`;
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			const logger = getLogger();
+			logger.warn(
+				`Failed to load AGENTS.md from ${agentsPath}: ${errorMessage}`,
+			);
+		}
+	}
+
+	return systemPrompt;
+}
+
+/**
+ * Assemble the final prompt by replacing all placeholders with their full content
+ * This function is called before sending the prompt to the AI
+ */
+export function assemblePrompt(inputState: InputState): string {
+	let assembledPrompt = inputState.displayValue;
+
+	// Replace each placeholder with its full content
+	Object.entries(inputState.placeholderContent).forEach(
+		([placeholderId, placeholderContent]) => {
+			// Each placeholder type can have its own replacement logic
+			let replacementContent = placeholderContent.content || '';
+
+			// Type-specific content assembly (extensible for future types)
+			switch (placeholderContent.type) {
+				case PlaceholderType.PASTE: {
+					// For paste, use content directly
+					replacementContent = placeholderContent.content;
+					break;
+				}
+				case PlaceholderType.FILE: {
+					// Format file content with header for LLM context
+					const fileName =
+						placeholderContent.filePath.split('/').pop() ||
+						placeholderContent.filePath;
+					const header = `=== File: ${fileName} ===`;
+					const footer = '='.repeat(header.length);
+					replacementContent = `${header}\n${placeholderContent.content}\n${footer}`;
+					break;
+				}
+				default: {
+					// TypeScript will ensure this is unreachable with proper enum usage
+					// Exhaustiveness check to ensure all enum cases are handled
+					placeholderContent satisfies never;
+					// Fallback for safety, though this should never be reached
+					replacementContent = '';
+					break;
+				}
+			}
+
+			// Use the displayText to find and replace the placeholder
+			const displayText = placeholderContent.displayText;
+			if (displayText) {
+				assembledPrompt = assembledPrompt.replace(
+					displayText,
+					replacementContent,
+				);
+			} else {
+				// Fallback for legacy paste format
+				const placeholderPattern = `\\[Paste #${placeholderId}: \\d+ chars\\]`;
+				const regex = new RegExp(placeholderPattern, 'g');
+				assembledPrompt = assembledPrompt.replace(regex, replacementContent);
+			}
+		},
+	);
+
+	return assembledPrompt;
+}

package/source/utils/tool-args-parser.spec.ts

@@ -0,0 +1,136 @@
+import test from 'ava';
+import {parseToolArguments} from './tool-args-parser';
+
+console.log(`\ntool-args-parser.spec.ts`);
+
+// Tests for lenient mode (default, strict=false)
+test('parseToolArguments - parses valid JSON string in lenient mode', t => {
+	const input = '{"path": "/test", "count": 42}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {path: '/test', count: 42});
+});
+
+test('parseToolArguments - returns object as-is in lenient mode', t => {
+	const input = {path: '/test', count: 42};
+	const result = parseToolArguments(input);
+	t.deepEqual(result, input);
+});
+
+test('parseToolArguments - returns unparsed string on parse failure in lenient mode', t => {
+	const input = '{invalid json}';
+	const result = parseToolArguments<unknown>(input);
+	t.is(result, input); // Should return the string as-is
+});
+
+test('parseToolArguments - handles empty object string in lenient mode', t => {
+	const input = '{}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {});
+});
+
+test('parseToolArguments - handles array JSON in lenient mode', t => {
+	const input = '[1, 2, 3]';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, [1, 2, 3]);
+});
+
+test('parseToolArguments - handles null in lenient mode', t => {
+	const result = parseToolArguments<unknown>(null);
+	t.is(result, null);
+});
+
+test('parseToolArguments - handles undefined in lenient mode', t => {
+	const result = parseToolArguments<unknown>(undefined);
+	t.is(result, undefined);
+});
+
+test('parseToolArguments - handles number in lenient mode', t => {
+	const result = parseToolArguments<unknown>(42);
+	t.is(result, 42);
+});
+
+// Tests for strict mode (strict=true)
+test('parseToolArguments - parses valid JSON string in strict mode', t => {
+	const input = '{"path": "/test", "count": 42}';
+	const result = parseToolArguments(input, {strict: true});
+	t.deepEqual(result, {path: '/test', count: 42});
+});
+
+test('parseToolArguments - returns object as-is in strict mode', t => {
+	const input = {path: '/test', count: 42};
+	const result = parseToolArguments(input, {strict: true});
+	t.deepEqual(result, input);
+});
+
+test('parseToolArguments - throws on parse failure in strict mode', t => {
+	const input = '{invalid json}';
+	const error = t.throws(() => {
+		parseToolArguments(input, {strict: true});
+	});
+	t.true(error?.message.includes('Error: Invalid tool arguments'));
+});
+
+test('parseToolArguments - throws on malformed JSON in strict mode', t => {
+	const input = '{"unclosed": ';
+	const error = t.throws(() => {
+		parseToolArguments(input, {strict: true});
+	});
+	t.true(error?.message.includes('Error: Invalid tool arguments'));
+});
+
+test('parseToolArguments - handles empty object string in strict mode', t => {
+	const input = '{}';
+	const result = parseToolArguments(input, {strict: true});
+	t.deepEqual(result, {});
+});
+
+// Tests for type parameter
+test('parseToolArguments - respects type parameter', t => {
+	interface TestType {
+		path: string;
+		count: number;
+	}
+	const input = '{"path": "/test", "count": 42}';
+	const result = parseToolArguments<TestType>(input);
+	t.deepEqual(result, {path: '/test', count: 42});
+});
+
+// Edge cases
+test('parseToolArguments - handles nested JSON', t => {
+	const input = '{"outer": {"inner": {"value": 123}}}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {outer: {inner: {value: 123}}});
+});
+
+test('parseToolArguments - handles JSON with special characters', t => {
+	const input = '{"message": "Hello \\"world\\"", "newline": "test\\nline"}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {message: 'Hello "world"', newline: 'test\nline'});
+});
+
+test('parseToolArguments - preserves boolean values', t => {
+	const input = '{"enabled": true, "disabled": false}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {enabled: true, disabled: false});
+});
+
+test('parseToolArguments - preserves null values in JSON', t => {
+	const input = '{"value": null}';
+	const result = parseToolArguments(input);
+	t.deepEqual(result, {value: null});
+});
+
+// Comparison between strict and lenient modes
+test('parseToolArguments - lenient vs strict behavior on invalid JSON', t => {
+	const invalidJson = '{broken}';
+
+	// Lenient mode: returns unparsed string
+	const lenientResult = parseToolArguments<unknown>(invalidJson);
+	t.is(lenientResult, invalidJson);
+
+	// Strict mode: throws error
+	const error = t.throws(() => {
+		parseToolArguments(invalidJson, {strict: true});
+	});
+	t.true(error?.message.includes('Error: Invalid tool arguments'));
+});