Merge branch 'main' into pe/remove-pre-indexed-docs-ui

Author: Patrick-Erichsen

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @continuedev/continue-code-reviewers

.github/workflows/pr_checks.yaml

@@ -420,8 +420,7 @@ jobs:
         id: test-extensions-cache
         with:
           path: extensions/vscode/e2e/.test-extensions
-          # package.json used as the key because that's where the download script is defined
-          key: vscode-test-extensions-${{ hashFiles('extensions/vscode/package.json') }}
+          key: CONSTANT
 
       - name: Download build artifact
         uses: actions/download-artifact@v4

.gitignore

@@ -157,11 +157,15 @@ Icon?
 notes.md
 
 manual-testing-sandbox/.idea/**
+manual-testing-sandbox/.continue/**
 extensions/intellij/.idea/**
 
 **/.idea/workspace.xml
 **/.idea/usage.statistics.xml
 **/.idea/shelf/
+**/.idea/inspectionProfiles/Project_Default.xml
+**/.idea/php.xml
+
 
 extensions/intellij/bin
 extensions/.continue-debug/

.prettierignore

@@ -14,4 +14,5 @@ gui/dist
 **/.continueignore
 CHANGELOG.md
 **/continue_tutorial.py
-**/node_modules
+**/node_modules
+**/CODEOWNERS

README.md

@@ -8,7 +8,7 @@
 
 <div align="center">
 
-**[Continue](https://docs.continue.dev) enables to developers to create, share, and use custom AI code assistants with our open-source [VS Code](https://marketplace.visualstudio.com/items?itemName=Continue.continue) and [JetBrains](https://plugins.jetbrains.com/plugin/22707-continue-extension) extensions and [hub of models, rules, prompts, docs, and other building blocks](https://hub.continue.dev)**
+**[Continue](https://docs.continue.dev) enables developers to create, share, and use custom AI code assistants with our open-source [VS Code](https://marketplace.visualstudio.com/items?itemName=Continue.continue) and [JetBrains](https://plugins.jetbrains.com/plugin/22707-continue-extension) extensions and [hub of models, rules, prompts, docs, and other building blocks](https://hub.continue.dev)**
 
 </div>
 

binary/package-lock.json

@@ -5,8 +5,18 @@
     "project": "./tsconfig.json"
   },
   "rules": {
-    "quotes": ["warn", "double", {}],
+    "quotes": ["off", "double", {}],
     "@typescript-eslint/naming-convention": "off",
-    "@typescript-eslint/no-floating-promises": "warn"
+    "@typescript-eslint/no-floating-promises": "off",
+    "import/order": "off",
+    "curly": "off",
+    "@typescript-eslint/semi": "off",
+    "eqeqeq": "error",
+    "complexity": ["error", { "max": 38 }],
+    "max-lines-per-function": ["error", { "max": 996 }],
+    "max-statements": ["error", { "max": 112 }],
+    "max-depth": ["error", { "max": 6 }],
+    "max-nested-callbacks": ["error", { "max": 4 }],
+    "max-params": ["error", { "max": 11 }]
   }
 }

core/.eslintrc.json

@@ -1,5 +1,4 @@
 import { streamLines } from "../../../diff/util";
-import { PosthogFeatureFlag, Telemetry } from "../../../util/posthog";
 import { HelperVars } from "../../util/HelperVars";
 
 import { stopAtStartOf, stopAtStopTokens } from "./charStream";
@@ -73,9 +72,7 @@ export class StreamTransformPipeline {
       fullStop,
     );
 
-    const timeoutValue = await Telemetry.getValueForFeatureFlag(
-      PosthogFeatureFlag.AutocompleteTimeout,
-    );
+    const timeoutValue = helper.options.showWhateverWeHaveAtXMs;
 
     lineGenerator = showWhateverWeHaveAtXMs(lineGenerator, timeoutValue!);
 

core/autocomplete/filtering/streamTransforms/StreamTransformPipeline.ts

