@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatTransferService.js

@@ -7,9 +7,14 @@ import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { areWorkspaceFoldersEmpty } from '../../../../services/workspaces/common/workspaceUtils.js';
 
-const transferredWorkspacesKey = 'chat.transferedWorkspaces';
+const transferredWorkspacesKey = "chat.transferedWorkspaces";
 let ChatTransferService = class ChatTransferService {
-    constructor(workspaceService, storageService, fileService, workspaceTrustManagementService) {
+    constructor(
+        workspaceService,
+        storageService,
+        fileService,
+        workspaceTrustManagementService
+    ) {
         this.workspaceService = workspaceService;
         this.storageService = storageService;
         this.fileService = fileService;
@@ -18,12 +23,22 @@ let ChatTransferService = class ChatTransferService {
     deleteWorkspaceFromTransferredList(workspace) {
         const transferredWorkspaces = this.storageService.getObject(transferredWorkspacesKey, StorageScope.PROFILE, []);
         const updatedWorkspaces = transferredWorkspaces.filter(uri => uri !== ( workspace.toString()));
-        this.storageService.store(transferredWorkspacesKey, updatedWorkspaces, StorageScope.PROFILE, StorageTarget.MACHINE);
+        this.storageService.store(
+            transferredWorkspacesKey,
+            updatedWorkspaces,
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
     }
     addWorkspaceToTransferred(workspace) {
         const transferredWorkspaces = this.storageService.getObject(transferredWorkspacesKey, StorageScope.PROFILE, []);
         transferredWorkspaces.push(( workspace.toString()));
-        this.storageService.store(transferredWorkspacesKey, transferredWorkspaces, StorageScope.PROFILE, StorageTarget.MACHINE);
+        this.storageService.store(
+            transferredWorkspacesKey,
+            transferredWorkspaces,
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
     }
     async checkAndSetTransferredWorkspaceTrust() {
         const workspace = this.workspaceService.getWorkspace();
@@ -44,11 +59,6 @@ let ChatTransferService = class ChatTransferService {
         return ( chatWorkspaceTransfer.some(item => ( item.toString()) === ( workspace.toString())));
     }
 };
-ChatTransferService = ( __decorate([
-    ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IFileService)),
-    ( __param(3, IWorkspaceTrustManagementService))
-], ChatTransferService));
+ChatTransferService = ( __decorate([( __param(0, IWorkspaceContextService)), ( __param(1, IStorageService)), ( __param(2, IFileService)), ( __param(3, IWorkspaceTrustManagementService))], ChatTransferService));
 
 export { ChatTransferService };

package/vscode/src/vs/workbench/contrib/chat/common/model/objectMutationLog.d.ts

@@ -0,0 +1,109 @@
+import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+/** IMPORTANT: `Key` comes first. Then we should sort in order of least->most expensive to diff */
+declare enum TransformKind {
+    Key = 0,
+    Primitive = 1,
+    Array = 2,
+    Object = 3
+}
+/** Schema entries sorted with key properties first */
+export type SchemaEntries = [
+    string,
+    Transform<unknown, unknown>
+][];
+interface TransformBase<TFrom, TTo> {
+    readonly kind: TransformKind;
+    /** Extracts the serializable value from the source object */
+    extract(from: TFrom): TTo;
+}
+/** Transform for primitive values (keys and values) that can be compared for equality */
+export interface TransformValue<TFrom, TTo> extends TransformBase<TFrom, TTo> {
+    readonly kind: TransformKind.Key | TransformKind.Primitive;
+    /** Compares two serialized values for equality */
+    equals(a: TTo, b: TTo): boolean;
+}
+/** Transform for arrays with an item schema */
+export interface TransformArray<TFrom, TTo> extends TransformBase<TFrom, TTo> {
+    readonly kind: TransformKind.Array;
+    /** The schema for array items */
+    readonly itemSchema: TransformObject<unknown, unknown> | TransformValue<unknown, unknown>;
+}
+/** Transform for objects with child properties */
+export interface TransformObject<TFrom, TTo> extends TransformBase<TFrom, TTo> {
+    readonly kind: TransformKind.Object;
+    /** Schema entries sorted with Key properties first */
+    readonly children: SchemaEntries;
+    /** Checks if the object is sealed (won't change). */
+    sealed?(obj: TTo, wasSerialized: boolean): boolean;
+}
+export type Transform<TFrom, TTo> = TransformValue<TFrom, TTo> | TransformArray<TFrom, TTo> | TransformObject<TFrom, TTo>;
+export type Schema<TFrom, TTo> = {
+    [K in keyof Required<TTo>]: Transform<TFrom, TTo[K]>;
+};
+/**
+ * A primitive that will be tracked and compared first. If this is changed, the entire
+ * object is thrown out and re-stored.
+ */
+export declare function key<T, R = T>(comparator?: (a: R, b: R) => boolean): TransformValue<T, R>;
+/** A value that will be tracked and replaced if the comparator is not equal. */
+export declare function value<T, R extends string | number | boolean | undefined>(): TransformValue<T, R>;
+export declare function value<T, R>(comparator: (a: R, b: R) => boolean): TransformValue<T, R>;
+/** An array that will use the schema to compare items positionally. */
+export declare function array<T, R>(schema: TransformObject<T, R> | TransformValue<T, R>): TransformArray<readonly T[], R[]>;
+export interface ObjectOptions<R> {
+    /**
+     * Returns true if the object is sealed and will never change again.
+     * When comparing two sealed objects, only key fields are compared
+     * (to detect replacement), but other fields are not diffed.
+     */
+    sealed?: (obj: R, wasSerialized: boolean) => boolean;
+}
+/** An object schema. */
+export declare function object<T, R extends object>(schema: Schema<T, R>, options?: ObjectOptions<R>): TransformObject<T, R>;
+/**
+ * Defines a getter on the object to extract a value, compared with the given schema.
+ * It should return the value that will get serialized in the resulting log file.
+ */
+export declare function t<T, O, R>(getter: (obj: T) => O, schema: Transform<O, R>): Transform<T, R>;
+/** Shortcut for t(fn, value()) */
+export declare function v<T, R extends string | number | boolean | undefined>(getter: (obj: T) => R): TransformValue<T, R>;
+export declare function v<T, R>(getter: (obj: T) => R, comparator: (a: R, b: R) => boolean): TransformValue<T, R>;
+/**
+ * An implementation of an append-based mutation logger. Given a `Transform`
+ * definition of an object, it can recreate it from a file on disk. It is
+ * then stateful, and given a `write` call it can update the log in a minimal
+ * way.
+ */
+export declare class ObjectMutationLog<TFrom, TTo> {
+    private readonly _transform;
+    private readonly _compactAfterEntries;
+    private _previous;
+    private _entryCount;
+    constructor(_transform: Transform<TFrom, TTo>, _compactAfterEntries?: number);
+    /**
+     * Creates an initial log file from the given object.
+     */
+    createInitial(current: TFrom): VSBuffer;
+    /**
+     * Creates an initial log file from the serialized object.
+     */
+    createInitialFromSerialized(value: TTo): VSBuffer;
+    /**
+     * Reads and reconstructs the state from a log file.
+     */
+    read(content: VSBuffer): TTo;
+    /**
+     * Writes updates to the log. Returns the operation type and data to write.
+     */
+    write(current: TFrom): {
+        op: "append" | "replace";
+        data: VSBuffer;
+    };
+    private _applySet;
+    private _applyPush;
+    private _diff;
+    private _diffObject;
+    private _diffArray;
+    private _hasKeyMismatch;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/model/objectMutationLog.js

@@ -0,0 +1,349 @@
+
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { isUndefinedOrNull } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+var TransformKind;
+(function(TransformKind) {
+    TransformKind[TransformKind["Key"] = 0] = "Key";
+    TransformKind[TransformKind["Primitive"] = 1] = "Primitive";
+    TransformKind[TransformKind["Array"] = 2] = "Array";
+    TransformKind[TransformKind["Object"] = 3] = "Object";
+})(TransformKind || (TransformKind = {}));
+function key(comparator) {
+    return {
+        kind: TransformKind.Key,
+        extract: from => from,
+        equals: comparator ?? ((a, b) => a === b)
+    };
+}
+function value(comparator) {
+    return {
+        kind: TransformKind.Primitive,
+        extract: from => {
+            let value = from;
+            if (!!value && typeof value === "object") {
+                value = JSON.parse(JSON.stringify(value));
+            }
+            return value;
+        },
+        equals: comparator ?? ((a, b) => a === b)
+    };
+}
+function array(schema) {
+    return {
+        kind: TransformKind.Array,
+        itemSchema: schema,
+        extract: from => from?.map(item => schema.extract(item))
+    };
+}
+function object(schema, options) {
+    const entries = Object.entries(schema).sort(([, a], [, b]) => a.kind - b.kind);
+    return {
+        kind: TransformKind.Object,
+        children: entries,
+        sealed: options?.sealed,
+        extract: from => {
+            if (isUndefinedOrNull(from)) {
+                return from;
+            }
+            const result = Object.create(null);
+            for (const [key, transform] of entries) {
+                result[key] = transform.extract(from);
+            }
+            return result;
+        }
+    };
+}
+function t(getter, schema) {
+    return {
+        ...schema,
+        extract: from => schema.extract(getter(from))
+    };
+}
+function v(getter, comparator) {
+    const inner = value(comparator);
+    return {
+        ...inner,
+        extract: from => inner.extract(getter(from))
+    };
+}
+var EntryKind;
+(function(EntryKind) {
+    EntryKind[EntryKind["Initial"] = 0] = "Initial";
+    EntryKind[EntryKind["Set"] = 1] = "Set";
+    EntryKind[EntryKind["Push"] = 2] = "Push";
+    EntryKind[EntryKind["Delete"] = 3] = "Delete";
+})(EntryKind || (EntryKind = {}));
+const LF = VSBuffer.fromString("\n");
+class ObjectMutationLog {
+    constructor(_transform, _compactAfterEntries = 512) {
+        this._transform = _transform;
+        this._compactAfterEntries = _compactAfterEntries;
+        this._entryCount = 0;
+    }
+    createInitial(current) {
+        return this.createInitialFromSerialized(this._transform.extract(current));
+    }
+    createInitialFromSerialized(value) {
+        this._previous = value;
+        this._entryCount = 1;
+        const entry = {
+            kind: EntryKind.Initial,
+            v: value
+        };
+        return VSBuffer.fromString(JSON.stringify(entry) + "\n");
+    }
+    read(content) {
+        let state;
+        let lineCount = 0;
+        let start = 0;
+        const len = content.byteLength;
+        while (start < len) {
+            let end = content.indexOf(LF, start);
+            if (end === -1) {
+                end = len;
+            }
+            if (end > start) {
+                const line = content.slice(start, end);
+                if (line.byteLength > 0) {
+                    lineCount++;
+                    const entry = JSON.parse(( line.toString()));
+                    switch (entry.kind) {
+                    case EntryKind.Initial:
+                        state = entry.v;
+                        break;
+                    case EntryKind.Set:
+                        this._applySet(state, entry.k, entry.v);
+                        break;
+                    case EntryKind.Push:
+                        this._applyPush(state, entry.k, entry.v, entry.i);
+                        break;
+                    case EntryKind.Delete:
+                        this._applySet(state, entry.k, undefined);
+                        break;
+                    default:
+                        assertNever();
+                    }
+                }
+            }
+            start = end + 1;
+        }
+        if (lineCount === 0) {
+            throw ( new Error("Empty log file"));
+        }
+        this._previous = state;
+        this._entryCount = lineCount;
+        return state;
+    }
+    write(current) {
+        const currentValue = this._transform.extract(current);
+        if (!this._previous || this._entryCount > this._compactAfterEntries) {
+            this._previous = currentValue;
+            this._entryCount = 1;
+            const entry = {
+                kind: EntryKind.Initial,
+                v: currentValue
+            };
+            return {
+                op: "replace",
+                data: VSBuffer.fromString(JSON.stringify(entry) + "\n")
+            };
+        }
+        const entries = [];
+        const path = [];
+        this._diff(this._transform, path, this._previous, currentValue, entries);
+        if (entries.length === 0) {
+            return {
+                op: "append",
+                data: VSBuffer.fromString("")
+            };
+        }
+        this._entryCount += entries.length;
+        this._previous = currentValue;
+        let data = "";
+        for (const e of entries) {
+            data += JSON.stringify(e) + "\n";
+        }
+        return {
+            op: "append",
+            data: VSBuffer.fromString(data)
+        };
+    }
+    _applySet(state, path, value) {
+        if (path.length === 0) {
+            return;
+        }
+        let current = state;
+        for (let i = 0; i < path.length - 1; i++) {
+            current = current[path[i]];
+        }
+        current[path[path.length - 1]] = value;
+    }
+    _applyPush(state, path, values, startIndex) {
+        let current = state;
+        for (let i = 0; i < path.length - 1; i++) {
+            current = current[path[i]];
+        }
+        const arrayKey = path[path.length - 1];
+        const arr = current[arrayKey] || [];
+        if (startIndex !== undefined) {
+            arr.length = startIndex;
+        }
+        if (values && values.length > 0) {
+            arr.push(...values);
+        }
+        current[arrayKey] = arr;
+    }
+    _diff(transform, path, prev, curr, entries) {
+        if (transform.kind === TransformKind.Key || transform.kind === TransformKind.Primitive) {
+            if (!transform.equals(prev, curr)) {
+                entries.push({
+                    kind: EntryKind.Set,
+                    k: path.slice(),
+                    v: curr
+                });
+            }
+        } else if (isUndefinedOrNull(prev) || isUndefinedOrNull(curr)) {
+            if (prev !== curr) {
+                if (curr === undefined) {
+                    entries.push({
+                        kind: EntryKind.Delete,
+                        k: path.slice()
+                    });
+                } else if (curr === null) {
+                    entries.push({
+                        kind: EntryKind.Set,
+                        k: path.slice(),
+                        v: null
+                    });
+                } else {
+                    entries.push({
+                        kind: EntryKind.Set,
+                        k: path.slice(),
+                        v: curr
+                    });
+                }
+            }
+        } else if (transform.kind === TransformKind.Array) {
+            this._diffArray(transform, path, prev, curr, entries);
+        } else if (transform.kind === TransformKind.Object) {
+            this._diffObject(transform.children, path, prev, curr, entries, transform.sealed);
+        } else {
+            throw ( new Error(`Unknown transform kind ${JSON.stringify(transform)}`));
+        }
+    }
+    _diffObject(children, path, prev, curr, entries, sealed) {
+        const prevObj = prev;
+        const currObj = curr;
+        let i = 0;
+        for (; i < children.length; i++) {
+            const [key, transform] = children[i];
+            if (transform.kind !== TransformKind.Key) {
+                break;
+            }
+            if (!transform.equals(prevObj?.[key], currObj[key])) {
+                entries.push({
+                    kind: EntryKind.Set,
+                    k: path.slice(),
+                    v: curr
+                });
+                return;
+            }
+        }
+        if (sealed && sealed(prev, true) && sealed(curr, false)) {
+            return;
+        }
+        for (; i < children.length; i++) {
+            const [key, transform] = children[i];
+            path.push(key);
+            this._diff(transform, path, prevObj?.[key], currObj[key], entries);
+            path.pop();
+        }
+    }
+    _diffArray(transform, path, prev, curr, entries) {
+        const prevArr = prev || [];
+        const currArr = curr || [];
+        const itemSchema = transform.itemSchema;
+        const minLen = Math.min(prevArr.length, currArr.length);
+        if (itemSchema.kind === TransformKind.Object) {
+            const childEntries = itemSchema.children;
+            for (let i = 0; i < minLen; i++) {
+                const prevItem = prevArr[i];
+                const currItem = currArr[i];
+                if (this._hasKeyMismatch(childEntries, prevItem, currItem)) {
+                    const newItems = currArr.slice(i);
+                    entries.push({
+                        kind: EntryKind.Push,
+                        k: path.slice(),
+                        v: newItems.length > 0 ? newItems : undefined,
+                        i
+                    });
+                    return;
+                }
+                path.push(i);
+                this._diffObject(childEntries, path, prevItem, currItem, entries, itemSchema.sealed);
+                path.pop();
+            }
+            if (currArr.length > prevArr.length) {
+                entries.push({
+                    kind: EntryKind.Push,
+                    k: path.slice(),
+                    v: currArr.slice(prevArr.length)
+                });
+            } else if (currArr.length < prevArr.length) {
+                entries.push({
+                    kind: EntryKind.Push,
+                    k: path.slice(),
+                    i: currArr.length
+                });
+            }
+        } else {
+            let firstMismatch = -1;
+            for (let i = 0; i < minLen; i++) {
+                if (!itemSchema.equals(prevArr[i], currArr[i])) {
+                    firstMismatch = i;
+                    break;
+                }
+            }
+            if (firstMismatch === -1) {
+                if (currArr.length > prevArr.length) {
+                    entries.push({
+                        kind: EntryKind.Push,
+                        k: path.slice(),
+                        v: currArr.slice(prevArr.length)
+                    });
+                } else if (currArr.length < prevArr.length) {
+                    entries.push({
+                        kind: EntryKind.Push,
+                        k: path.slice(),
+                        i: currArr.length
+                    });
+                }
+            } else {
+                const newItems = currArr.slice(firstMismatch);
+                entries.push({
+                    kind: EntryKind.Push,
+                    k: path.slice(),
+                    v: newItems.length > 0 ? newItems : undefined,
+                    i: firstMismatch
+                });
+            }
+        }
+    }
+    _hasKeyMismatch(children, prev, curr) {
+        const prevObj = prev;
+        const currObj = curr;
+        for (const [key, transform] of children) {
+            if (transform.kind !== TransformKind.Key) {
+                break;
+            }
+            if (!transform.equals(prevObj?.[key], currObj[key])) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+export { ObjectMutationLog, array, key, object, t, v, value };

package/vscode/src/vs/workbench/contrib/chat/common/participants/chatSlashCommands.js

@@ -20,7 +20,10 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
         if (( this._commands.has(data.command))) {
             throw ( new Error(`Already registered a command with id ${data.command}}`));
         }
-        this._commands.set(data.command, { data, command });
+        this._commands.set(data.command, {
+            data,
+            command
+        });
         this._onDidChangeCommands.fire();
         return toDisposable(() => {
             if (this._commands.delete(data.command)) {
@@ -29,9 +32,9 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
         });
     }
     getCommands(location, mode) {
-        return Array
-            .from(( this._commands.values()), v => v.data)
-            .filter(c => c.locations.includes(location) && (!c.modes || c.modes.includes(mode)));
+        return Array.from(( this._commands.values()), v => v.data).filter(
+            c => c.locations.includes(location) && (!c.modes || c.modes.includes(mode))
+        );
     }
     hasCommand(id) {
         return ( this._commands.has(id));
@@ -39,7 +42,7 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     async executeCommand(id, prompt, progress, history, location, sessionResource, token) {
         const data = this._commands.get(id);
         if (!data) {
-            throw ( new Error('No command with id ${id} NOT registered'));
+            throw ( new Error("No command with id ${id} NOT registered"));
         }
         if (!data.command) {
             await this._extensionService.activateByEvent(`onSlash:${id}`);
@@ -50,8 +53,6 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
         return await data.command(prompt, progress, history, location, sessionResource, token);
     }
 };
-ChatSlashCommandService = ( __decorate([
-    ( __param(0, IExtensionService))
-], ChatSlashCommandService));
+ChatSlashCommandService = ( __decorate([( __param(0, IExtensionService))], ChatSlashCommandService));
 
 export { ChatSlashCommandService };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/chatPromptFilesContribution.d.ts

@@ -1,5 +1,7 @@
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 export declare class ChatPromptFilesExtensionPointHandler implements IWorkbenchContribution {
     private readonly promptsService;
     static readonly ID = "workbench.contrib.chatPromptFilesExtensionPointHandler";
@@ -7,3 +9,10 @@ export declare class ChatPromptFilesExtensionPointHandler implements IWorkbenchC
     constructor(promptsService: IPromptsService);
     private handle;
 }
+/**
+ * Result type for the extension prompt file provider command.
+ */
+export interface IExtensionPromptFileResult {
+    readonly uri: UriComponents;
+    readonly type: PromptsType;
+}