fix: correct filename match detection in simple search

- Changed condition from match[0] === 0 to match[0] < positionOffset
  to correctly detect all matches within the filename, not just at position 0
- Added comprehensive test suite for searchSimplePost with 12 test cases
  covering filename matches, content matches, edge cases, and position calculations
- Implemented functional prepareSimpleSearch mock for testing

Fixes issue where files like '1 - Master Plan.md' were not found
when searching for 'Master Plan' because the match didn't start at position 0.

Addresses PR feedback:
- Tests now cover off-by-one errors and boundary conditions
- Match detection logic correctly identifies all filename matches
- Position calculations verified through tests

Author: Benjamin Klein

mocks/obsidian.ts

@@ -178,5 +178,24 @@ export class SearchResult {
 export function prepareSimpleSearch(
   query: string
 ): (value: string) => null | SearchResult {
-  return null;
+  return (text: string) => {
+    const matches: [number, number][] = [];
+    const lowerQuery = query.toLowerCase();
+    const lowerText = text.toLowerCase();
+
+    let index = 0;
+    while ((index = lowerText.indexOf(lowerQuery, index)) !== -1) {
+      matches.push([index, index + query.length]);
+      index += query.length;
+    }
+
+    if (matches.length === 0) {
+      return null;
+    }
+
+    const result = new SearchResult();
+    result.matches = matches;
+    result.score = matches.length * -10;
+    return result;
+  };
 }

src/requestHandler.test.ts

@@ -802,4 +802,255 @@ describe("requestHandler", () => {
         .expect(401);
     });
   });
