@gguf/coder 0.3.1 → 0.3.2

package/source/utils/paste-utils.ts

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

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

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

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

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

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