@gguf/coder 0.2.9 → 0.3.1

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

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import test from 'ava';
+import {
+	isValidFilePath,
+	parseFileMentions,
+	parseLineRange,
+	resolveFilePath,
+} from './file-mention-parser.js';
+
+console.log(`\nfile-mention-parser.spec.ts`);
+
+// Test parseFileMentions()
+test('parses single file mention', t => {
+	const result = parseFileMentions('Check @app.tsx');
+	t.is(result.length, 1);
+	t.is(result[0].filePath, 'app.tsx');
+	t.is(result[0].rawText, '@app.tsx');
+	t.is(result[0].startIndex, 6);
+	t.is(result[0].endIndex, 14);
+	t.is(result[0].lineRange, undefined);
+});
+
+test('parses file with path', t => {
+	const result = parseFileMentions('Check @src/components/Button.tsx');
+	t.is(result.length, 1);
+	t.is(result[0].filePath, 'src/components/Button.tsx');
+	t.is(result[0].rawText, '@src/components/Button.tsx');
+});
+
+test('parses file with single line number', t => {
+	const result = parseFileMentions('@app.tsx:10');
+	t.is(result.length, 1);
+	t.is(result[0].filePath, 'app.tsx');
+	t.deepEqual(result[0].lineRange, {start: 10, end: undefined});
+});
+
+test('parses file with line range', t => {
+	const result = parseFileMentions('@app.tsx:10-20');
+	t.is(result.length, 1);
+	t.is(result[0].filePath, 'app.tsx');
+	t.deepEqual(result[0].lineRange, {start: 10, end: 20});
+});
+
+test('parses multiple file mentions', t => {
+	const result = parseFileMentions('Compare @a.ts and @b.ts');
+	t.is(result.length, 2);
+	t.is(result[0].filePath, 'a.ts');
+	t.is(result[1].filePath, 'b.ts');
+});
+
+test('parses file mentions with different line ranges', t => {
+	const result = parseFileMentions('Check @app.tsx:1-5 and @utils.ts:10-15');
+	t.is(result.length, 2);
+	t.deepEqual(result[0].lineRange, {start: 1, end: 5});
+	t.deepEqual(result[1].lineRange, {start: 10, end: 15});
+});
+
+test('handles text without file mentions', t => {
+	const result = parseFileMentions('This is just regular text');
+	t.is(result.length, 0);
+});
+
+test('ignores @ symbols in email addresses', t => {
+	const result = parseFileMentions('Email: user@example.com');
+	// Should not match email addresses (they have spaces or are at word boundaries)
+	// However, this might match "example.com" - let's verify behavior
+	t.true(result.length <= 1);
+	if (result.length === 1) {
+		t.is(result[0].filePath, 'example.com');
+	}
+});
+
+test('rejects invalid line ranges in file mentions', t => {
+	// Line range where end < start should not have lineRange
+	const result = parseFileMentions('@app.tsx:20-10');
+	t.is(result.length, 1);
+	t.is(result[0].lineRange, undefined);
+});
+
+test('rejects zero or negative line numbers', t => {
+	const result1 = parseFileMentions('@app.tsx:0');
+	t.is(result1[0].lineRange, undefined);
+
+	const result2 = parseFileMentions('@app.tsx:0-10');
+	t.is(result2[0].lineRange, undefined);
+});
+
+test('handles complex file paths', t => {
+	const result = parseFileMentions(
+		'@src/components/ui/Button/index.tsx:100-200',
+	);
+	t.is(result.length, 1);
+	t.is(result[0].filePath, 'src/components/ui/Button/index.tsx');
+	t.deepEqual(result[0].lineRange, {start: 100, end: 200});
+});
+
+// Test isValidFilePath()
+test('accepts valid relative paths', t => {
+	t.true(isValidFilePath('app.tsx'));
+	t.true(isValidFilePath('src/app.tsx'));
+	t.true(isValidFilePath('src/components/Button.tsx'));
+});
+
+test('rejects directory traversal attempts', t => {
+	t.false(isValidFilePath('../../etc/passwd'));
+	t.false(isValidFilePath('../../../secret.txt'));
+	t.false(isValidFilePath('src/../../../etc/passwd'));
+});
+
+test('rejects absolute paths', t => {
+	t.false(isValidFilePath('/etc/passwd'));
+	t.false(isValidFilePath('/home/user/file.txt'));
+	t.false(isValidFilePath('C:\\Windows\\System32\\file.txt'));
+});
+
+test('rejects empty or whitespace paths', t => {
+	t.false(isValidFilePath(''));
+	t.false(isValidFilePath('   '));
+});
+
+test('rejects paths with null bytes', t => {
+	t.false(isValidFilePath('file.txt\0'));
+	t.false(isValidFilePath('file\0.txt'));
+});
+
+test('rejects paths starting with slashes', t => {
+	t.false(isValidFilePath('/file.txt'));
+	t.false(isValidFilePath('\\file.txt'));
+});
+
+// Test resolveFilePath()
+test('resolves relative path to absolute', t => {
+	const cwd = '/home/user/project';
+	const resolved = resolveFilePath('src/app.tsx', cwd);
+	t.is(resolved, path.join(cwd, 'src/app.tsx'));
+});
+
+test('throws on invalid file paths', t => {
+	const cwd = '/home/user/project';
+	t.throws(() => resolveFilePath('../../etc/passwd', cwd), {
+		message: /Invalid file path/,
+	});
+});
+
+test('throws when resolved path escapes project directory', t => {
+	const cwd = '/home/user/project';
+	// Even if validation passes, resolve should catch escaping
+	t.throws(() => resolveFilePath('/etc/passwd', cwd), {
+		message: /Invalid file path/,
+	});
+});
+
+test('resolves nested paths correctly', t => {
+	const cwd = '/home/user/project';
+	const resolved = resolveFilePath('src/components/ui/Button.tsx', cwd);
+	t.is(resolved, path.join(cwd, 'src/components/ui/Button.tsx'));
+});
+
+// Test parseLineRange()
+test('parses single line number', t => {
+	const result = parseLineRange('10');
+	t.deepEqual(result, {start: 10, end: undefined});
+});
+
+test('parses line range', t => {
+	const result = parseLineRange('10-20');
+	t.deepEqual(result, {start: 10, end: 20});
+});
+
+test('rejects invalid line ranges', t => {
+	t.is(parseLineRange('20-10'), null); // end < start
+	t.is(parseLineRange('0'), null); // zero
+	t.is(parseLineRange('-5'), null); // negative
+	t.is(parseLineRange('abc'), null); // non-numeric
+	t.is(parseLineRange(''), null); // empty
+});
+
+test('rejects malformed ranges', t => {
+	t.is(parseLineRange('10-20-30'), null); // too many parts
+	t.is(parseLineRange('10-'), null); // missing end
+	t.is(parseLineRange('-20'), null); // missing start
+});

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

