@codingame/monaco-vscode-chat-service-override 31.0.0 → 32.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.js

@@ -0,0 +1,167 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+
+class PlanReviewFeedbackService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._registrations = ( new Map());
+        this._onDidChangeFeedback = this._register(( new Emitter()));
+        this.onDidChangeFeedback = this._onDidChangeFeedback.event;
+        this._onDidChangeNavigation = this._register(( new Emitter()));
+        this.onDidChangeNavigation = this._onDidChangeNavigation.event;
+        this._onDidChangeRegistrations = this._register(( new Emitter()));
+        this.onDidChangeRegistrations = this._onDidChangeRegistrations.event;
+    }
+    registerPlanReview(planUri, onSubmit) {
+        const key = ( planUri.toString());
+        this._registrations.set(key, {
+            onSubmit,
+            items: [],
+            navigationAnchor: undefined
+        });
+        this._onDidChangeRegistrations.fire();
+        return toDisposable(() => {
+            this._registrations.delete(key);
+            this._onDidChangeRegistrations.fire();
+        });
+    }
+    isActivePlanReview(uri) {
+        return ( this._registrations.has(( uri.toString())));
+    }
+    addFeedback(planUri, line, column, text) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration) {
+            return "";
+        }
+        const id = generateUuid();
+        registration.items.push({
+            id,
+            line,
+            column,
+            text
+        });
+        registration.items.sort((a, b) => a.line - b.line || a.column - b.column);
+        this._onDidChangeFeedback.fire(planUri);
+        return id;
+    }
+    removeFeedback(planUri, feedbackId) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration) {
+            return;
+        }
+        const idx = registration.items.findIndex(item => item.id === feedbackId);
+        if (idx >= 0) {
+            registration.items.splice(idx, 1);
+            this._onDidChangeFeedback.fire(planUri);
+        }
+    }
+    updateFeedback(planUri, feedbackId, newText) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration) {
+            return;
+        }
+        const idx = registration.items.findIndex(item => item.id === feedbackId);
+        if (idx >= 0) {
+            const old = registration.items[idx];
+            registration.items[idx] = {
+                id: old.id,
+                line: old.line,
+                column: old.column,
+                text: newText
+            };
+            this._onDidChangeFeedback.fire(planUri);
+        }
+    }
+    getFeedback(planUri) {
+        const key = ( planUri.toString());
+        return this._registrations.get(key)?.items ?? [];
+    }
+    clearFeedback(planUri) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration || registration.items.length === 0) {
+            return;
+        }
+        registration.items.length = 0;
+        registration.navigationAnchor = undefined;
+        this._onDidChangeFeedback.fire(planUri);
+    }
+    getNextFeedback(planUri, next) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration || registration.items.length === 0) {
+            return undefined;
+        }
+        const items = registration.items;
+        const anchorIdx = registration.navigationAnchor ? items.findIndex(item => item.id === registration.navigationAnchor) : -1;
+        let targetIdx;
+        if (anchorIdx === -1) {
+            targetIdx = next ? 0 : items.length - 1;
+        } else {
+            targetIdx = next ? (anchorIdx + 1) % items.length : (anchorIdx - 1 + items.length) % items.length;
+        }
+        const target = items[targetIdx];
+        this.setNavigationAnchor(planUri, target.id);
+        return target;
+    }
+    getNavigationBearing(planUri) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration) {
+            return {
+                activeIdx: -1,
+                totalCount: 0
+            };
+        }
+        const totalCount = registration.items.length;
+        if (!registration.navigationAnchor) {
+            return {
+                activeIdx: -1,
+                totalCount
+            };
+        }
+        const activeIdx = registration.items.findIndex(item => item.id === registration.navigationAnchor);
+        return {
+            activeIdx,
+            totalCount
+        };
+    }
+    setNavigationAnchor(planUri, itemId) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (registration) {
+            registration.navigationAnchor = itemId;
+            this._onDidChangeNavigation.fire(planUri);
+        }
+    }
+    submitAllFeedback(planUri) {
+        const key = ( planUri.toString());
+        const registration = this._registrations.get(key);
+        if (!registration || registration.items.length === 0) {
+            return;
+        }
+        const formatted = this._formatFeedback(registration.items);
+        registration.onSubmit({
+            rejected: false,
+            feedback: formatted
+        });
+    }
+    _formatFeedback(items) {
+        const parts = ["Here's the feedback:"];
+        for (const item of items) {
+            if (item.column > 1) {
+                parts.push(`Line ${item.line}: Column ${item.column}: ${item.text}`);
+            } else {
+                parts.push(`Line ${item.line}: ${item.text}`);
+            }
+        }
+        return parts.join("\n");
+    }
+}
+
+export { PlanReviewFeedbackService };

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

