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

package/vscode/src/vs/workbench/contrib/chat/browser/chatRepoInfo.js

@@ -0,0 +1,548 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { relativePath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { linesDiffComputers } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputers';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ISCMService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+const MAX_CHANGES = 100;
+const MAX_DIFFS_SIZE_BYTES = 900 * 1024;
+const MAX_SESSIONS_WITH_FULL_DIFFS = 5;
+const RemoteMatcher = /^\s*url\s*=\s*(.+\S)\s*$/mg;
+function getRawRemotes(text) {
+    const remotes = [];
+    let match;
+    while (match = RemoteMatcher.exec(text)) {
+        remotes.push(match[1]);
+    }
+    return remotes;
+}
+function getRemoteHost(remoteUrl) {
+    try {
+        const url = ( new URL(remoteUrl));
+        return url.hostname.toLowerCase();
+    } catch {
+        const atIndex = remoteUrl.lastIndexOf("@");
+        const hostAndPath = atIndex !== -1 ? remoteUrl.slice(atIndex + 1) : remoteUrl;
+        const colonIndex = hostAndPath.indexOf(":");
+        if (colonIndex !== -1) {
+            const host = hostAndPath.slice(0, colonIndex);
+            return host ? host.toLowerCase() : undefined;
+        }
+        const slashIndex = hostAndPath.indexOf("/");
+        if (slashIndex !== -1) {
+            const host = hostAndPath.slice(0, slashIndex);
+            return host ? host.toLowerCase() : undefined;
+        }
+        return undefined;
+    }
+}
+function determineChangeType(resource, groupId) {
+    const contextValue = resource.contextValue?.toLowerCase() ?? "";
+    const groupIdLower = groupId.toLowerCase();
+    if (contextValue.includes("untracked") || contextValue.includes("add")) {
+        return "added";
+    }
+    if (contextValue.includes("delete")) {
+        return "deleted";
+    }
+    if (contextValue.includes("rename")) {
+        return "renamed";
+    }
+    if (groupIdLower.includes("untracked")) {
+        return "added";
+    }
+    if (resource.decorations.strikeThrough) {
+        return "deleted";
+    }
+    if (!resource.multiDiffEditorOriginalUri) {
+        return "added";
+    }
+    return "modified";
+}
+async function generateUnifiedDiff(fileService, relPath, originalUri, modifiedUri, changeType) {
+    try {
+        let originalContent = "";
+        let modifiedContent = "";
+        if (originalUri && changeType !== "added") {
+            try {
+                const originalFile = await fileService.readFile(originalUri);
+                originalContent = ( originalFile.value.toString());
+            } catch {
+                if (changeType === "modified") {
+                    return undefined;
+                }
+            }
+        }
+        if (changeType !== "deleted") {
+            try {
+                const modifiedFile = await fileService.readFile(modifiedUri);
+                modifiedContent = ( modifiedFile.value.toString());
+            } catch {
+                return undefined;
+            }
+        }
+        const originalLines = originalContent.split("\n");
+        const modifiedLines = modifiedContent.split("\n");
+        const originalEndsWithNewline = originalContent.length > 0 && originalContent.endsWith("\n");
+        const modifiedEndsWithNewline = modifiedContent.length > 0 && modifiedContent.endsWith("\n");
+        if (originalEndsWithNewline && originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+            originalLines.pop();
+        }
+        if (modifiedEndsWithNewline && modifiedLines.length > 0 && modifiedLines[modifiedLines.length - 1] === "") {
+            modifiedLines.pop();
+        }
+        const diffLines = [];
+        const aPath = changeType === "added" ? "/dev/null" : `a/${relPath}`;
+        const bPath = changeType === "deleted" ? "/dev/null" : `b/${relPath}`;
+        diffLines.push(`--- ${aPath}`);
+        diffLines.push(`+++ ${bPath}`);
+        if (changeType === "added") {
+            if (modifiedLines.length > 0) {
+                diffLines.push(`@@ -0,0 +1,${modifiedLines.length} @@`);
+                for (const line of modifiedLines) {
+                    diffLines.push(`+${line}`);
+                }
+                if (!modifiedEndsWithNewline) {
+                    diffLines.push("\");
+                }
+            }
+        } else if (changeType === "deleted") {
+            if (originalLines.length > 0) {
+                diffLines.push(`@@ -1,${originalLines.length} +0,0 @@`);
+                for (const line of originalLines) {
+                    diffLines.push(`-${line}`);
+                }
+                if (!originalEndsWithNewline) {
+                    diffLines.push("\");
+                }
+            }
+        } else {
+            const hunks = computeDiffHunks(
+                originalLines,
+                modifiedLines,
+                originalEndsWithNewline,
+                modifiedEndsWithNewline
+            );
+            for (const hunk of hunks) {
+                diffLines.push(hunk);
+            }
+        }
+        return diffLines.join("\n");
+    } catch {
+        return undefined;
+    }
+}
+function computeDiffHunks(
+    originalLines,
+    modifiedLines,
+    originalEndsWithNewline,
+    modifiedEndsWithNewline
+) {
+    const contextSize = 3;
+    const result = [];
+    const diffComputer = linesDiffComputers.getDefault();
+    const diffResult = diffComputer.computeDiff(originalLines, modifiedLines, {
+        ignoreTrimWhitespace: false,
+        maxComputationTimeMs: 1000,
+        computeMoves: false
+    });
+    if (diffResult.changes.length === 0) {
+        return result;
+    }
+    const hunkGroups = [];
+    let currentGroup = [];
+    for (const change of diffResult.changes) {
+        if (currentGroup.length === 0) {
+            currentGroup.push(change);
+        } else {
+            const lastChange = currentGroup[currentGroup.length - 1];
+            const lastContextEnd = lastChange.original.endLineNumberExclusive - 1 + contextSize;
+            const currentContextStart = change.original.startLineNumber - contextSize;
+            if (currentContextStart <= lastContextEnd + 1) {
+                currentGroup.push(change);
+            } else {
+                hunkGroups.push(currentGroup);
+                currentGroup = [change];
+            }
+        }
+    }
+    if (currentGroup.length > 0) {
+        hunkGroups.push(currentGroup);
+    }
+    for (const group of hunkGroups) {
+        const firstChange = group[0];
+        const lastChange = group[group.length - 1];
+        const hunkOrigStart = Math.max(1, firstChange.original.startLineNumber - contextSize);
+        const hunkOrigEnd = Math.min(
+            originalLines.length,
+            lastChange.original.endLineNumberExclusive - 1 + contextSize
+        );
+        const hunkModStart = Math.max(1, firstChange.modified.startLineNumber - contextSize);
+        const hunkLines = [];
+        let lastOriginalLineIndex = -1;
+        let lastModifiedLineIndex = -1;
+        let origLineNum = hunkOrigStart;
+        let origCount = 0;
+        let modCount = 0;
+        for (const change of group) {
+            const origStart = change.original.startLineNumber;
+            const origEnd = change.original.endLineNumberExclusive;
+            const modStart = change.modified.startLineNumber;
+            const modEnd = change.modified.endLineNumberExclusive;
+            while (origLineNum < origStart) {
+                const idx = hunkLines.length;
+                hunkLines.push(` ${originalLines[origLineNum - 1]}`);
+                if (origLineNum === originalLines.length) {
+                    lastOriginalLineIndex = idx;
+                }
+                const modLineNum = hunkModStart + modCount;
+                if (modLineNum === modifiedLines.length) {
+                    lastModifiedLineIndex = idx;
+                }
+                origLineNum++;
+                origCount++;
+                modCount++;
+            }
+            for (let i = origStart; i < origEnd; i++) {
+                const idx = hunkLines.length;
+                hunkLines.push(`-${originalLines[i - 1]}`);
+                if (i === originalLines.length) {
+                    lastOriginalLineIndex = idx;
+                }
+                origLineNum++;
+                origCount++;
+            }
+            for (let i = modStart; i < modEnd; i++) {
+                const idx = hunkLines.length;
+                hunkLines.push(`+${modifiedLines[i - 1]}`);
+                if (i === modifiedLines.length) {
+                    lastModifiedLineIndex = idx;
+                }
+                modCount++;
+            }
+        }
+        while (origLineNum <= hunkOrigEnd) {
+            const idx = hunkLines.length;
+            hunkLines.push(` ${originalLines[origLineNum - 1]}`);
+            if (origLineNum === originalLines.length) {
+                lastOriginalLineIndex = idx;
+            }
+            const modLineNum = hunkModStart + modCount;
+            if (modLineNum === modifiedLines.length) {
+                lastModifiedLineIndex = idx;
+            }
+            origLineNum++;
+            origCount++;
+            modCount++;
+        }
+        result.push(`@@ -${hunkOrigStart},${origCount} +${hunkModStart},${modCount} @@`);
+        for (let i = 0; i < hunkLines.length; i++) {
+            result.push(hunkLines[i]);
+            const isLastOriginal = i === lastOriginalLineIndex;
+            const isLastModified = i === lastModifiedLineIndex;
+            if (isLastOriginal && isLastModified) {
+                if (!originalEndsWithNewline || !modifiedEndsWithNewline) {
+                    result.push("\");
+                }
+            } else if (isLastOriginal && !originalEndsWithNewline) {
+                result.push("\");
+            } else if (isLastModified && !modifiedEndsWithNewline) {
+                result.push("\");
+            }
+        }
+    }
+    return result;
+}
+async function captureRepoInfo(scmService, fileService) {
+    const repositories = [...scmService.repositories];
+    if (repositories.length === 0) {
+        return undefined;
+    }
+    const repository = repositories[0];
+    const rootUri = repository.provider.rootUri;
+    if (!rootUri) {
+        return undefined;
+    }
+    let hasGit = false;
+    try {
+        const gitDirUri = rootUri.with({
+            path: `${rootUri.path}/.git`
+        });
+        hasGit = await fileService.exists(gitDirUri);
+    } catch {}
+    if (!hasGit) {
+        return {
+            workspaceType: "plain-folder",
+            syncStatus: "no-git",
+            diffs: undefined
+        };
+    }
+    let remoteUrl;
+    try {
+        const gitConfigUri = rootUri.with({
+            path: `${rootUri.path}/.git/config`
+        });
+        const exists = await fileService.exists(gitConfigUri);
+        if (exists) {
+            const content = await fileService.readFile(gitConfigUri);
+            const remotes = getRawRemotes(( content.value.toString()));
+            remoteUrl = remotes[0];
+        }
+    } catch {}
+    let localBranch;
+    let localHeadCommit;
+    let remoteTrackingBranch;
+    let remoteHeadCommit;
+    let remoteBaseBranch;
+    const historyProvider = repository.provider.historyProvider?.get();
+    if (historyProvider) {
+        const historyItemRef = historyProvider.historyItemRef.get();
+        localBranch = historyItemRef?.name;
+        localHeadCommit = historyItemRef?.revision;
+        const historyItemRemoteRef = historyProvider.historyItemRemoteRef.get();
+        if (historyItemRemoteRef) {
+            remoteTrackingBranch = historyItemRemoteRef.name;
+            remoteHeadCommit = historyItemRemoteRef.revision;
+        }
+        const historyItemBaseRef = historyProvider.historyItemBaseRef.get();
+        if (historyItemBaseRef) {
+            remoteBaseBranch = historyItemBaseRef.name;
+        }
+    }
+    let workspaceType;
+    let syncStatus;
+    if (!remoteUrl) {
+        workspaceType = "local-git";
+        syncStatus = "local-only";
+    } else {
+        workspaceType = "remote-git";
+        if (!remoteTrackingBranch) {
+            syncStatus = "unpublished";
+        } else if (localHeadCommit === remoteHeadCommit) {
+            syncStatus = "synced";
+        } else {
+            syncStatus = "unpushed";
+        }
+    }
+    let remoteVendor;
+    if (remoteUrl) {
+        const host = getRemoteHost(remoteUrl);
+        if (host === "github.com") {
+            remoteVendor = "github";
+        } else if (host === "dev.azure.com" || (host && host.endsWith(".visualstudio.com"))) {
+            remoteVendor = "ado";
+        } else {
+            remoteVendor = "other";
+        }
+    }
+    let totalChangeCount = 0;
+    for (const group of repository.provider.groups) {
+        totalChangeCount += group.resources.length;
+    }
+    const baseRepoData = {
+        workspaceType,
+        syncStatus,
+        remoteUrl,
+        remoteVendor,
+        localBranch,
+        remoteTrackingBranch,
+        remoteBaseBranch,
+        localHeadCommit,
+        remoteHeadCommit
+    };
+    if (totalChangeCount === 0) {
+        return {
+            ...baseRepoData,
+            diffs: undefined,
+            diffsStatus: "noChanges",
+            changedFileCount: 0
+        };
+    }
+    if (totalChangeCount > MAX_CHANGES) {
+        return {
+            ...baseRepoData,
+            diffs: undefined,
+            diffsStatus: "tooManyChanges",
+            changedFileCount: totalChangeCount
+        };
+    }
+    const diffs = [];
+    const diffPromises = [];
+    for (const group of repository.provider.groups) {
+        for (const resource of group.resources) {
+            const relPath = relativePath(rootUri, resource.sourceUri) ?? resource.sourceUri.path;
+            const changeType = determineChangeType(resource, group.id);
+            const diffPromise = (async () => {
+                const unifiedDiff = await generateUnifiedDiff(
+                    fileService,
+                    relPath,
+                    resource.multiDiffEditorOriginalUri,
+                    resource.sourceUri,
+                    changeType
+                );
+                return {
+                    relativePath: relPath,
+                    changeType,
+                    status: group.label || group.id,
+                    unifiedDiff
+                };
+            })();
+            diffPromises.push(diffPromise);
+        }
+    }
+    const generatedDiffs = await Promise.all(diffPromises);
+    for (const diff of generatedDiffs) {
+        if (diff) {
+            diffs.push(diff);
+        }
+    }
+    const diffsJson = JSON.stringify(diffs);
+    const diffsSizeBytes = ( new TextEncoder()).encode(diffsJson).length;
+    if (diffsSizeBytes > MAX_DIFFS_SIZE_BYTES) {
+        return {
+            ...baseRepoData,
+            diffs: undefined,
+            diffsStatus: "tooLarge",
+            changedFileCount: totalChangeCount
+        };
+    }
+    return {
+        ...baseRepoData,
+        diffs,
+        diffsStatus: "included",
+        changedFileCount: totalChangeCount
+    };
+}
+let ChatRepoInfoContribution = class ChatRepoInfoContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatRepoInfo";
+    }
+    constructor(
+        chatService,
+        chatEntitlementService,
+        scmService,
+        fileService,
+        logService,
+        configurationService
+    ) {
+        super();
+        this.chatService = chatService;
+        this.chatEntitlementService = chatEntitlementService;
+        this.scmService = scmService;
+        this.fileService = fileService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this._configurationRegistered = false;
+        this.registerConfigurationIfInternal();
+        this._register(this.chatEntitlementService.onDidChangeEntitlement(() => {
+            this.registerConfigurationIfInternal();
+        }));
+        this._register(this.chatService.onDidSubmitRequest(async (
+            {
+                chatSessionResource
+            }
+        ) => {
+            const model = this.chatService.getSession(chatSessionResource);
+            if (!model) {
+                return;
+            }
+            await this.captureAndSetRepoData(model);
+        }));
+    }
+    registerConfigurationIfInternal() {
+        if (this._configurationRegistered) {
+            return;
+        }
+        if (!this.chatEntitlementService.isInternal) {
+            return;
+        }
+        const registry = ( Registry.as(Extensions.Configuration));
+        registry.registerConfiguration({
+            id: "chatRepoInfo",
+            title: ( localize(5471, "Chat Repository Info")),
+            type: "object",
+            properties: {
+                [ChatConfiguration.RepoInfoEnabled]: {
+                    type: "boolean",
+                    description: ( localize(
+                        5472,
+                        "Controls whether repository information (branch, commit, working tree diffs) is captured at the start of chat sessions for internal diagnostics."
+                    )),
+                    default: true
+                }
+            }
+        });
+        this._configurationRegistered = true;
+        this.logService.debug("[ChatRepoInfo] Configuration registered for internal user");
+    }
+    async captureAndSetRepoData(model) {
+        if (!this.chatEntitlementService.isInternal) {
+            return;
+        }
+        if (!this.configurationService.getValue(ChatConfiguration.RepoInfoEnabled)) {
+            return;
+        }
+        if (model.repoData) {
+            return;
+        }
+        try {
+            const repoData = await captureRepoInfo(this.scmService, this.fileService);
+            if (repoData) {
+                model.setRepoData(repoData);
+                if (!repoData.localHeadCommit && repoData.workspaceType !== "plain-folder") {
+                    this.logService.warn(
+                        "[ChatRepoInfo] Captured repo data without commit hash - git history may not be ready"
+                    );
+                }
+                this.trimOldSessionDiffs();
+            } else {
+                this.logService.debug("[ChatRepoInfo] No SCM repository available for chat session");
+            }
+        } catch (error) {
+            this.logService.warn("[ChatRepoInfo] Failed to capture repo info:", error);
+        }
+    }
+    trimOldSessionDiffs() {
+        try {
+            const sessionsWithDiffs = [];
+            for (const model of this.chatService.chatModels.get()) {
+                if (model.repoData?.diffs && model.repoData.diffs.length > 0 && model.repoData.diffsStatus === "included") {
+                    sessionsWithDiffs.push({
+                        model,
+                        timestamp: model.timestamp
+                    });
+                }
+            }
+            sessionsWithDiffs.sort((a, b) => b.timestamp - a.timestamp);
+            for (let i = MAX_SESSIONS_WITH_FULL_DIFFS; i < sessionsWithDiffs.length; i++) {
+                const {
+                    model
+                } = sessionsWithDiffs[i];
+                if (model.repoData) {
+                    const trimmedRepoData = {
+                        ...model.repoData,
+                        diffs: undefined,
+                        diffsStatus: "trimmedForStorage"
+                    };
+                    model.setRepoData(trimmedRepoData);
+                    this.logService.trace(`[ChatRepoInfo] Trimmed diffs from older session: ${( model.sessionResource.toString())}`);
+                }
+            }
+        } catch (error) {
+            this.logService.warn("[ChatRepoInfo] Failed to trim old session diffs:", error);
+        }
+    }
+};
+ChatRepoInfoContribution = ( __decorate([( __param(0, IChatService)), ( __param(1, IChatEntitlementService)), ( __param(2, ISCMService)), ( __param(3, IFileService)), ( __param(4, ILogService)), ( __param(5, IConfigurationService))], ChatRepoInfoContribution));
+
+export { ChatRepoInfoContribution, captureRepoInfo };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetupContributions.d.ts

@@ -34,7 +34,6 @@ export declare class ChatTeardownContribution extends Disposable implements IWor
     private readonly viewDescriptorService;
     private readonly layoutService;
     static readonly ID = "workbench.contrib.chatTeardown";
-    static readonly CHAT_DISABLED_CONFIGURATION_KEY = "chat.disableAIFeatures";
     constructor(chatEntitlementService: ChatEntitlementService, configurationService: IConfigurationService, extensionsWorkbenchService: IExtensionsWorkbenchService, extensionEnablementService: IWorkbenchExtensionEnablementService, viewDescriptorService: IViewDescriptorService, layoutService: IWorkbenchLayoutService);
     private handleChatDisabled;
     private registerListeners;