@@ -0,0 +1,170 @@
+import path from 'node:path';
+
+/**
+ * Represents a parsed file mention from user input
+ * Supports:
+ * - @filename.ts
+ * - @src/components/Button.tsx
+ * - @file.ts:10-20 (line ranges)
+ * - @file.ts:10 (single line)
+ */
+interface FileMention {
+	rawText: string; // "@src/app.tsx:10-20"
+	filePath: string; // "src/app.tsx"
+	lineRange?: {
+		start: number;
+		end?: number; // undefined for single line
+	};
+	startIndex: number; // Position in input string
+	endIndex: number;
+}
+
+/**
+ * Regex pattern to match @file mentions
+ * Matches:
+ * - @file.ts
+ * - @src/path/to/file.tsx
+ * - @file.ts:10
+ * - @file.ts:10-20
+ */
+const FILE_MENTION_REGEX = /@([^\s:]+)(?::(\d+)(?:-(\d+))?)?/g;
+
+/**
+ * Parse all @mentions from user input
+ */
+export function parseFileMentions(input: string): FileMention[] {
+	const mentions: FileMention[] = [];
+	let match: RegExpExecArray | null;
+
+	// Reset regex state
+	FILE_MENTION_REGEX.lastIndex = 0;
+
+	while ((match = FILE_MENTION_REGEX.exec(input)) !== null) {
+		const rawText = match[0]; // Full match: "@src/app.tsx:10-20"
+		const filePath = match[1]; // Captured group 1: "src/app.tsx"
+		const lineStart = match[2]; // Captured group 2: "10"
+		const lineEnd = match[3]; // Captured group 3: "20"
+
+		// Skip if the file path is empty or invalid
+		if (!filePath || !isValidFilePath(filePath)) {
+			continue;
+		}
+
+		const mention: FileMention = {
+			rawText,
+			filePath,
+			startIndex: match.index,
+			endIndex: match.index + rawText.length,
+		};
+
+		// Parse line range if present
+		if (lineStart) {
+			const start = parseInt(lineStart, 10);
+			const end = lineEnd ? parseInt(lineEnd, 10) : undefined;
+
+			// Validate line numbers
+			if (start > 0 && (!end || end >= start)) {
+				mention.lineRange = {start, end};
+			}
+		}
+
+		mentions.push(mention);
+	}
+
+	return mentions;
+}
+
+/**
+ * Validate file path to prevent directory traversal attacks
+ * and ensure it's within the project directory
+ */
+export function isValidFilePath(filePath: string): boolean {
+	// Reject empty paths
+	if (!filePath || filePath.trim().length === 0) {
+		return false;
+	}
+
+	// Reject paths that try to escape parent directories
+	if (filePath.includes('..')) {
+		return false;
+	}
+
+	// Reject absolute paths (outside project)
+	if (path.isAbsolute(filePath)) {
+		return false;
+	}
+
+	// Reject Windows absolute paths (C:\, D:\, etc.) even on Unix systems
+	if (/^[A-Za-z]:[/\\]/.test(filePath)) {
+		return false;
+	}
+
+	// Reject paths with null bytes (security)
+	if (filePath.includes('\0')) {
+		return false;
+	}
+
+	// Reject paths that start with special characters that could be problematic
+	if (filePath.startsWith('/') || filePath.startsWith('\\')) {
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Resolve a relative file path to an absolute path within the project
+ */
+export function resolveFilePath(filePath: string, cwd: string): string {
+	// Validate first
+	if (!isValidFilePath(filePath)) {
+		throw new Error(`Invalid file path: ${filePath}`);
+	}
+
+	// Resolve to absolute path
+	const absolutePath = path.resolve(cwd, filePath);
+
+	// Ensure the resolved path is still within the project directory
+	const normalizedCwd = path.resolve(cwd);
+	if (!absolutePath.startsWith(normalizedCwd)) {
+		throw new Error(
+			`File path escapes project directory: ${filePath} -> ${absolutePath}`,
+		);
+	}
+
+	return absolutePath;
+}
+
+/**
+ * Parse line range from a string like "10-20" or "10"
+ */
+export function parseLineRange(
+	rangeStr: string,
+): {start: number; end?: number} | null {
+	if (!rangeStr) {
+		return null;
+	}
+
+	const parts = rangeStr.split('-');
+
+	if (parts.length === 1) {
+		// Single line: "10"
+		const line = parseInt(parts[0], 10);
+		if (isNaN(line) || line <= 0) {
+			return null;
+		}
+		return {start: line, end: undefined};
+	} else if (parts.length === 2) {
+		// Range: "10-20"
+		const start = parseInt(parts[0], 10);
+		const end = parseInt(parts[1], 10);
+
+		if (isNaN(start) || isNaN(end) || start <= 0 || end < start) {
+			return null;
+		}
+
+		return {start, end};
+	}
+
+	return null;
+}

package/source/utils/fuzzy-matching.spec.ts

@@ -0,0 +1,149 @@
+import test from 'ava';
+import {fuzzyScore, fuzzyScoreFilePath} from './fuzzy-matching';
+
+console.log(`\nfuzzy-matching.spec.ts`);
+
+// Tests for fuzzyScore (general text matching)
+test('fuzzyScore - exact match returns highest score', t => {
+	t.is(fuzzyScore('help', 'help'), 1000);
+	t.is(fuzzyScore('status', 'status'), 1000);
+});
+
+test('fuzzyScore - case insensitive matching', t => {
+	t.is(fuzzyScore('Help', 'help'), 1000);
+	t.is(fuzzyScore('STATUS', 'status'), 1000);
+	t.is(fuzzyScore('help', 'HELP'), 1000);
+});
+
+test('fuzzyScore - prefix match', t => {
+	const score = fuzzyScore('help', 'hel');
+	t.true(score > 0);
+	t.true(score >= 800);
+});
+
+test('fuzzyScore - substring match', t => {
+	const score = fuzzyScore('status', 'tat');
+	t.true(score > 0);
+	t.true(score >= 700);
+});
+
+test('fuzzyScore - sequential character match', t => {
+	const score = fuzzyScore('provider', 'pvdr');
+	t.true(score > 0);
+	t.true(score < 700); // Should be lower than substring match
+});
+
+test('fuzzyScore - no match returns 0', t => {
+	t.is(fuzzyScore('help', 'xyz'), 0);
+	t.is(fuzzyScore('status', 'abc'), 0);
+});
+
+test('fuzzyScore - empty query returns 0', t => {
+	t.is(fuzzyScore('help', ''), 0);
+	t.is(fuzzyScore('anything', ''), 0);
+});
+
+test('fuzzyScore - ranks exact match higher than prefix', t => {
+	const exactScore = fuzzyScore('help', 'help');
+	const prefixScore = fuzzyScore('helper', 'help');
+	t.true(exactScore > prefixScore);
+});
+
+test('fuzzyScore - ranks prefix higher than substring', t => {
+	const prefixScore = fuzzyScore('helper', 'help');
+	const substringScore = fuzzyScore('unhelpful', 'help');
+	t.true(prefixScore > substringScore);
+});
+
+test('fuzzyScore - ranks substring higher than fuzzy', t => {
+	const substringScore = fuzzyScore('helper', 'elp');
+	const fuzzyScore1 = fuzzyScore('enable-lp', 'elp');
+	t.true(substringScore > fuzzyScore1);
+});
+
+// Tests for fuzzyScoreFilePath (file path specific matching)
+test('fuzzyScoreFilePath - exact filename match scores high', t => {
+	const score = fuzzyScoreFilePath('src/utils/helper.ts', 'helper.ts');
+	t.true(score >= 900);
+});
+
+test('fuzzyScoreFilePath - filename prefix scores higher than path prefix', t => {
+	const filenameScore = fuzzyScoreFilePath('src/utils/helper.ts', 'help');
+	const pathScore = fuzzyScoreFilePath('helper/src/utils/file.ts', 'help');
+	t.true(filenameScore > pathScore);
+});
+
+test('fuzzyScoreFilePath - filename substring matches correctly', t => {
+	const filenameScore = fuzzyScoreFilePath('src/utils/my-helper.ts', 'help');
+	const pathScore = fuzzyScoreFilePath('helper/src/utils/file.ts', 'help');
+	// Both should have scores, but path prefix might score higher than filename substring
+	t.true(filenameScore > 0);
+	t.true(pathScore > 0);
+});
+
+test('fuzzyScoreFilePath - handles paths with multiple slashes', t => {
+	const score = fuzzyScoreFilePath('a/b/c/d/file.ts', 'file');
+	t.true(score > 0);
+});
+
+test('fuzzyScoreFilePath - case insensitive for paths', t => {
+	const score1 = fuzzyScoreFilePath('src/Utils/Helper.ts', 'helper');
+	const score2 = fuzzyScoreFilePath('src/utils/helper.ts', 'HELPER');
+	t.true(score1 > 0);
+	t.true(score2 > 0);
+});
+
+// Command-specific test scenarios
+test('command matching - /h matches help, status does not', t => {
+	const helpScore = fuzzyScore('help', 'h');
+	const statusScore = fuzzyScore('status', 'h');
+	t.true(helpScore > 0);
+	t.is(statusScore, 0);
+});
+
+test('command matching - /st matches status', t => {
+	const score = fuzzyScore('status', 'st');
+	t.true(score > 0);
+	t.true(score >= 800); // Should be prefix match
+});
+
+test('command matching - /mod matches model', t => {
+	const modelScore = fuzzyScore('model', 'mod');
+	const recommendationsScore = fuzzyScore('recommendations', 'mod');
+
+	t.true(modelScore > 0);
+	// recommendations doesn't contain 'mod' as substring, so it should be 0 or fuzzy match
+	// model should score higher (prefix match)
+	t.true(modelScore > recommendationsScore);
+});
+
+test('command matching - fuzzy matching for /pvd matches provider', t => {
+	const score = fuzzyScore('provider', 'pvd');
+	t.true(score > 0);
+});
+
+test('command matching - /init matches init higher than initialization', t => {
+	const initScore = fuzzyScore('init', 'init');
+	const initializationScore = fuzzyScore('initialization', 'init');
+
+	t.true(initScore > initializationScore);
+});
+
+// Edge cases
+test('fuzzyScore - single character queries work', t => {
+	const score1 = fuzzyScore('help', 'h');
+	const score2 = fuzzyScore('status', 's');
+	t.true(score1 > 0);
+	t.true(score2 > 0);
+});
+
+test('fuzzyScore - longer text with short query', t => {
+	const score = fuzzyScore('very-long-command-name-here', 'vlc');
+	t.true(score > 0);
+});
+
+test('fuzzyScoreFilePath - works with Windows-style paths', t => {
+	// While the function uses /, testing that it handles edge cases
+	const score = fuzzyScoreFilePath('src\\utils\\file.ts', 'file');
+	t.true(score > 0);
+});

package/source/utils/fuzzy-matching.ts

@@ -0,0 +1,146 @@
+/**
+ * Fuzzy match scoring algorithm
+ * Returns a score from 0 to 1000 (higher = better match)
+ *
+ * This can be used for matching file paths, command names, or any other strings.
+ */
+export function fuzzyScore(text: string, query: string): number {
+	if (!query) {
+		return 0;
+	}
+
+	const lowerText = text.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+
+	// Exact match (highest score)
+	if (lowerText === lowerQuery) {
+		return 1000;
+	}
+
+	// Text ends with query
+	if (lowerText.endsWith(lowerQuery)) {
+		return 850;
+	}
+
+	// Text starts with query
+	if (lowerText.startsWith(lowerQuery)) {
+		return 800;
+	}
+
+	// Text contains query as substring
+	if (lowerText.includes(lowerQuery)) {
+		return 700;
+	}
+
+	// Sequential character match (fuzzy)
+	// All query characters appear in order in the text
+	let textIndex = 0;
+	let queryIndex = 0;
+	let lastMatchIndex = -1;
+	let consecutiveMatches = 0;
+
+	while (textIndex < lowerText.length && queryIndex < lowerQuery.length) {
+		if (lowerText[textIndex] === lowerQuery[queryIndex]) {
+			// Bonus for consecutive matches
+			if (textIndex === lastMatchIndex + 1) {
+				consecutiveMatches++;
+			} else {
+				consecutiveMatches = 1;
+			}
+			lastMatchIndex = textIndex;
+			queryIndex++;
+		}
+		textIndex++;
+	}
+
+	// If all query characters matched
+	if (queryIndex === lowerQuery.length) {
+		// Score based on match density and consecutive matches
+		const matchDensity = lowerQuery.length / lowerText.length;
+		const consecutiveBonus = consecutiveMatches * 50;
+		return Math.min(500 + matchDensity * 100 + consecutiveBonus, 699);
+	}
+
+	// No match
+	return 0;
+}
+
+/**
+ * Fuzzy score specifically for file paths
+ * Gives higher priority to filename matches over directory matches
+ */
+export function fuzzyScoreFilePath(filePath: string, query: string): number {
+	if (!query) {
+		return 0;
+	}
+
+	const lowerPath = filePath.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+
+	// Exact match (highest score)
+	if (lowerPath === lowerQuery) {
+		return 1000;
+	}
+
+	// Exact match of filename (without path)
+	const filename = filePath.split('/').pop() || '';
+	if (filename.toLowerCase() === lowerQuery) {
+		return 900;
+	}
+
+	// Path ends with query
+	if (lowerPath.endsWith(lowerQuery)) {
+		return 850;
+	}
+
+	// Filename starts with query
+	if (filename.toLowerCase().startsWith(lowerQuery)) {
+		return 800;
+	}
+
+	// Path starts with query
+	if (lowerPath.startsWith(lowerQuery)) {
+		return 750;
+	}
+
+	// Filename contains query as substring
+	if (filename.toLowerCase().includes(lowerQuery)) {
+		return 700;
+	}
+
+	// Path contains query as substring
+	if (lowerPath.includes(lowerQuery)) {
+		return 600;
+	}
+
+	// Sequential character match (fuzzy)
+	let pathIndex = 0;
+	let queryIndex = 0;
+	let lastMatchIndex = -1;
+	let consecutiveMatches = 0;
+
+	while (pathIndex < lowerPath.length && queryIndex < lowerQuery.length) {
+		if (lowerPath[pathIndex] === lowerQuery[queryIndex]) {
+			// Bonus for consecutive matches
+			if (pathIndex === lastMatchIndex + 1) {
+				consecutiveMatches++;
+			} else {
+				consecutiveMatches = 1;
+			}
+			lastMatchIndex = pathIndex;
+			queryIndex++;
+		}
+		pathIndex++;
+	}
+
+	// If all query characters matched
+	if (queryIndex === lowerQuery.length) {
+		// Score based on match density and consecutive matches
+		const matchDensity = lowerQuery.length / lowerPath.length;
+		const consecutiveBonus = consecutiveMatches * 50;
+		return Math.min(500 + matchDensity * 100 + consecutiveBonus, 599);
+	}
+
+	// No match
+	return 0;
+}