@@ -0,0 +1,65 @@
+import {
+    processTestCase,
+    type CompletionTestCase,
+} from "./completionTestUtils";
+
+describe("processTestCase utility", () => {
+    it("processes simple console.log completion", () => {
+        const testCase: CompletionTestCase = {
+            original: "console.log(|cur||till|)",
+            completion: "\"foo,\", bar",
+        };
+
+        expect(processTestCase(testCase)).toEqual({
+            input: {
+                lastLineOfCompletionText: "\"foo,\", bar",
+                currentText: ")",
+                cursorPosition: "console.log(".length,
+            },
+            expectedResult: {
+                completionText: "\"foo,\", bar",
+            },
+        });
+    });
+
+    it("processes simple console.log completion with overwriting", () => {
+        const testCase: CompletionTestCase = {
+            original: "console.log(|cur|)|till|",
+            completion: "\"foo,\", bar);",
+        };
+
+        expect(processTestCase(testCase)).toEqual({
+            input: {
+                lastLineOfCompletionText: "\"foo,\", bar);",
+                currentText: ")",
+                cursorPosition: "console.log(".length,
+            },
+            expectedResult: {
+                completionText: "\"foo,\", bar);",
+                range: {
+                    start: "console.log(".length,
+                    end: "console.log()".length,
+                },
+            },
+        });
+    });
+
+    it("partially applying completion", () => {
+        const testCase: CompletionTestCase = {
+            original: "|cur||till|fetch(\"https://example.com\");",
+            completion: "await fetch(\"https://example.com\");",
+            appliedCompletion: "await ",
+        };
+
+        expect(processTestCase(testCase)).toEqual({
+            input: {
+                lastLineOfCompletionText: "await fetch(\"https://example.com\");",
+                currentText: "fetch(\"https://example.com\");",
+                cursorPosition: 0,
+            },
+            expectedResult: {
+                completionText: "await ",
+            },
+        });
+    });
+});

core/autocomplete/util/completionTestUtils.test.ts

@@ -0,0 +1,91 @@
+export interface CompletionTestCase {
+    original: string;    // Text with |cur| and |till| markers
+    completion: string;  // Text to insert/overwrite
+    appliedCompletion?: string | null;
+    cursorMarker?: string;
+    tillMarker?: string;
+}
+
+export interface ProcessedTestCase {
+    input: {
+        lastLineOfCompletionText: string;
+        currentText: string;
+        cursorPosition: number;
+    };
+    expectedResult: {
+        completionText: string;
+        range?: {
+            start: number;
+            end: number;
+        };
+    };
+}
+
+/**
+ * Transforms human-readable test case into input and expected results.
+ * 
+ * - `original`: Your original text with |cur| marking where the cursor is before completion,
+ *      and |till| marking where the cursor should be after accepting completion (and this is
+ *      the end of the actual applied completion)
+ * - `completion`: LLM completion output
+ * - `appliedCompletion` (optional):  part of the LLM completion output that is actually applied
+ *      (written between |cur| and |till| in the original)
+ * 
+ * For example, you have this line:
+ * 
+ *     console.log("<cursor here>");
+ * 
+ * and expect it to be completed this way:
+ * 
+ *     console.log("foo: ", bar<cursor here>);
+ * 
+ * with your completion coming from LLM being: `'foo: ", bar<cursor here>);'`
+ * 
+ * Your input to this function should be:
+ * - original: `'console.log("|cur|"|till|);'`
+ * - completion: `'foo: ", bar);'`
+ * - appliedCompletion: `'foo: ", bar'`
+ * 
+ * Output: input and expected output of {@link core/autocomplete/util/processSingleLineCompletion/processSingleLineCompletion|processSingleLineCompletion()}
+ * 
+ */
+export function processTestCase({
+    original,
+    completion,
+    appliedCompletion = null,
+    cursorMarker = "|cur|",
+    tillMarker = "|till|",
+}: CompletionTestCase): ProcessedTestCase {
+    // Validate cursor marker
+    if (!original.includes(cursorMarker)) {
+        throw new Error("Cursor marker not found in original text");
+    }
+
+    const cursorPos = original.indexOf(cursorMarker);
+    original = original.replace(cursorMarker, "");
+
+    let tillPos = original.indexOf(tillMarker);
+    if (tillPos < 0) {
+        tillPos = cursorPos;
+    } else {
+        original = original.replace(tillMarker, "")
+    }
+
+    // Calculate currentText based on what's between cursor and till marker
+    const currentText = original.substring(cursorPos);
+
+    return {
+        input: {
+            lastLineOfCompletionText: completion,
+            currentText,
+            cursorPosition: cursorPos,
+        },
+        expectedResult: {
+            completionText: appliedCompletion || completion,
+            range: cursorPos === tillPos ? undefined : {
+                start: cursorPos,
+                end: tillPos,
+            },
+        },
+    };
+}