Process thinking blocks with Anthropic provider and write to the Output.

core/autocomplete/util/completionTestUtils.test.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.ts

@@ -0,0 +1,63 @@
+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;
+        };
+    };
+}
+
+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,
+            },
+        },
+    };
+}

core/autocomplete/util/processSingleLineCompletion.test.ts

@@ -0,0 +1,97 @@
+import { processTestCase } from "./completionTestUtils";
+import { processSingleLineCompletion } from "./processSingleLineCompletion";
+
+describe("processSingleLineCompletion", () => {
+
+    it("should handle simple end of line completion", () => {
+        const testCase = processTestCase({
+            original: "console.log(|cur|",
+            completion: "\"Hello, world!\")",
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+    it("should handle midline insert repeating the end of line", () => {
+        const testCase = processTestCase({
+            original: "console.log(|cur|);|till|",
+            completion: "\"Hello, world!\");",
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+    it("should handle midline insert repeating the end of line plus adding a semicolon", () => {
+        const testCase = processTestCase({
+            original: "console.log(|cur|)|till|",
+            completion: "\"Hello, world!\");",
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+    it("should handle simple midline insert", () => {
+        const testCase = processTestCase({
+            original: "console.log(|cur|)",
+            completion: "\"Hello, world!\"",
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+    it("should handle complex dif with addition in the beginning", () => {
+        const testCase = processTestCase({
+            original: "console.log(|cur||till|, \"param1\", )", // TODO
+            completion: "\"Hello world!\", \"param1\", param1);",
+            appliedCompletion: "\"Hello world!\""
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+    it("should handle simple insertion even with random equality", () => {
+        const testCase = processTestCase({
+            original: "print(f\"Foobar length: |cur||till|\")",
+            completion: "{len(foobar)}",
+        });
+
+        const result = processSingleLineCompletion(
+            testCase.input.lastLineOfCompletionText,
+            testCase.input.currentText,
+            testCase.input.cursorPosition
+        );
+
+        expect(result).toEqual(testCase.expectedResult);
+    });
+
+});

core/autocomplete/util/processSingleLineCompletion.ts

@@ -0,0 +1,92 @@
+import * as Diff from "diff";
+
+interface SingleLineCompletionResult {
+    completionText: string;
+    range?: {
+        start: number;
+        end: number;
+    };
+}
+
+
+interface DiffType {
+    count?: number;
+    added?: boolean;
+    removed?: boolean;
+    value: string;
+}
+
+
+function diffPatternMatches(
+    diffs: DiffType[],
+    pattern: DiffPartType[],
+): boolean {
+    if (diffs.length !== pattern.length) {
+        return false;
+    }
+
+    for (let i = 0; i < diffs.length; i++) {
+        const diff = diffs[i];
+        const diffPartType: DiffPartType =
+            !diff.added && !diff.removed ? "=" : diff.added ? "+" : "-";
+
+        if (diffPartType !== pattern[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+type DiffPartType = "+" | "-" | "=";
+
+export function processSingleLineCompletion(
+    lastLineOfCompletionText: string,
+    currentText: string,
+    cursorPosition: number
+): SingleLineCompletionResult | undefined {
+    const diffs: DiffType[] = Diff.diffWords(currentText, lastLineOfCompletionText);
+
+    if (diffPatternMatches(diffs, ["+"])) {
+        // Just insert, we're already at the end of the line
+        return {
+            completionText: lastLineOfCompletionText,
+        };
+    }
+
+    if (
+        diffPatternMatches(diffs, ["+", "="]) ||
+        diffPatternMatches(diffs, ["+", "=", "+"])
+    ) {
+        // The model repeated the text after the cursor to the end of the line
+        return {
+            completionText: lastLineOfCompletionText,
+            range: {
+                start: cursorPosition,
+                end: currentText.length + cursorPosition,
+            },
+        };
+    }
+
+    if (
+        diffPatternMatches(diffs, ["+", "-"]) ||
+        diffPatternMatches(diffs, ["-", "+"])
+    ) {
+        // We are midline and the model just inserted without repeating to the end of the line
+        return {
+            completionText: lastLineOfCompletionText,
+        };
+    }
+
+    // For any other diff pattern, just use the first added part if available
+    if (diffs[0]?.added) {
+        return {
+            completionText: diffs[0].value,
+        };
+    }
+
+    // Default case: treat as simple insertion
+    return {
+        completionText: lastLineOfCompletionText,
+    };
+}