@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/browser/parts/mobile/contributions/mobileDiffHelpers.js

@@ -0,0 +1,429 @@
+
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { linesDiffComputers } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputers';
+import { tokenizeToString } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/textToHtmlTokenizer';
+
+const EXTENSION_LANGUAGE_MAP = {
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascriptreact",
+    ".ts": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".tsx": "typescriptreact",
+    ".py": "python",
+    ".pyw": "python",
+    ".java": "java",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".go": "go",
+    ".rs": "rust",
+    ".rb": "ruby",
+    ".php": "php",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".json": "json",
+    ".jsonc": "jsonc",
+    ".md": "markdown",
+    ".sh": "shellscript",
+    ".bash": "shellscript",
+    ".zsh": "shellscript",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".xml": "xml",
+    ".sql": "sql",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".r": "r",
+    ".lua": "lua",
+    ".dart": "dart"
+};
+function resolveMobileDiffLanguageId(languageService, diff) {
+    const uri = diff.modifiedURI ?? diff.originalURI;
+    if (!uri) {
+        return "plaintext";
+    }
+    const guessed = languageService.guessLanguageIdByFilepathOrFirstLine(uri);
+    if (guessed && guessed !== "unknown") {
+        return guessed;
+    }
+    const name = basename(uri);
+    const ext = name.includes(".") ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
+    return EXTENSION_LANGUAGE_MAP[ext] ?? "plaintext";
+}
+async function tokenizeFileLines(languageService, text, languageId) {
+    if (!text) {
+        return [""];
+    }
+    const html = await tokenizeToString(languageService, text, languageId);
+    const inner = stripTokenizedWrapper(html);
+    return inner.split("<br/>");
+}
+function stripTokenizedWrapper(html) {
+    const openTag = "<div class=\"monaco-tokenized-source\">";
+    const closeTag = "</div>";
+    if (html.startsWith(openTag) && html.endsWith(closeTag)) {
+        return html.slice(openTag.length, html.length - closeTag.length);
+    }
+    return html;
+}
+function hasMultipleTokenClasses(lines) {
+    for (const line of lines) {
+        if (line && /class="mtk[2-9]|class="mtk[1-9][0-9]/.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+const LANG_FAMILY = {
+    javascript: "js",
+    javascriptreact: "js",
+    typescript: "js",
+    typescriptreact: "js",
+    java: "js",
+    csharp: "js",
+    go: "js",
+    rust: "js",
+    cpp: "js",
+    c: "js",
+    swift: "js",
+    kotlin: "js",
+    dart: "js",
+    php: "js",
+    ruby: "js",
+    python: "python",
+    css: "css",
+    scss: "css",
+    less: "css",
+    html: "html",
+    xml: "html",
+    json: "json",
+    jsonc: "json",
+    shellscript: "shell",
+    powershell: "shell"
+};
+const JS_KEYWORDS = ( new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "let",
+    "new",
+    "null",
+    "of",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "undefined",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "async",
+    "await",
+    "from",
+    "as",
+    "interface",
+    "type",
+    "enum",
+    "declare",
+    "abstract",
+    "override",
+    "readonly",
+    "namespace",
+    "module",
+    "public",
+    "private",
+    "protected"
+]));
+const PY_KEYWORDS = ( new Set([
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+]));
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildSpan(kind, text) {
+    if (kind === "default" || !text) {
+        return escapeHtml(text);
+    }
+    return `<span class="mobile-diff-tok-${kind}">${escapeHtml(text)}</span>`;
+}
+function regexTokenizeLine(line, lang) {
+    const tokens = [];
+    let pos = 0;
+    const len = line.length;
+    while (pos < len) {
+        let matched = false;
+        const commentPfx = lang === "python" ? "#" : lang === "shell" ? "#" : "//";
+        if (line.startsWith(commentPfx, pos) || (lang === "generic" && line.startsWith("#", pos))) {
+            tokens.push({
+                start: pos,
+                end: len,
+                kind: "comment"
+            });
+            pos = len;
+            matched = true;
+        }
+        if (!matched && lang !== "python" && lang !== "shell" && line.startsWith("/*", pos)) {
+            const end = line.indexOf("*/", pos + 2);
+            const tokenEnd = end === -1 ? len : end + 2;
+            tokens.push({
+                start: pos,
+                end: tokenEnd,
+                kind: "comment"
+            });
+            pos = tokenEnd;
+            matched = true;
+        }
+        if (!matched && (lang === "js") && line[pos] === "`") {
+            let i = pos + 1;
+            while (i < len) {
+                if (line[i] === "\\") {
+                    i += 2;
+                    continue;
+                }
+                if (line[i] === "`") {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({
+                start: pos,
+                end: i,
+                kind: "string"
+            });
+            pos = i;
+            matched = true;
+        }
+        if (!matched && (line[pos] === "\"" || line[pos] === "'")) {
+            const q = line[pos];
+            let i = pos + 1;
+            while (i < len) {
+                if (line[i] === "\\") {
+                    i += 2;
+                    continue;
+                }
+                if (line[i] === q) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({
+                start: pos,
+                end: i,
+                kind: "string"
+            });
+            pos = i;
+            matched = true;
+        }
+        if (!matched && /[0-9]/.test(line[pos])) {
+            const m = line.slice(pos).match(/^0x[0-9a-fA-F]+|^[0-9]+\.?[0-9]*(?:[eE][+-]?[0-9]+)?/);
+            if (m) {
+                tokens.push({
+                    start: pos,
+                    end: pos + m[0].length,
+                    kind: "number"
+                });
+                pos += m[0].length;
+                matched = true;
+            }
+        }
+        if (!matched && /[a-zA-Z_$]/.test(line[pos])) {
+            const m = line.slice(pos).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/);
+            if (m) {
+                const word = m[0];
+                const keywords = lang === "python" ? PY_KEYWORDS : JS_KEYWORDS;
+                const kind = ( keywords.has(word)) ? "keyword" : "default";
+                tokens.push({
+                    start: pos,
+                    end: pos + word.length,
+                    kind
+                });
+                pos += word.length;
+                matched = true;
+            }
+        }
+        if (!matched) {
+            const prevTok = tokens[tokens.length - 1];
+            if (prevTok && prevTok.kind === "default") {
+                prevTok.end = pos + 1;
+            } else {
+                tokens.push({
+                    start: pos,
+                    end: pos + 1,
+                    kind: "default"
+                });
+            }
+            pos++;
+        }
+    }
+    return tokens.map(t => buildSpan(t.kind, line.slice(t.start, t.end))).join("");
+}
+function regexTokenizeLines(text, languageId) {
+    if (!text) {
+        return [""];
+    }
+    const lang = LANG_FAMILY[languageId] ?? "generic";
+    return text.split(/\r?\n/).map(line => regexTokenizeLine(line, lang));
+}
+const CONTEXT_LINES = 3;
+function computeUnifiedDiff(original, modified) {
+    const origLines = original.split(/\r?\n/);
+    const modLines = modified.split(/\r?\n/);
+    const result = linesDiffComputers.getDefault().computeDiff(origLines, modLines, {
+        ignoreTrimWhitespace: false,
+        maxComputationTimeMs: 1000,
+        computeMoves: false
+    });
+    if (result.changes.length === 0) {
+        return [];
+    }
+    const groups = [];
+    for (const change of result.changes) {
+        const sub = {
+            origStart: change.original.startLineNumber,
+            origEnd: change.original.endLineNumberExclusive,
+            modStart: change.modified.startLineNumber,
+            modEnd: change.modified.endLineNumberExclusive
+        };
+        const last = groups[groups.length - 1];
+        const lastSub = last?.subs[last.subs.length - 1];
+        if (lastSub && sub.origStart - lastSub.origEnd <= CONTEXT_LINES * 2) {
+            last.subs.push(sub);
+        } else {
+            groups.push({
+                subs: [sub]
+            });
+        }
+    }
+    const hunks = [];
+    for (const group of groups) {
+        const first = group.subs[0];
+        const last = group.subs[group.subs.length - 1];
+        const origLeading = Math.max(1, first.origStart - CONTEXT_LINES);
+        const modLeading = Math.max(1, first.modStart - CONTEXT_LINES);
+        const origTrailing = Math.min(origLines.length + 1, last.origEnd + CONTEXT_LINES);
+        const modTrailing = Math.min(modLines.length + 1, last.modEnd + CONTEXT_LINES);
+        const lines = [];
+        for (let i = origLeading; i < first.origStart; i++) {
+            lines.push({
+                type: "context",
+                lineNum: i,
+                text: origLines[i - 1] ?? ""
+            });
+        }
+        for (let s = 0; s < group.subs.length; s++) {
+            const sub = group.subs[s];
+            for (let i = sub.origStart; i < sub.origEnd; i++) {
+                lines.push({
+                    type: "removed",
+                    lineNum: i,
+                    text: origLines[i - 1] ?? ""
+                });
+            }
+            for (let i = sub.modStart; i < sub.modEnd; i++) {
+                lines.push({
+                    type: "added",
+                    lineNum: i,
+                    text: modLines[i - 1] ?? ""
+                });
+            }
+            const next = group.subs[s + 1];
+            if (next) {
+                for (let i = sub.origEnd; i < next.origStart; i++) {
+                    lines.push({
+                        type: "context",
+                        lineNum: i,
+                        text: origLines[i - 1] ?? ""
+                    });
+                }
+            }
+        }
+        for (let i = last.origEnd; i < origTrailing; i++) {
+            lines.push({
+                type: "context",
+                lineNum: i,
+                text: origLines[i - 1] ?? ""
+            });
+        }
+        const origCount = origTrailing - origLeading;
+        const modCount = modTrailing - modLeading;
+        hunks.push({
+            header: `@@ -${origLeading},${origCount} +${modLeading},${modCount} @@`,
+            lines
+        });
+    }
+    return hunks;
+}
+
+export { computeUnifiedDiff, hasMultipleTokenClasses, regexTokenizeLines, resolveMobileDiffLanguageId, tokenizeFileLines };

package/vscode/src/vs/sessions/browser/parts/mobile/contributions/mobileDiffView.d.ts

@@ -0,0 +1,100 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+/**
+ * Command ID for opening the {@link MobileDiffView}.
+ *
+ * Accepts {@link IMobileDiffViewData} as the single argument. Phone-only.
+ *
+ * For backwards compatibility the command also accepts a bare
+ * {@link IFileDiffViewData} (without siblings) — in that case the view
+ * is rendered without prev/next navigation.
+ */
+export declare const MOBILE_OPEN_DIFF_VIEW_COMMAND_ID = "sessions.mobile.openDiffView";
+/**
+ * Minimal subset of diff entry fields consumed by the mobile diff view.
+ * Defined locally to avoid importing from vs/workbench/contrib in vs/sessions/browser.
+ */
+export interface IFileDiffViewData {
+    /**
+     * URI of the file before the change. `undefined` when the file is
+     * newly added by the agent and there is no prior content; the diff
+     * is rendered against an empty original (all lines as additions).
+     */
+    readonly originalURI: URI | undefined;
+    /**
+     * URI of the file after the change. `undefined` when the file was
+     * deleted by the agent — the diff is rendered as all-removed lines
+     * read from {@link originalURI}.
+     */
+    readonly modifiedURI: URI | undefined;
+    readonly identical: boolean;
+    readonly added: number;
+    readonly removed: number;
+}
+/**
+ * Data passed to {@link MobileDiffView} when opening a diff view.
+ *
+ * When {@link siblings} is provided and contains more than one entry,
+ * the header renders prev/next chevrons that navigate within the list.
+ */
+export interface IMobileDiffViewData {
+    readonly diff: IFileDiffViewData;
+    readonly siblings?: readonly IFileDiffViewData[];
+    readonly index?: number;
+}
+/**
+ * Full-screen overlay for viewing file changes produced by a coding agent
+ * session on phone viewports.
+ *
+ * Renders a unified diff with coloured +/- gutters, line numbers, and
+ * Monaco-quality syntax highlighting. Text is read from the file service
+ * via the modified/original URIs stored in {@link IFileDiffViewData}.
+ * This keeps the view lightweight — it avoids embedding a full Monaco
+ * diff editor while still giving users a readable, theme-aware view.
+ *
+ * Follows the account-sheet overlay pattern: appends to the workbench
+ * container, disposes on back-button tap.
+ */
+export declare class MobileDiffView extends Disposable {
+    private readonly textFileService;
+    private readonly languageService;
+    private readonly _onDidDispose;
+    /**
+     * Fires when this view has been disposed (either externally or
+     * because the user tapped Back). Used by the mobile overlay
+     * contribution to clear its `MutableDisposable<MobileDiffView>` slot.
+     */
+    readonly onDidDispose: Event<void>;
+    private readonly viewStore;
+    private disposed;
+    /** Bumped on every body render so late-arriving `textFileService.read`
+     *  promises know to drop their results when the user navigated away. */
+    private renderGeneration;
+    private readonly siblings;
+    private currentIndex;
+    private titleEl;
+    private subtitleEl;
+    private positionEl;
+    private prevBtn;
+    private nextBtn;
+    private contentArea;
+    private scrollWrapper;
+    constructor(workbenchContainer: HTMLElement, data: IMobileDiffViewData, textFileService: ITextFileService, languageService: ILanguageService);
+    private render;
+    private attachSwipeNavigation;
+    private navigate;
+    private renderBodyForCurrent;
+    private loadDiffContent;
+    private loadAndRender;
+    private resolveLanguageId;
+    private renderHunks;
+    dispose(): void;
+}
+/**
+ * Opens a {@link MobileDiffView} for the given file diff.
+ * Returns the view instance; dispose it to close.
+ */
+export declare function openMobileDiffView(workbenchContainer: HTMLElement, data: IMobileDiffViewData, textFileService: ITextFileService, languageService: ILanguageService): MobileDiffView;