Adds autocomplete for graph search

Author: eamodio

src/system/__tests__/fuzzy.test.ts

@@ -0,0 +1,106 @@
+import * as assert from 'assert';
+import { fuzzyFilter, fuzzyMatch } from '../fuzzy';
+
+suite('fuzzyMatch', () => {
+	test('should match exact strings', () => {
+		const result = fuzzyMatch('message:', 'message:');
+		assert.strictEqual(result.matches, true);
+		assert.strictEqual(result.score, 1);
+	});
+
+	test('should match prefix strings with high score', () => {
+		const result = fuzzyMatch('mes', 'message:');
+		assert.strictEqual(result.matches, true);
+		assert.ok(result.score > 0.9);
+	});
+
+	test('should match non-consecutive characters', () => {
+		const result = fuzzyMatch('msg', 'message:');
+		assert.strictEqual(result.matches, true);
+		assert.ok(result.score > 0);
+		assert.ok(result.score < 0.9); // Lower score than prefix match
+	});
+
+	test('should not match when pattern characters are missing', () => {
+		const result = fuzzyMatch('xyz', 'message:');
+		assert.strictEqual(result.matches, false);
+		assert.strictEqual(result.score, 0);
+	});
+
+	test('should be case-insensitive by default', () => {
+		const result = fuzzyMatch('MES', 'message:');
+		assert.strictEqual(result.matches, true);
+		assert.ok(result.score > 0.9);
+	});
+
+	test('should handle empty pattern', () => {
+		const result = fuzzyMatch('', 'message:');
+		assert.strictEqual(result.matches, true);
+		assert.strictEqual(result.score, 1);
+	});
+
+	test('should handle empty target', () => {
+		const result = fuzzyMatch('mes', '');
+		assert.strictEqual(result.matches, false);
+		assert.strictEqual(result.score, 0);
+	});
+
+	test('should score consecutive matches higher', () => {
+		const consecutive = fuzzyMatch('mes', 'message:');
+		const nonConsecutive = fuzzyMatch('msg', 'message:');
+		assert.ok(consecutive.score > nonConsecutive.score);
+	});
+
+	test('should match short-form operators', () => {
+		const result = fuzzyMatch('@', '@:');
+		assert.strictEqual(result.matches, true);
+		assert.ok(result.score > 0.9);
+	});
+
+	test('should match partial operator names', () => {
+		const result = fuzzyMatch('aut', 'author:');
+		assert.strictEqual(result.matches, true);
+		assert.ok(result.score > 0.9);
+	});
+});
+
+suite('fuzzyFilter', () => {
+	const operators = [
+		{ name: 'message:', desc: 'Search messages' },
+		{ name: 'author:', desc: 'Search authors' },
+		{ name: 'commit:', desc: 'Search commits' },
+		{ name: 'file:', desc: 'Search files' },
+	];
+
+	test('should filter and sort by score', () => {
+		const results = fuzzyFilter('mes', operators, op => op.name);
+		assert.ok(results.length > 0);
+		assert.strictEqual(results[0].item.name, 'message:');
+	});
+
+	test('should return all items when pattern is empty', () => {
+		const results = fuzzyFilter('', operators, op => op.name);
+		assert.strictEqual(results.length, operators.length);
+	});
+
+	test('should filter out non-matching items', () => {
+		const results = fuzzyFilter('xyz', operators, op => op.name);
+		assert.strictEqual(results.length, 0);
+	});
+
+	test('should sort by match quality', () => {
+		const results = fuzzyFilter('a', operators, op => op.name);
+		assert.ok(results.length > 1);
+		// 'author:' should score higher than 'message:' for pattern 'a'
+		assert.strictEqual(results[0].item.name, 'author:');
+	});
+
+	test('should handle multiple matches', () => {
+		const results = fuzzyFilter('m', operators, op => op.name);
+		assert.ok(results.length > 1);
+		// Both 'message:' and 'commit:' contain 'm'
+		const names = results.map(r => r.item.name);
+		assert.ok(names.includes('message:'));
+		assert.ok(names.includes('commit:'));
+	});
+});

src/system/fuzzy.ts

