code-auditor-mcp
Version:
TypeScript/JavaScript code quality auditor with MCP server - Analyze code for SOLID principles, DRY violations, security patterns, and more
170 lines • 8.29 kB
JavaScript
import { CodeIndexDB } from './codeIndexDB.js';
import { QueryParser } from './search/QueryParser.js';
async function testMultiStrategySearch() {
const db = new CodeIndexDB('./.code-index/test.db');
const queryParser = new QueryParser();
try {
await db.initialize();
console.log('Database initialized');
// Add some test functions
const testFunctions = [
{
name: 'getUserData',
signature: 'getUserData(userId: string): Promise<User>',
purpose: 'Fetch user information from the database',
context: 'Part of the user management module',
filePath: '/src/services/userService.ts',
language: 'typescript',
startLine: 10,
endLine: 20,
dependencies: ['database', 'logger'],
jsDoc: {
description: 'Retrieves user data from the database by user ID',
params: [{ name: 'userId', type: 'string', description: 'The unique user identifier' }],
returns: { type: 'Promise<User>', description: 'A promise that resolves to user data' }
},
parameters: [
{ name: 'userId', type: 'string', description: 'The unique user identifier' }
],
returnType: 'Promise<User>',
complexity: 5
},
{
name: 'createUser',
signature: 'createUser(data: CreateUserDto): Promise<User>',
purpose: 'Create a new user in the system',
context: 'User registration process',
filePath: '/src/services/userService.ts',
language: 'typescript',
startLine: 25,
endLine: 45,
dependencies: ['database', 'validator', 'bcrypt'],
jsDoc: {
description: 'Creates a new user with validation and password hashing',
params: [{ name: 'data', type: 'CreateUserDto', description: 'User creation data' }],
returns: { type: 'Promise<User>', description: 'The created user object' }
},
parameters: [
{ name: 'data', type: 'CreateUserDto', description: 'User creation data' }
],
returnType: 'Promise<User>',
complexity: 8
},
{
name: 'validateUserInput',
signature: 'validateUserInput(input: any): ValidationResult',
purpose: 'Validate user input data',
context: 'Input validation utilities',
filePath: '/src/utils/validation.ts',
language: 'typescript',
startLine: 5,
endLine: 25,
dependencies: ['joi', 'validator'],
jsDoc: {
description: 'Validates user input against defined schema rules',
params: [{ name: 'input', type: 'any', description: 'Input to validate' }],
returns: { type: 'ValidationResult', description: 'Validation result with errors if any' }
},
parameters: [
{ name: 'input', type: 'any', description: 'Input to validate' }
],
returnType: 'ValidationResult',
complexity: 6
},
{
name: 'logError',
signature: 'logError(error: Error, context?: string): void',
purpose: 'Log application errors with context',
context: 'Error handling and logging',
filePath: '/src/utils/logger.ts',
language: 'typescript',
startLine: 15,
endLine: 20,
dependencies: ['winston', 'sentry'],
jsDoc: {
description: 'Logs errors to console and external monitoring services',
params: [
{ name: 'error', type: 'Error', description: 'The error object' },
{ name: 'context', type: 'string', description: 'Optional context information' }
]
},
parameters: [
{ name: 'error', type: 'Error', description: 'The error object' },
{ name: 'context', type: 'string', description: 'Optional context information' }
],
returnType: 'void',
complexity: 3
}
];
// Register test functions
for (const func of testFunctions) {
await db.registerFunction(func);
}
console.log('Test functions registered');
// Test 1: Multi-word query (should use AND logic)
console.log('\n=== Test 1: Multi-word query "get user" ===');
const parsed1 = queryParser.parse('get user');
const results1 = await db.searchFunctions({ parsedQuery: parsed1 });
console.log(`Query terms: ${parsed1.terms.join(', ')}`);
console.log(`Found ${results1.totalCount} results:`);
results1.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - ${f.purpose}`);
});
// Test 2: Exact phrase matching
console.log('\n=== Test 2: Exact phrase "user data" ===');
const parsed2 = queryParser.parse('"user data"');
const results2 = await db.searchFunctions({ parsedQuery: parsed2 });
console.log(`Phrases: ${parsed2.phrases.join(', ')}`);
console.log(`Found ${results2.totalCount} results:`);
results2.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - ${f.purpose}`);
});
// Test 3: Excluded terms
console.log('\n=== Test 3: Query "user -create" (exclude create) ===');
const parsed3 = queryParser.parse('user -create');
const results3 = await db.searchFunctions({ parsedQuery: parsed3 });
console.log(`Terms: ${parsed3.terms.join(', ')}, Excluded: ${parsed3.excludedTerms.join(', ')}`);
console.log(`Found ${results3.totalCount} results:`);
results3.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - ${f.purpose}`);
});
// Test 4: Synonym expansion
console.log('\n=== Test 4: Query "fetch" (should find get via synonym) ===');
const parsed4 = queryParser.parse('fetch');
const results4 = await db.searchFunctions({ parsedQuery: parsed4 });
console.log(`Expanded terms: ${parsed4.terms.join(', ')}`);
console.log(`Found ${results4.totalCount} results:`);
results4.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - ${f.purpose}`);
});
// Test 5: Complex query with operators
console.log('\n=== Test 5: Complex query "validate lang:typescript complexity:5-10" ===');
const parsed5 = queryParser.parse('validate lang:typescript complexity:5-10');
const results5 = await db.searchFunctions({ parsedQuery: parsed5 });
console.log(`Terms: ${parsed5.terms.join(', ')}`);
console.log(`Filters:`, parsed5.filters);
console.log(`Found ${results5.totalCount} results:`);
results5.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - complexity: ${f.complexity}`);
});
// Test 6: Fuzzy search
console.log('\n=== Test 6: Fuzzy search "usr ~" ===');
const parsed6 = queryParser.parse('usr ~');
const results6 = await db.searchFunctions({ parsedQuery: parsed6 });
console.log(`Terms: ${parsed6.terms.join(', ')}, Fuzzy: ${parsed6.fuzzy}`);
console.log(`Found ${results6.totalCount} results:`);
results6.functions.forEach(f => {
console.log(` - ${f.name} (score: ${f.score}) - ${f.purpose}`);
});
}
catch (error) {
console.error('Test failed:', error);
}
finally {
await db.close();
}
}
// Run tests
testMultiStrategySearch();
//# sourceMappingURL=test-multi-strategy-search.js.map