+
+  describe("searchSimplePost", () => {
+    test("match at beginning of filename", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Master Plan";
+      testFile.path = "Master Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Some content here";
+
+      const result = await request(server)
+        .post("/search/simple/?query=Master")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("Master Plan.md");
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(0);
+      expect(result.body[0].matches[0].match.end).toBe(6);
+      expect(result.body[0].matches[0].context).toBe("Master Plan");
+    });
+
+    test("match in middle of filename", async () => {
+      const testFile = new TFile();
+      testFile.basename = "1 - Master Plan";
+      testFile.path = "1 - Master Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Some content here";
+
+      const result = await request(server)
+        .post("/search/simple/?query=Master")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("1 - Master Plan.md");
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(4);
+      expect(result.body[0].matches[0].match.end).toBe(10);
+      expect(result.body[0].matches[0].context).toBe("1 - Master Plan");
+    });
+
+    test("match at end of filename", async () => {
+      const testFile = new TFile();
+      testFile.basename = "My Master Plan";
+      testFile.path = "My Master Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Some content here";
+
+      const result = await request(server)
+        .post("/search/simple/?query=Plan")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("My Master Plan.md");
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(10);
+      expect(result.body[0].matches[0].match.end).toBe(14);
+      expect(result.body[0].matches[0].context).toBe("My Master Plan");
+    });
+
+    test("match in content only", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Random Note";
+      testFile.path = "Random Note.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "This is my master plan for the project.";
+
+      const result = await request(server)
+        .post("/search/simple/?query=master")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("Random Note.md");
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("content");
+      expect(result.body[0].matches[0].match.start).toBe(11);
+      expect(result.body[0].matches[0].match.end).toBe(17);
+    });
+
+    test("match in both filename and content", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Master Plan";
+      testFile.path = "Master Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "The master plan is to complete this project.";
+
+      const result = await request(server)
+        .post("/search/simple/?query=master")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("Master Plan.md");
+      expect(result.body[0].matches).toHaveLength(2);
+
+      // First match should be in filename (case-insensitive)
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(0);
+      expect(result.body[0].matches[0].match.end).toBe(6);
+      expect(result.body[0].matches[0].context).toBe("Master Plan");
+
+      // Second match should be in content
+      expect(result.body[0].matches[1].match.source).toBe("content");
+      expect(result.body[0].matches[1].match.start).toBe(4);
+      expect(result.body[0].matches[1].match.end).toBe(10);
+    });
+
+    test("multiple matches in filename", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Test Test Test";
+      testFile.path = "Test Test Test.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Content without the search term";
+
+      const result = await request(server)
+        .post("/search/simple/?query=Test")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("Test Test Test.md");
+      expect(result.body[0].matches).toHaveLength(3);
+
+      // All matches should be in filename
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(0);
+      expect(result.body[0].matches[0].match.end).toBe(4);
+
+      expect(result.body[0].matches[1].match.source).toBe("filename");
+      expect(result.body[0].matches[1].match.start).toBe(5);
+      expect(result.body[0].matches[1].match.end).toBe(9);
+
+      expect(result.body[0].matches[2].match.source).toBe("filename");
+      expect(result.body[0].matches[2].match.start).toBe(10);
+      expect(result.body[0].matches[2].match.end).toBe(14);
+    });
+
+    test("filename with special characters", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Project (2024) - Master Plan";
+      testFile.path = "Project (2024) - Master Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Project details";
+
+      const result = await request(server)
+        .post("/search/simple/?query=2024")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].filename).toBe("Project (2024) - Master Plan.md");
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(9);
+      expect(result.body[0].matches[0].match.end).toBe(13);
+      expect(result.body[0].matches[0].context).toBe("Project (2024) - Master Plan");
+    });
+
+    test("context length for content matches", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Note";
+      testFile.path = "Note.md";
+
+      const longContent = "A".repeat(200) + "MATCH" + "B".repeat(200);
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = longContent;
+
+      const result = await request(server)
+        .post("/search/simple/?query=MATCH&contextLength=50")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].matches).toHaveLength(1);
+      expect(result.body[0].matches[0].match.source).toBe("content");
+
+      // Context should be approximately 50 chars before + match + 50 chars after
+      const context = result.body[0].matches[0].context;
+      expect(context.length).toBeLessThanOrEqual(105); // 50 + 5 + 50
+      expect(context).toContain("MATCH");
+    });
+
+    test("no matches returns empty array", async () => {
+      const testFile = new TFile();
+      testFile.basename = "Random Note";
+      testFile.path = "Random Note.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "Some content";
+
+      const result = await request(server)
+        .post("/search/simple/?query=NonExistentTerm")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(0);
+    });
+
+    test("case insensitive search", async () => {
+      const testFile = new TFile();
+      testFile.basename = "MASTER Plan";
+      testFile.path = "MASTER Plan.md";
+
+      app.vault._markdownFiles = [testFile];
+      app.vault._cachedRead = "master plan details";
+
+      const result = await request(server)
+        .post("/search/simple/?query=master")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(200);
+
+      expect(result.body).toHaveLength(1);
+      expect(result.body[0].matches).toHaveLength(2);
+
+      // Should match "MASTER" in filename (case-insensitive)
+      expect(result.body[0].matches[0].match.source).toBe("filename");
+      expect(result.body[0].matches[0].match.start).toBe(0);
+      expect(result.body[0].matches[0].match.end).toBe(6);
+
+      // Should match "master" in content
+      expect(result.body[0].matches[1].match.source).toBe("content");
+      expect(result.body[0].matches[1].match.start).toBe(0);
+      expect(result.body[0].matches[1].match.end).toBe(6);
+    });
+
+    test("unauthorized", async () => {
+      await request(server)
+        .post("/search/simple/?query=test")
+        .expect(401);
+    });
+
+    test("missing query parameter", async () => {
+      await request(server)
+        .post("/search/simple/")
+        .set("Authorization", `Bearer ${API_KEY}`)
+        .expect(400);
+    });
+  });
 });

src/requestHandler.ts

@@ -1026,8 +1026,8 @@ export default class RequestHandler {
       if (result) {
         const contextMatches: SearchContext[] = [];
         for (const match of result.matches) {
-          if (match[0] === 0) {
-            // When start position is between 0 and positionOffset, that means the search term matched within the headline.
+          if (match[0] < positionOffset) {
+            // When start position is between 0 and positionOffset, that means the search term matched within the filename.
             contextMatches.push({
               match: {
                 start: match[0],