@@ -0,0 +1,188 @@
+/**
+ * Result of a fuzzy match operation
+ */
+export interface FuzzyMatchResult {
+	/** Whether the pattern matches the target */
+	matches: boolean;
+	/** Score of the match (higher is better, 0-1 range) */
+	score: number;
+	/** Indices of matched characters in the target string */
+	matchedIndices: number[];
+}
+
+/**
+ * Options for fuzzy matching
+ */
+export interface FuzzyMatchOptions {
+	/** Whether to perform case-sensitive matching (default: false) */
+	caseSensitive?: boolean;
+	/** Bonus for consecutive character matches (default: 0.15) */
+	consecutiveBonus?: number;
+	/** Bonus for matches at the start of the string (default: 0.2) */
+	prefixBonus?: number;
+	/** Penalty for each unmatched character (default: 0.05) */
+	unmatchedPenalty?: number;
+}
+
+const defaultOptions: Required<FuzzyMatchOptions> = {
+	caseSensitive: false,
+	consecutiveBonus: 0.15,
+	prefixBonus: 0.2,
+	unmatchedPenalty: 0.05,
+};
+
+/**
+ * Performs fuzzy matching of a pattern against a target string with scoring.
+ *
+ * The algorithm:
+ * 1. Checks if all characters in the pattern exist in the target (in order)
+ * 2. Calculates a score based on:
+ *    - Exact prefix matches (highest priority)
+ *    - Consecutive character matches
+ *    - Position of matches (earlier is better)
+ *    - Unmatched characters (penalty)
+ *
+ * @param pattern The search pattern
+ * @param target The string to match against
+ * @param options Matching options
+ * @returns Match result with score and matched indices
+ *
+ * @example
+ * fuzzyMatch('mes', 'message:') // { matches: true, score: 0.95, matchedIndices: [0, 1, 2] }
+ * fuzzyMatch('aut', 'author:')  // { matches: true, score: 0.93, matchedIndices: [0, 1, 2] }
+ * fuzzyMatch('msg', 'message:') // { matches: true, score: 0.65, matchedIndices: [0, 2, 3] }
+ */
+export function fuzzyMatch(pattern: string, target: string, options?: FuzzyMatchOptions): FuzzyMatchResult {
+	const opts = { ...defaultOptions, ...options };
+
+	if (!pattern) {
+		return { matches: true, score: 1, matchedIndices: [] };
+	}
+
+	if (!target) {
+		return { matches: false, score: 0, matchedIndices: [] };
+	}
+
+	const patternStr = opts.caseSensitive ? pattern : pattern.toLowerCase();
+	const targetStr = opts.caseSensitive ? target : target.toLowerCase();
+
+	// Check for exact match first
+	if (patternStr === targetStr) {
+		return {
+			matches: true,
+			score: 1,
+			matchedIndices: Array.from({ length: target.length }, (_, i) => i),
+		};
+	}
+
+	// Check if pattern is a prefix of target
+	if (targetStr.startsWith(patternStr)) {
+		return {
+			matches: true,
+			score: 0.9 + (patternStr.length / targetStr.length) * 0.1,
+			matchedIndices: Array.from({ length: pattern.length }, (_, i) => i),
+		};
+	}
+
+	// Perform fuzzy matching
+	const matchedIndices: number[] = [];
+	let patternIdx = 0;
+	let targetIdx = 0;
+	let consecutiveMatches = 0;
+	let score = 0;
+
+	while (patternIdx < patternStr.length && targetIdx < targetStr.length) {
+		if (patternStr[patternIdx] === targetStr[targetIdx]) {
+			matchedIndices.push(targetIdx);
+
+			// Base score for each match
+			score += 1;
+
+			// Bonus for consecutive matches
+			if (
+				matchedIndices.length > 1 &&
+				matchedIndices[matchedIndices.length - 1] === matchedIndices[matchedIndices.length - 2] + 1
+			) {
+				consecutiveMatches++;
+				score += opts.consecutiveBonus * consecutiveMatches;
+			} else {
+				consecutiveMatches = 0;
+			}
+
+			// Bonus for matches at the start
+			if (targetIdx === patternIdx) {
+				score += opts.prefixBonus;
+			}
+
+			patternIdx++;
+		}
+		targetIdx++;
+	}
+
+	// Check if all pattern characters were matched
+	if (patternIdx < patternStr.length) {
+		return { matches: false, score: 0, matchedIndices: [] };
+	}
+
+	// Apply penalty for unmatched characters
+	const unmatchedCount = targetStr.length - matchedIndices.length;
+	score -= unmatchedCount * opts.unmatchedPenalty;
+
+	// Normalize score to 0-1 range
+	// Maximum possible score is pattern.length + bonuses
+	const maxScore = patternStr.length * (1 + opts.consecutiveBonus + opts.prefixBonus);
+	const normalizedScore = Math.max(0, Math.min(1, score / maxScore));
+
+	return {
+		matches: true,
+		score: normalizedScore,
+		matchedIndices: matchedIndices,
+	};
+}
+
+/**
+ * Filters and sorts an array of items by fuzzy matching against a pattern.
+ *
+ * @param pattern The search pattern
+ * @param items The items to filter and sort
+ * @param getText Function to extract searchable text from each item
+ * @param options Matching options
+ * @returns Filtered and sorted items with their match results
+ *
+ * @example
+ * const operators = [
+ *   { name: 'message:', desc: 'Search messages' },
+ *   { name: 'author:', desc: 'Search authors' }
+ * ];
+ * fuzzyFilter('mes', operators, op => op.name)
+ * // Returns [{ item: { name: 'message:', ... }, match: { score: 0.95, ... } }]
+ */
+export function fuzzyFilter<T>(
+	pattern: string,
+	items: T[],
+	getText: (item: T) => string,
+	options?: FuzzyMatchOptions,
+): Array<{ item: T; match: FuzzyMatchResult }> {
+	if (!pattern) {
+		return items.map(item => ({
+			item: item,
+			match: { matches: true, score: 1, matchedIndices: [] },
+		}));
+	}
+
+	const results: Array<{ item: T; match: FuzzyMatchResult }> = [];
+
+	for (const item of items) {
+		const text = getText(item);
+		const match = fuzzyMatch(pattern, text, options);
+
+		if (match.matches) {
+			results.push({ item: item, match: match });
+		}
+	}
+
+	// Sort by score (descending)
+	results.sort((a, b) => b.match.score - a.match.score);
+
+	return results;
+}