@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.d.ts

@@ -0,0 +1,76 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IActiveSessionItem } from "../../sessions/browser/sessionsManagementService.js";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service";
+import { IJSONEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/jsonEditing.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IPreferencesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { CommandString } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskConfiguration";
+import { ISessionsConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/sessionsConfigurationService.service";
+export type TaskStorageTarget = "user" | "workspace";
+/**
+ * Shape of a single task entry inside tasks.json.
+ */
+export interface ITaskEntry {
+    readonly label: string;
+    readonly task?: CommandString;
+    readonly script?: string;
+    readonly type?: string;
+    readonly command?: string;
+    readonly args?: CommandString[];
+    readonly inSessions?: boolean;
+    readonly windows?: {
+        command?: string;
+        args?: CommandString[];
+    };
+    readonly osx?: {
+        command?: string;
+        args?: CommandString[];
+    };
+    readonly linux?: {
+        command?: string;
+        args?: CommandString[];
+    };
+    readonly [key: string]: unknown;
+}
+export declare class SessionsConfigurationService extends Disposable implements ISessionsConfigurationService {
+    private readonly _fileService;
+    private readonly _jsonEditingService;
+    private readonly _preferencesService;
+    private readonly _terminalService;
+    private readonly _sessionsManagementService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private static readonly _LAST_RUN_TASK_LABELS_KEY;
+    private static readonly _SUPPORTED_TASK_TYPES;
+    private readonly _sessionTasks;
+    private readonly _fileWatcher;
+    /** Maps `cwd.toString() + command` to the terminal `instanceId`. */
+    private readonly _taskTerminals;
+    private readonly _lastRunTaskLabels;
+    private readonly _lastRunTaskObservables;
+    private _watchedResource;
+    private _lastRefreshedFolder;
+    constructor(_fileService: IFileService, _jsonEditingService: IJSONEditingService, _preferencesService: IPreferencesService, _terminalService: ITerminalService, _sessionsManagementService: ISessionsManagementService, _storageService: IStorageService);
+    getSessionTasks(session: IActiveSessionItem): IObservable<readonly ITaskEntry[]>;
+    getNonSessionTasks(session: IActiveSessionItem): Promise<readonly ITaskEntry[]>;
+    addTaskToSessions(task: ITaskEntry, session: IActiveSessionItem, target: TaskStorageTarget): Promise<void>;
+    createAndAddTask(command: string, session: IActiveSessionItem, target: TaskStorageTarget): Promise<ITaskEntry | undefined>;
+    runTask(task: ITaskEntry, session: IActiveSessionItem): Promise<void>;
+    getLastRunTaskLabel(repository: URI | undefined): IObservable<string | undefined>;
+    private _getExistingTerminalInstance;
+    private _getTasksJsonUri;
+    private _readTasksJson;
+    private _readAllTasks;
+    private _isSupportedTask;
+    private _resolveCommand;
+    private _appendArgs;
+    private _ensureFileWatch;
+    private _refreshSessionTasks;
+    private _commitTasksFile;
+    private _loadLastRunTaskLabels;
+    private _saveLastRunTaskLabels;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.js

@@ -0,0 +1,299 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual, joinPath, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonc';
+import { isWindows, isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { TerminalLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService.service';
+import { IJSONEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configuration/common/jsonEditing.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { CommandString } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/tasks/common/taskConfiguration';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var SessionsConfigurationService_1;
+let SessionsConfigurationService = class SessionsConfigurationService extends Disposable {
+    static {
+        SessionsConfigurationService_1 = this;
+    }
+    static {
+        this._LAST_RUN_TASK_LABELS_KEY = "agentSessions.lastRunTaskLabels";
+    }
+    static {
+        this._SUPPORTED_TASK_TYPES = ( new Set(["shell", "npm"]));
+    }
+    constructor(
+        _fileService,
+        _jsonEditingService,
+        _preferencesService,
+        _terminalService,
+        _sessionsManagementService,
+        _storageService
+    ) {
+        super();
+        this._fileService = _fileService;
+        this._jsonEditingService = _jsonEditingService;
+        this._preferencesService = _preferencesService;
+        this._terminalService = _terminalService;
+        this._sessionsManagementService = _sessionsManagementService;
+        this._storageService = _storageService;
+        this._sessionTasks = observableValue(this, []);
+        this._fileWatcher = this._register(( new MutableDisposable()));
+        this._taskTerminals = ( new Map());
+        this._lastRunTaskObservables = ( new Map());
+        this._lastRunTaskLabels = this._loadLastRunTaskLabels();
+    }
+    getSessionTasks(session) {
+        const folder = session.worktree ?? session.repository;
+        if (folder) {
+            this._ensureFileWatch(folder);
+        }
+        if (!isEqual(this._lastRefreshedFolder, folder)) {
+            this._lastRefreshedFolder = folder;
+            this._refreshSessionTasks(folder);
+        }
+        return this._sessionTasks;
+    }
+    async getNonSessionTasks(session) {
+        const allTasks = await this._readAllTasks(session);
+        return allTasks.filter(t => !t.inSessions);
+    }
+    async addTaskToSessions(task, session, target) {
+        const tasksJsonUri = this._getTasksJsonUri(session, target);
+        if (!tasksJsonUri) {
+            return;
+        }
+        const tasksJson = await this._readTasksJson(tasksJsonUri);
+        const tasks = tasksJson.tasks ?? [];
+        const index = tasks.findIndex(t => t.label === task.label);
+        if (index === -1) {
+            return;
+        }
+        await this._jsonEditingService.write(tasksJsonUri, [{
+            path: ["tasks", index, "inSessions"],
+            value: true
+        }], true);
+        if (target === "workspace") {
+            await this._commitTasksFile(session);
+        }
+    }
+    async createAndAddTask(command, session, target) {
+        const tasksJsonUri = this._getTasksJsonUri(session, target);
+        if (!tasksJsonUri) {
+            return undefined;
+        }
+        const tasksJson = await this._readTasksJson(tasksJsonUri);
+        const tasks = tasksJson.tasks ?? [];
+        const newTask = {
+            label: command,
+            type: "shell",
+            command,
+            inSessions: true
+        };
+        await this._jsonEditingService.write(tasksJsonUri, [{
+            path: ["version"],
+            value: tasksJson.version ?? "2.0.0"
+        }, {
+            path: ["tasks"],
+            value: [...tasks, newTask]
+        }], true);
+        if (target === "workspace") {
+            await this._commitTasksFile(session);
+        }
+        return newTask;
+    }
+    async runTask(task, session) {
+        const command = this._resolveCommand(task);
+        if (!command) {
+            return;
+        }
+        const cwd = session.worktree ?? session.repository;
+        if (!cwd) {
+            return;
+        }
+        const terminalKey = `${( cwd.toString())}${command}`;
+        let terminal = this._getExistingTerminalInstance(terminalKey);
+        if (!terminal) {
+            terminal = await this._terminalService.createTerminal({
+                location: TerminalLocation.Panel,
+                config: {
+                    name: task.label
+                },
+                cwd
+            });
+            this._taskTerminals.set(terminalKey, terminal.instanceId);
+        }
+        await terminal.sendText(command, true);
+        this._terminalService.setActiveInstance(terminal);
+        await this._terminalService.revealActiveTerminal();
+        if (session.repository) {
+            const key = ( session.repository.toString());
+            this._lastRunTaskLabels.set(key, task.label);
+            this._saveLastRunTaskLabels();
+            const obs = this._lastRunTaskObservables.get(key);
+            if (obs) {
+                transaction(tx => obs.set(task.label, tx));
+            }
+        }
+    }
+    getLastRunTaskLabel(repository) {
+        if (!repository) {
+            return observableValue("lastRunTaskLabel", undefined);
+        }
+        const key = ( repository.toString());
+        let obs = this._lastRunTaskObservables.get(key);
+        if (!obs) {
+            obs = observableValue("lastRunTaskLabel", this._lastRunTaskLabels.get(key));
+            this._lastRunTaskObservables.set(key, obs);
+        }
+        return obs;
+    }
+    _getExistingTerminalInstance(terminalKey) {
+        const instanceId = this._taskTerminals.get(terminalKey);
+        if (instanceId === undefined) {
+            return undefined;
+        }
+        const instance = this._terminalService.instances.find(i => i.instanceId === instanceId);
+        if (!instance || instance.hasChildProcesses) {
+            this._taskTerminals.delete(terminalKey);
+            return undefined;
+        }
+        return instance;
+    }
+    _getTasksJsonUri(session, target) {
+        if (target === "workspace") {
+            const folder = session.worktree ?? session.repository;
+            return folder ? joinPath(folder, ".vscode", "tasks.json") : undefined;
+        }
+        return joinPath(dirname(this._preferencesService.userSettingsResource), "tasks.json");
+    }
+    async _readTasksJson(uri) {
+        try {
+            const content = await this._fileService.readFile(uri);
+            return parse(( content.value.toString()));
+        } catch {
+            return {};
+        }
+    }
+    async _readAllTasks(session) {
+        const result = [];
+        const workspaceUri = this._getTasksJsonUri(session, "workspace");
+        if (workspaceUri) {
+            const workspaceJson = await this._readTasksJson(workspaceUri);
+            if (workspaceJson.tasks) {
+                result.push(...workspaceJson.tasks.filter(t => this._isSupportedTask(t)));
+            }
+        }
+        const userUri = this._getTasksJsonUri(session, "user");
+        if (userUri) {
+            const userJson = await this._readTasksJson(userUri);
+            if (userJson.tasks) {
+                result.push(...userJson.tasks.filter(t => this._isSupportedTask(t)));
+            }
+        }
+        return result;
+    }
+    _isSupportedTask(task) {
+        return !!task.type && ( SessionsConfigurationService_1._SUPPORTED_TASK_TYPES.has(task.type));
+    }
+    _resolveCommand(task) {
+        if (task.type === "npm") {
+            if (!task.script) {
+                return undefined;
+            }
+            const base = task.path ? `npm --prefix ${task.path} run ${task.script}` : `npm run ${task.script}`;
+            return this._appendArgs(base, task.args);
+        }
+        let command;
+        let platformArgs;
+        if (isWindows && task.windows?.command) {
+            command = task.windows.command;
+            platformArgs = task.windows.args;
+        } else if (isMacintosh && task.osx?.command) {
+            command = task.osx.command;
+            platformArgs = task.osx.args;
+        } else if (!isWindows && !isMacintosh && task.linux?.command) {
+            command = task.linux.command;
+            platformArgs = task.linux.args;
+        } else {
+            command = task.command;
+        }
+        const args = platformArgs ?? task.args;
+        return this._appendArgs(command, args);
+    }
+    _appendArgs(command, args) {
+        if (!command) {
+            return undefined;
+        }
+        if (!args || args.length === 0) {
+            return command;
+        }
+        const resolvedArgs = ( args.map(a => CommandString.value(a))).join(" ");
+        return `${command} ${resolvedArgs}`;
+    }
+    _ensureFileWatch(folder) {
+        const tasksUri = joinPath(folder, ".vscode", "tasks.json");
+        if (this._watchedResource && ( this._watchedResource.toString()) === ( tasksUri.toString())) {
+            return;
+        }
+        this._watchedResource = tasksUri;
+        const disposables = ( new DisposableStore());
+        disposables.add(this._fileService.watch(tasksUri));
+        disposables.add(this._fileService.onDidFilesChange(e => {
+            if (e.affects(tasksUri)) {
+                this._refreshSessionTasks(folder);
+            }
+        }));
+        this._fileWatcher.value = disposables;
+    }
+    async _refreshSessionTasks(folder) {
+        if (!folder) {
+            transaction(tx => this._sessionTasks.set([], tx));
+            return;
+        }
+        const tasksUri = joinPath(folder, ".vscode", "tasks.json");
+        const tasksJson = await this._readTasksJson(tasksUri);
+        const sessionTasks = (tasksJson.tasks ?? []).filter(t => t.inSessions && this._isSupportedTask(t));
+        const userUri = joinPath(dirname(this._preferencesService.userSettingsResource), "tasks.json");
+        const userJson = await this._readTasksJson(userUri);
+        const userSessionTasks = (userJson.tasks ?? []).filter(t => t.inSessions && this._isSupportedTask(t));
+        transaction(tx => this._sessionTasks.set([...sessionTasks, ...userSessionTasks], tx));
+    }
+    async _commitTasksFile(session) {
+        const worktree = session.worktree;
+        if (!worktree) {
+            return;
+        }
+        const tasksUri = joinPath(worktree, ".vscode", "tasks.json");
+        await this._sessionsManagementService.commitWorktreeFiles(session, [tasksUri]);
+    }
+    _loadLastRunTaskLabels() {
+        const raw = this._storageService.get(
+            SessionsConfigurationService_1._LAST_RUN_TASK_LABELS_KEY,
+            StorageScope.APPLICATION
+        );
+        if (raw) {
+            try {
+                return ( new Map(Object.entries(JSON.parse(raw))));
+            } catch {}
+        }
+        return ( new Map());
+    }
+    _saveLastRunTaskLabels() {
+        this._storageService.store(
+            SessionsConfigurationService_1._LAST_RUN_TASK_LABELS_KEY,
+            JSON.stringify(Object.fromEntries(this._lastRunTaskLabels)),
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
+    }
+};
+SessionsConfigurationService = SessionsConfigurationService_1 = ( __decorate([( __param(0, IFileService)), ( __param(1, IJSONEditingService)), ( __param(2, IPreferencesService)), ( __param(3, ITerminalService)), ( __param(4, ISessionsManagementService)), ( __param(5, IStorageService))], SessionsConfigurationService));
+
+export { SessionsConfigurationService };

package/vscode/src/vs/sessions/contrib/fileTreeView/browser/githubFileSystemProvider.d.ts

@@ -0,0 +1,67 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { FileSystemProviderCapabilities, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IFileChange } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+export declare const GITHUB_REMOTE_FILE_SCHEME = "github-remote-file";
+/**
+ * Derives a display name from a github-remote-file URI.
+ * Returns "repo (branch)" or just "repo" when on HEAD.
+ */
+export declare function getGitHubRemoteFileDisplayName(uri: URI): string | undefined;
+/**
+ * A readonly virtual filesystem provider backed by the GitHub REST API.
+ *
+ * URI format: github-remote-file://github/{owner}/{repo}/{ref}/{path...}
+ *
+ * For example: github-remote-file://github/microsoft/vscode/main/src/vs/base/common/uri.ts
+ *
+ * This provider fetches the full recursive tree from the GitHub Trees API on first
+ * access and caches it. Individual file contents are fetched on demand via the
+ * Blobs API.
+ */
+export declare class GitHubFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    private readonly requestService;
+    private readonly authenticationService;
+    private readonly logService;
+    private readonly _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    readonly capabilities: FileSystemProviderCapabilities;
+    private readonly _onDidChangeFile;
+    readonly onDidChangeFile: Event<readonly IFileChange[]>;
+    /** Cache keyed by "owner/repo/ref" */
+    private readonly treeCache;
+    /** Negative cache for refs that returned 404, keyed by "owner/repo/ref" */
+    private readonly notFoundCache;
+    /** In-flight fetch promises keyed by "owner/repo/ref" to deduplicate concurrent requests */
+    private readonly pendingFetches;
+    /** Cache TTL - 5 minutes */
+    private static readonly CACHE_TTL_MS;
+    /** Negative cache TTL - 1 minute */
+    private static readonly NOT_FOUND_CACHE_TTL_MS;
+    constructor(requestService: IRequestService, authenticationService: IAuthenticationService, logService: ILogService);
+    /**
+     * Parse a github-remote-file URI into its components.
+     * Format: github-remote-file://github/{owner}/{repo}/{ref}/{path...}
+     */
+    private parseUri;
+    private getCacheKey;
+    private getAuthToken;
+    private fetchTree;
+    private doFetchTree;
+    stat(resource: URI): Promise<IStat>;
+    readdir(resource: URI): Promise<[
+        string,
+        FileType
+    ][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    watch(): IDisposable;
+    writeFile(_resource: URI, _content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
+    mkdir(_resource: URI): Promise<void>;
+    delete(_resource: URI, _opts: IFileDeleteOptions): Promise<void>;
+    rename(_from: URI, _to: URI, _opts: IFileOverwriteOptions): Promise<void>;
+    invalidateCache(owner: string, repo: string, ref: string): void;
+    dispose(): void;
+}