Merge branch 'main' of https://github.com/continuedev/continue into fix/readFileRange-kotlin-int-overflow

Author: RomneyDa

.github/workflows/jetbrains-release.yaml

@@ -107,7 +107,7 @@ jobs:
           ref: ${{ github.event.release.tag_name }}
 
       - name: Import Apple certificate
-        uses: apple-actions/import-codesign-certs@v5
+        uses: apple-actions/import-codesign-certs@v6
         with:
           keychain: ${{ github.run_id }}
           keychain-password: ${{ github.run_id }}

core/edit/searchAndReplace/findSearchMatch.ts

@@ -59,6 +59,25 @@ function trimmedMatch(
   return null;
 }
 
+/**
+ * Case-insensitive matching strategy
+ */
+function caseInsensitiveMatch(
+  fileContent: string,
+  searchContent: string,
+): BasicMatchResult | null {
+  const lowerFileContent = fileContent.toLowerCase();
+  const lowerSearchContent = searchContent.toLowerCase();
+  const index = lowerFileContent.indexOf(lowerSearchContent);
+  if (index !== -1) {
+    return {
+      startIndex: index,
+      endIndex: index + searchContent.length,
+    };
+  }
+  return null;
+}
+
 /**
  * Whitespace-ignored matching strategy
  * Removes all whitespace from both content and search, then finds the match
@@ -284,6 +303,7 @@ function findFuzzyMatch(
 const matchingStrategies: Array<{ strategy: MatchStrategy; name: string }> = [
   { strategy: exactMatch, name: "exactMatch" },
   { strategy: trimmedMatch, name: "trimmedMatch" },
+  { strategy: caseInsensitiveMatch, name: "caseInsensitiveMatch" },
   { strategy: whitespaceIgnoredMatch, name: "whitespaceIgnoredMatch" },
   // { strategy: findFuzzyMatch, name: "jaroWinklerFuzzyMatch" },
 ];

core/edit/searchAndReplace/findSearchMatch.vitest.ts

@@ -109,8 +109,11 @@ describe("findSearchMatch", () => {
       const searchContent = "hello";
       const result = findSearchMatch(fileContent, searchContent);
 
-      // Should not match due to case sensitivity, will fall through to other strategies
-      expect(result).toBeNull();
+      expect(result).toEqual({
+        startIndex: 0,
+        endIndex: 5,
+        strategyName: "caseInsensitiveMatch",
+      });
     });
   });
 
@@ -152,6 +155,32 @@ describe("findSearchMatch", () => {
     });
   });
 
+  describe("Case insensitive match strategy fallback", () => {
+    it("should match when case differs", () => {
+      const result = findSearchMatch(
+        "const myVariable = 42;",
+        "const MYVARIABLE = 42;",
+      );
+      expect(result).toEqual({
+        startIndex: 0,
+        endIndex: 22,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+
+    it("should match mixed case in middle of file", () => {
+      const result = findSearchMatch(
+        "function HandleClick() {",
+        "function handleclick() {",
+      );
+      expect(result).toEqual({
+        startIndex: 0,
+        endIndex: 24,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+  });
+
   describe("Whitespace ignored strategy fallback", () => {
     it("should match content with different whitespace formatting", () => {
       const fileContent = "function test() {\n  return true;\n}";

core/edit/searchAndReplace/findSearchMatches.test.ts

@@ -113,6 +113,98 @@ line 3 foo`;
     });
   });
 
+  describe("case insensitive match strategy", () => {
+    it("should find multiple occurrences with different cases", () => {
+      const content = "const Foo = 'FOO';";
+      const search = "foo";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(2);
+      expect(matches[0]).toEqual({
+        startIndex: 6,
+        endIndex: 9,
+        strategyName: "caseInsensitiveMatch",
+      });
+      expect(matches[1]).toEqual({
+        startIndex: 13,
+        endIndex: 16,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+
+    it("should handle mixed case patterns", () => {
+      const content = "const MyVariable = 'value';";
+      const search = "mYvArIaBlE";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(1);
+      expect(matches[0]).toEqual({
+        startIndex: 6,
+        endIndex: 16,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+
+    it("should find multiple matches with varying cases", () => {
+      const content = "Hello world, HELLO universe, HeLLo there";
+      const search = "hello";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(3);
+      expect(matches[0]).toEqual({
+        startIndex: 0,
+        endIndex: 5,
+        strategyName: "caseInsensitiveMatch",
+      });
+      expect(matches[1]).toEqual({
+        startIndex: 13,
+        endIndex: 18,
+        strategyName: "caseInsensitiveMatch",
+      });
+      expect(matches[2]).toEqual({
+        startIndex: 29,
+        endIndex: 34,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+
+    it("should handle multi-line content with case differences", () => {
+      const content = `function Test() {
+  return TRUE;
+}`;
+      const search = "test";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(1);
+      expect(matches[0]).toEqual({
+        startIndex: 9,
+        endIndex: 13,
+        strategyName: "caseInsensitiveMatch",
+      });
+    });
+
+    it("should preserve original content length in match", () => {
+      const content = "const VARIABLE = 'value';";
+      const search = "variable";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(1);
+      expect(matches[0].endIndex - matches[0].startIndex).toBe(8);
+      expect(content.slice(matches[0].startIndex, matches[0].endIndex)).toBe(
+        "VARIABLE",
+      );
+    });
+
+    it("should not match when exact and trimmed strategies succeed", () => {
+      const content = "const foo = 'bar';";
+      const search = "foo";
+      const matches = findSearchMatches(content, search);
+
+      expect(matches).toHaveLength(1);
+      expect(matches[0].strategyName).toBe("exactMatch");
+    });
+  });
+
   describe("whitespace ignored match strategy", () => {
     it("should find matches ignoring internal whitespace", () => {
       const content = "const foo = bar;";