@@ -1,18 +1,60 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
 import { IPluginGitService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginGitService.service";
 /**
- * Stub implementation of {@link IPluginGitService} that throws on
- * every call. On desktop the native implementation is registered instead;
- * this exists only so the browser layer has a default registration.
+ * Browser implementation of {@link IPluginGitService}.
+ *
+ * `git` is not available in the browser, so plugin contents are reconstructed
+ * from the GitHub REST API: `/git/trees/{sha}?recursive=1` for the listing and
+ * `/git/blobs/{blob_sha}` for each file's bytes. Both live on `api.github.com`,
+ * which is the only GitHub host that handles CORS with auth headers — the
+ * `/tarball/` endpoint redirects to `codeload.github.com` (no CORS) and
+ * `raw.githubusercontent.com` rejects the OPTIONS preflight forced by
+ * `Authorization: Bearer`.
+ *
+ * Only HTTPS GitHub clone URLs are supported; everything else throws an
+ * actionable localized error pointing at desktop or a remote agent host.
+ *
+ * Per-target metadata is persisted via {@link IStorageService} so `revParse`
+ * answers locally, `pull()` skips the re-download when the upstream SHA has
+ * not moved, and the persisted SHA feeds `CustomizationRef.nonce` for AHP
+ * dedupe.
  */
 export declare class BrowserPluginGitCommandService implements IPluginGitService {
+    private readonly _fileService;
+    private readonly _logService;
+    private readonly _requestService;
+    private readonly _storageService;
+    private readonly _authenticationService;
     readonly _serviceBrand: undefined;
-    cloneRepository(_cloneUrl: string, _targetDir: URI, _ref?: string, _token?: CancellationToken): Promise<void>;
-    pull(_repoDir: URI, _token?: CancellationToken): Promise<boolean>;
-    checkout(_repoDir: URI, _treeish: string, _detached?: boolean, _token?: CancellationToken): Promise<void>;
-    revParse(_repoDir: URI, _ref: string): Promise<string>;
+    private _cache;
+    constructor(_fileService: IFileService, _logService: ILogService, _requestService: IRequestService, _storageService: IStorageService, _authenticationService: IAuthenticationService);
+    cloneRepository(cloneUrl: string, targetDir: URI, ref?: string, token?: CancellationToken): Promise<void>;
+    pull(repoDir: URI, token?: CancellationToken): Promise<boolean>;
+    checkout(repoDir: URI, treeish: string, _detached?: boolean, token?: CancellationToken): Promise<void>;
+    revParse(repoDir: URI, ref: string): Promise<string>;
     fetch(_repoDir: URI, _token?: CancellationToken): Promise<void>;
     fetchRepository(_repoDir: URI, _token?: CancellationToken): Promise<void>;
     revListCount(_repoDir: URI, _fromRef: string, _toRef: string): Promise<number>;
+    private _parseOrThrow;
+    private _maybeLogTransientError;
+    /**
+     * Best-effort silent lookup of an existing GitHub session token. Returns
+     * `undefined` when no session is available; callers fall back to anonymous,
+     * which still works for public repos. Prefers a `repo`-scoped session when
+     * multiple are present (e.g. EMU + personal).
+     */
+    private _lookupGitHubToken;
+    private _requestGitHubToken;
+    private _cacheKey;
+    private _pruneStaleEntries;
+    private _ensureCacheLoaded;
+    private _getCacheEntry;
+    private _setCacheEntry;
+    private _persistCache;
 }

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

@@ -1,31 +1,327 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { getComparisonKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.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 { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { resolveGitHubRefToSha, fetchAndExtractGitHubRepo, GitHubAuthRequiredError, parseGitHubCloneUrl, GitHubRateLimitError } from './githubRepoFetcher.js';
 
-function notSupported() {
-    throw ( new Error(( localize(6488, "Agent plugins are not available in this environment"))));
-}
-class BrowserPluginGitCommandService {
-    async cloneRepository(_cloneUrl, _targetDir, _ref, _token) {
-        notSupported();
+const BROWSER_CACHE_STORAGE_KEY = "chat.plugins.browserCache.v1";
+let BrowserPluginGitCommandService = class BrowserPluginGitCommandService {
+    constructor(
+        _fileService,
+        _logService,
+        _requestService,
+        _storageService,
+        _authenticationService
+    ) {
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._requestService = _requestService;
+        this._storageService = _storageService;
+        this._authenticationService = _authenticationService;
     }
-    async pull(_repoDir, _token) {
-        notSupported();
+    async cloneRepository(cloneUrl, targetDir, ref, token) {
+        const repo = this._parseOrThrow(cloneUrl);
+        const cancel = token ?? CancellationToken.None;
+        const cloneWithToken = async authToken => {
+            const sha = await resolveGitHubRefToSha(this._requestService, repo, ref, authToken, cancel);
+            await fetchAndExtractGitHubRepo(
+                this._requestService,
+                this._fileService,
+                this._logService,
+                repo,
+                sha,
+                targetDir,
+                authToken,
+                cancel
+            );
+            this._setCacheEntry(targetDir, {
+                owner: repo.owner,
+                repo: repo.repo,
+                ref,
+                sha,
+                fetchedAt: Date.now()
+            });
+        };
+        const initialAuthToken = await this._lookupGitHubToken();
+        const attempts = [async () => initialAuthToken];
+        if (initialAuthToken) {
+            attempts.push(async () => undefined);
+        }
+        attempts.push(() => this._requestGitHubToken(repo));
+        let lastErr;
+        for (const getToken of attempts) {
+            if (cancel.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            try {
+                await cloneWithToken(await getToken());
+                return;
+            } catch (err) {
+                lastErr = err;
+                this._maybeLogTransientError(err, repo);
+                if (!(err instanceof GitHubAuthRequiredError)) {
+                    throw err;
+                }
+            }
+        }
+        if (lastErr instanceof GitHubAuthRequiredError) {
+            throw ( new Error(( localize(
+                6730,
+                "GitHub authentication is required to install '{0}'. Sign in with an account that has access to this repository, then try again.",
+                `${repo.owner}/${repo.repo}`
+            ))));
+        }
+        throw lastErr;
     }
-    async checkout(_repoDir, _treeish, _detached, _token) {
-        notSupported();
+    async pull(repoDir, token) {
+        const entry = this._getCacheEntry(repoDir);
+        if (!entry) {
+            throw ( new Error(`Cannot pull plugin: no cached metadata for ${( repoDir.toString())}`));
+        }
+        const cancel = token ?? CancellationToken.None;
+        const authToken = await this._lookupGitHubToken();
+        const repo = {
+            owner: entry.owner,
+            repo: entry.repo
+        };
+        try {
+            const newSha = await resolveGitHubRefToSha(this._requestService, repo, entry.ref, authToken, cancel);
+            if (newSha === entry.sha) {
+                return false;
+            }
+            await fetchAndExtractGitHubRepo(
+                this._requestService,
+                this._fileService,
+                this._logService,
+                repo,
+                newSha,
+                repoDir,
+                authToken,
+                cancel
+            );
+            this._setCacheEntry(repoDir, {
+                ...entry,
+                sha: newSha,
+                fetchedAt: Date.now()
+            });
+            return true;
+        } catch (err) {
+            this._maybeLogTransientError(err, repo);
+            throw err;
+        }
     }
-    async revParse(_repoDir, _ref) {
-        notSupported();
+    async checkout(repoDir, treeish, _detached, token) {
+        const entry = this._getCacheEntry(repoDir);
+        if (!entry) {
+            throw ( new Error(`Cannot checkout plugin: no cached metadata for ${( repoDir.toString())}`));
+        }
+        const cancel = token ?? CancellationToken.None;
+        const authToken = await this._lookupGitHubToken();
+        const repo = {
+            owner: entry.owner,
+            repo: entry.repo
+        };
+        const requestedRef = treeish.trim();
+        const isFullSha = /^[0-9a-f]{40}$/i.test(requestedRef);
+        const requestedSha = isFullSha ? requestedRef.toLowerCase() : await resolveGitHubRefToSha(this._requestService, repo, requestedRef, authToken, cancel);
+        if (requestedSha === entry.sha.toLowerCase()) {
+            return;
+        }
+        try {
+            await fetchAndExtractGitHubRepo(
+                this._requestService,
+                this._fileService,
+                this._logService,
+                repo,
+                requestedSha,
+                repoDir,
+                authToken,
+                cancel
+            );
+            this._setCacheEntry(repoDir, {
+                ...entry,
+                ref: isFullSha ? entry.ref : requestedRef,
+                sha: requestedSha,
+                fetchedAt: Date.now()
+            });
+        } catch (err) {
+            this._maybeLogTransientError(err, repo);
+            throw err;
+        }
     }
-    async fetch(_repoDir, _token) {
-        notSupported();
-    }
-    async fetchRepository(_repoDir, _token) {
-        notSupported();
+    async revParse(repoDir, ref) {
+        const entry = this._getCacheEntry(repoDir);
+        if (!entry) {
+            throw ( new Error(`Cannot resolve ref: no cached metadata for ${( repoDir.toString())}`));
+        }
+        const trimmed = ref.trim();
+        const isFullSha = /^[0-9a-f]{40}$/i.test(trimmed);
+        if (isFullSha && trimmed.toLowerCase() !== entry.sha.toLowerCase()) {
+            throw ( new Error(
+                `Cannot resolve ref '${ref}' in tree-cached plugin: only HEAD/${entry.sha} is materialised`
+            ));
+        }
+        return entry.sha;
     }
+    async fetch(_repoDir, _token) {}
+    async fetchRepository(_repoDir, _token) {}
     async revListCount(_repoDir, _fromRef, _toRef) {
-        notSupported();
+        return 0;
+    }
+    _parseOrThrow(cloneUrl) {
+        const parsed = parseGitHubCloneUrl(cloneUrl);
+        if (!parsed) {
+            throw ( new Error(( localize(
+                6731,
+                "Agent plugins in the browser can only be installed from GitHub HTTPS URLs. To install '{0}', use the desktop application or connect to a remote agent host.",
+                cloneUrl
+            ))));
+        }
+        return parsed;
+    }
+    _maybeLogTransientError(err, repo) {
+        if (err instanceof GitHubAuthRequiredError) {
+            this._logService.warn(
+                `[BrowserPluginGitCommandService] GitHub auth required for ${repo.owner}/${repo.repo}: ${err.message}`
+            );
+        } else if (err instanceof GitHubRateLimitError) {
+            const wait = err.retryAfterSeconds !== undefined ? ` (retry after ${err.retryAfterSeconds}s)` : "";
+            this._logService.warn(
+                `[BrowserPluginGitCommandService] GitHub rate limit hit for ${repo.owner}/${repo.repo}${wait}: ${err.message}`
+            );
+        } else if (err instanceof Error) {
+            const cause = err.cause instanceof Error ? ` (cause: ${err.cause.name}: ${err.cause.message})` : "";
+            this._logService.error(
+                `[BrowserPluginGitCommandService] Clone failed for ${repo.owner}/${repo.repo}: ${err.message}${cause}`
+            );
+        }
+    }
+    async _lookupGitHubToken() {
+        try {
+            const sessions = await this._authenticationService.getSessions("github", [], {
+                silent: true
+            });
+            if (sessions.length === 0) {
+                return undefined;
+            }
+            const repoScopeSession = sessions.find(session => session.scopes.includes("repo"));
+            return repoScopeSession?.accessToken ?? sessions[0].accessToken;
+        } catch (err) {
+            this._logService.trace(
+                "[BrowserPluginGitCommandService] Silent GitHub session lookup failed:",
+                err
+            );
+            return undefined;
+        }
+    }
+    async _requestGitHubToken(repo) {
+        try {
+            const session = await this._authenticationService.createSession("github", ["repo"], {
+                activateImmediate: true
+            });
+            return session.accessToken;
+        } catch (err) {
+            this._logService.trace("[BrowserPluginGitCommandService] GitHub session request failed:", err);
+            throw ( new Error(( localize(
+                6732,
+                "Sign in to GitHub with an account that has access to '{0}' to install this plugin.",
+                `${repo.owner}/${repo.repo}`
+            ))));
+        }
+    }
+    _cacheKey(targetDir) {
+        return getComparisonKey(targetDir, true);
+    }
+    async _pruneStaleEntries(cache, knownDirs) {
+        const removed = [];
+        await Promise.all(Array.from(knownDirs, async ([key, uri]) => {
+            try {
+                if (!(await this._fileService.exists(uri))) {
+                    removed.push(key);
+                }
+            } catch {}
+        }));
+        if (removed.length === 0) {
+            return;
+        }
+        for (const key of removed) {
+            cache.delete(key);
+        }
+        this._logService.trace(
+            `[BrowserPluginGitCommandService] Pruned ${removed.length} stale cache entries`
+        );
+        this._persistCache();
+    }
+    _ensureCacheLoaded() {
+        if (this._cache) {
+            return this._cache;
+        }
+        const cache = ( new Map());
+        const stored = this._storageService.getObject(BROWSER_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+        const knownDirs = ( new Map());
+        if (stored) {
+            for (const [key, entry] of Object.entries(stored)) {
+                if (entry && typeof entry.sha === "string" && typeof entry.owner === "string" && typeof entry.repo === "string") {
+                    cache.set(key, {
+                        owner: entry.owner,
+                        repo: entry.repo,
+                        ref: typeof entry.ref === "string" ? entry.ref : undefined,
+                        sha: entry.sha,
+                        fetchedAt: typeof entry.fetchedAt === "number" ? entry.fetchedAt : 0
+                    });
+                    try {
+                        knownDirs.set(key, ( URI.parse(key)));
+                    } catch {
+                        cache.delete(key);
+                    }
+                }
+            }
+        }
+        this._cache = cache;
+        if (knownDirs.size > 0) {
+            this._pruneStaleEntries(cache, knownDirs).catch(err => {
+                this._logService.trace("[BrowserPluginGitCommandService] Cache prune failed:", err);
+            });
+        }
+        return cache;
+    }
+    _getCacheEntry(targetDir) {
+        return this._ensureCacheLoaded().get(this._cacheKey(targetDir));
+    }
+    _setCacheEntry(targetDir, entry) {
+        const cache = this._ensureCacheLoaded();
+        cache.set(this._cacheKey(targetDir), entry);
+        this._persistCache();
+    }
+    _persistCache() {
+        if (!this._cache) {
+            return;
+        }
+        const serialized = {};
+        for (const [key, entry] of this._cache) {
+            serialized[key] = entry;
+        }
+        if (( Object.keys(serialized)).length === 0) {
+            this._storageService.remove(BROWSER_CACHE_STORAGE_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        this._storageService.store(
+            BROWSER_CACHE_STORAGE_KEY,
+            JSON.stringify(serialized),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
     }
-}
+};
+BrowserPluginGitCommandService = ( __decorate([( __param(0, IFileService)), ( __param(1, ILogService)), ( __param(2, IRequestService)), ( __param(3, IStorageService)), ( __param(4, IAuthenticationService))], BrowserPluginGitCommandService));
 
 export { BrowserPluginGitCommandService };