Feat limit search (#27)

* feat(search): restrict search results to top 10 and those within 10 of the top score (remove less relevant items)

* chore(release): version bump

* feat(searchIndex): add tests for search limit functions

Author: walmsles

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-dna/powertools-mcp",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Powertools for AWS Lambda Documentation MCP Server",
   "main": "dist/bundle.js",
   "bin": {
@@ -32,7 +32,8 @@
     "test:ci": "jest --ci",
     "lint:fix": "eslint --fix --config eslint.config.mjs",
     "postversion": "pnpm build",
-    "release": "semantic-release"
+    "release": "semantic-release",
+    "mcp:local": "pnpm build && npx -y @modelcontextprotocol/inspector node dist/bundle.js"
   },
   "keywords": [
     "aws",

src/index.ts

@@ -30,7 +30,7 @@ const fetchDocSchema = z.object({
 const server = new Server(
   {
     name: "powertools-mcp-server",
-    version: "0.1.0",
+    version: "0.6.0",
   },
   {
     capabilities: {

src/searchIndex.spec.ts

@@ -357,6 +357,66 @@ describe('[Search-Index] When testing URL construction', () => {
   });
 });
 
+describe('[Search-Index] When limiting search results', () => {
+  it('should limit results to 10 items by default', async () => {
+    const factory = new SearchIndexFactory();
+    const index = await factory.getIndex('python');
+    
+    if (!index?.index || !index?.documents) {
+      throw new Error('Python index not properly loaded');
+    }
+    
+    // Mock the lunr search to return more than 10 results
+    const originalSearch = index.index.search;
+    index.index.search = jest.fn().mockImplementation(() => {
+      // Generate 20 mock results
+      return Array.from({ length: 20 }, (_, i) => ({
+        ref: `doc${i}.html`,
+        score: 100 - i, // Decreasing scores
+        matchData: {}
+      }));
+    });
+    
+    // Perform the search
+    const results = searchDocuments(index.index, index.documents, 'common term');
+    
+    // Verify results are limited to 10
+    expect(results.length).toBe(10);
+    
+    // Restore original search function
+    index.index.search = originalSearch;
+  });
+  
+  it('should allow custom limit values', async () => {
+    const factory = new SearchIndexFactory();
+    const index = await factory.getIndex('python');
+    
+    if (!index?.index || !index?.documents) {
+      throw new Error('Python index not properly loaded');
+    }
+    
+    // Mock the lunr search to return more than 5 results
+    const originalSearch = index.index.search;
+    index.index.search = jest.fn().mockImplementation(() => {
+      // Generate 20 mock results
+      return Array.from({ length: 20 }, (_, i) => ({
+        ref: `doc${i}.html`,
+        score: 100 - i, // Decreasing scores
+        matchData: {}
+      }));
+    });
+    
+    // Perform the search with custom limit of 5
+    const results = searchDocuments(index.index, index.documents, 'common term', 5);
+    
+    // Verify results are limited to 5
+    expect(results.length).toBe(5);
+    
+    // Restore original search function
+    index.index.search = originalSearch;
+  });
+});
+
 // Add a final summary after all tests
 afterAll(() => {
   console.log('\n===== FINAL TEST SUMMARY =====');

src/searchIndex.ts

@@ -172,15 +172,40 @@ export class SearchIndexFactory {
  * @param index The lunr index to search
  * @param documents The document map for retrieving full documents
  * @param query The search query
- * @returns Array of search results with scores
+ * @param limit Maximum number of results to return (default: 10)
+ * @param scoreThreshold Score threshold below max score (default: 10)
+ * @returns Array of search results with scores, filtered by relevance and limited to the top results
  */
-export function searchDocuments(index: lunr.Index, documents: Map<string, any>, query: string) {
+export function searchDocuments(
+    index: lunr.Index, 
+    documents: Map<string, any>, 
+    query: string, 
+    limit: number = 10,
+    scoreThreshold: number = 10
+) {
     try {
         // Perform the search
         const results = index.search(query);
 
+        if (results.length === 0) {
+            return [];
+        }
+        
+        // Find the maximum score
+        const maxScore = results[0].score;
+        
+        // Filter results to only include those within the threshold of the max score
+        const filteredResults = results.filter(result => {
+            return (maxScore - result.score) <= scoreThreshold;
+        });
+        
+        // Apply limit if there are still too many results
+        const limitedResults = filteredResults.length > limit 
+            ? filteredResults.slice(0, limit) 
+            : filteredResults;
+        
         // Enhance results with document data
-        return results.map(result => {
+        return limitedResults.map(result => {
             const doc = documents.get(result.ref);
             return {
                 ref: result.ref,