@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.4

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalOutputCache.js

@@ -0,0 +1,285 @@
+
+import { TerminalToolId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds';
+import { parseCommand, segmentHead } from './terminalCommandParser.js';
+
+var CacheClass;
+(function(CacheClass) {
+    CacheClass["Fast"] = "fast";
+    CacheClass["Medium"] = "medium";
+    CacheClass["Slow"] = "slow";
+})(CacheClass || (CacheClass = {}));
+const TTL_MS = {
+    [CacheClass.Fast]: 30_000,
+    [CacheClass.Medium]: 120_000,
+    [CacheClass.Slow]: 300_000
+};
+const MAX_ENTRIES = 256;
+function classifyCommand(command) {
+    const parsed = parseCommand(command);
+    if (!parsed || parsed.segments.length === 0) {
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    }
+    if (parsed.segments.length > 1) {
+        const allInvalidates = [];
+        for (const seg of parsed.segments) {
+            const h = segmentHead(seg);
+            if (h) {
+                const sub = classifySingleHead(h);
+                allInvalidates.push(...sub.invalidates);
+            }
+        }
+        return {
+            cls: undefined,
+            invalidates: allInvalidates
+        };
+    }
+    const head = segmentHead(parsed.segments[0]);
+    if (!head) {
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    }
+    return classifySingleHead(head);
+}
+function classifySingleHead(head) {
+    switch (head.head) {
+    case "git":
+        {
+            if (head.sub && /^(add|commit|push|pull|fetch|merge|rebase|reset|checkout|switch|restore|cherry-pick|revert|stash|tag|branch|am|apply|clean|rm|mv)$/.test(head.sub)) {
+                return {
+                    cls: undefined,
+                    invalidates: ["git"]
+                };
+            }
+            if (head.sub === "status" || head.sub === "diff" || head.sub === "show" || head.sub === "blame") {
+                return {
+                    cls: CacheClass.Fast,
+                    invalidates: []
+                };
+            }
+            if (head.sub === "log" || head.sub === "reflog" || head.sub === "shortlog") {
+                return {
+                    cls: CacheClass.Slow,
+                    invalidates: []
+                };
+            }
+            return {
+                cls: undefined,
+                invalidates: []
+            };
+        }
+    case "ls":
+    case "pwd":
+    case "tree":
+    case "find":
+        return {
+            cls: head.head === "find" || head.head === "tree" ? CacheClass.Slow : CacheClass.Fast,
+            invalidates: []
+        };
+    case "npm":
+    case "pnpm":
+    case "yarn":
+        if (head.sub === "ls" || head.sub === "list" || head.sub === "outdated") {
+            return {
+                cls: CacheClass.Slow,
+                invalidates: []
+            };
+        }
+        if (head.sub === "install" || head.sub === "i" || head.sub === "ci" || head.sub === "add" || head.sub === "remove" || head.sub === "uninstall" || head.sub === "update") {
+            return {
+                cls: undefined,
+                invalidates: ["npm", "pnpm", "yarn"]
+            };
+        }
+        if (head.sub === "test" || head.sub === "run" || head.sub === undefined) {
+            return {
+                cls: CacheClass.Medium,
+                invalidates: []
+            };
+        }
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    case "pytest":
+    case "jest":
+    case "vitest":
+    case "cargo":
+        if (head.head === "cargo" && head.sub && /^(test|nextest|check|build)$/.test(head.sub)) {
+            return {
+                cls: CacheClass.Medium,
+                invalidates: []
+            };
+        }
+        if (head.head !== "cargo") {
+            return {
+                cls: CacheClass.Medium,
+                invalidates: []
+            };
+        }
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    case "go":
+        if (head.sub === "test" || head.sub === "build" || head.sub === "vet") {
+            return {
+                cls: CacheClass.Medium,
+                invalidates: []
+            };
+        }
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    case "docker":
+    case "kubectl":
+        if (head.sub === "ps" || head.sub === "images" || head.sub === "get" || head.sub === "describe") {
+            return {
+                cls: CacheClass.Fast,
+                invalidates: []
+            };
+        }
+        return {
+            cls: undefined,
+            invalidates: []
+        };
+    case "env":
+    case "printenv":
+        return {
+            cls: CacheClass.Slow,
+            invalidates: []
+        };
+    case "gh":
+        return {
+            cls: CacheClass.Medium,
+            invalidates: []
+        };
+    }
+    return {
+        cls: undefined,
+        invalidates: []
+    };
+}
+function getInput(input) {
+    if (typeof input !== "object" || input === null) {
+        return undefined;
+    }
+    const i = input;
+    if (typeof i.command !== "string" || !i.command.trim()) {
+        return undefined;
+    }
+    const cwd = typeof i.cwd === "string" ? i.cwd : "";
+    return {
+        command: i.command,
+        cwd
+    };
+}
+class TerminalOutputCache {
+    constructor(now = () => Date.now()) {
+        this.id = "terminal.session-dedup";
+        this.toolIds = [TerminalToolId.RunInTerminal];
+        this._entries = ( new Map());
+        this._now = now;
+    }
+    _key(cwd, command) {
+        return `${cwd}::${command.trim()}`;
+    }
+    observe(_toolId, input) {
+        const parsed = getInput(input);
+        if (!parsed) {
+            return;
+        }
+        const {
+            invalidates
+        } = classifyCommand(parsed.command);
+        if (invalidates.length === 0) {
+            return;
+        }
+        this._invalidateByProgram(parsed.cwd, invalidates);
+    }
+    lookup(_toolId, input) {
+        const parsed = getInput(input);
+        if (!parsed) {
+            return undefined;
+        }
+        const {
+            cls
+        } = classifyCommand(parsed.command);
+        if (cls === undefined) {
+            return undefined;
+        }
+        const key = this._key(parsed.cwd, parsed.command);
+        const entry = this._entries.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        const ttl = TTL_MS[entry.cls];
+        if (this._now() - entry.timestamp > ttl) {
+            this._entries.delete(key);
+            return undefined;
+        }
+        return {
+            text: entry.text,
+            timestamp: entry.timestamp
+        };
+    }
+    record(_toolId, input, text) {
+        const parsed = getInput(input);
+        if (!parsed) {
+            return;
+        }
+        const {
+            cls
+        } = classifyCommand(parsed.command);
+        if (cls === undefined) {
+            return;
+        }
+        const key = this._key(parsed.cwd, parsed.command);
+        if (( this._entries.has(key))) {
+            this._entries.delete(key);
+        }
+        this._entries.set(key, {
+            cwd: parsed.cwd,
+            command: parsed.command,
+            text,
+            timestamp: this._now(),
+            cls
+        });
+        while (this._entries.size > MAX_ENTRIES) {
+            const oldestKey = ( this._entries.keys()).next().value;
+            if (oldestKey === undefined) {
+                break;
+            }
+            this._entries.delete(oldestKey);
+        }
+    }
+    invalidateCwd(cwd) {
+        for (const key of [...( this._entries.keys())]) {
+            const e = this._entries.get(key);
+            if (e.cwd === cwd) {
+                this._entries.delete(key);
+            }
+        }
+    }
+    _invalidateByProgram(cwd, programs) {
+        const progSet = ( new Set(programs));
+        for (const key of [...( this._entries.keys())]) {
+            const e = this._entries.get(key);
+            if (e.cwd !== cwd) {
+                continue;
+            }
+            const head = segmentHead(parseCommand(e.command)?.segments[0] ?? {
+                tokens: []});
+            if (head && ( progSet.has(head.head))) {
+                this._entries.delete(key);
+            }
+        }
+    }
+}
+
+export { CacheClass, TerminalOutputCache };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalOutputCompressor.d.ts

@@ -1,32 +1,39 @@
-import { IToolResultFilter } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor";
+import { IToolResultFilter } from "../../../../chat/common/tools/toolResultCompressor.js";
 import { IToolResultCompressor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/toolResultCompressor.service";
-/**
- * Returns the "head" of a shell command — the first executable word, after
- * skipping common env-var assignments like `FOO=bar baz`. `sub` is the first
- * non-long-flag token after the head, so `git --no-pager diff` yields
- * `{ head: 'git', sub: 'diff' }`. Returns `undefined` when the command can't
- * be parsed.
- */
-export declare function parseCommandHead(command: string | undefined): {
-    head: string;
-    sub: string | undefined;
-} | undefined;
+import { parseCommandHead as _parseCommandHead } from "./terminalCommandParser.js";
+/** Backwards-compatible re-export so existing tests/consumers keep working. */
+export declare const parseCommandHead: typeof _parseCommandHead;
 /**
  * Compresses `git diff` / `git show` output by reducing context lines to a
  * tighter window and dropping the huge no-op chunks that diffs of generated
  * files (lockfiles, snapshots) produce.
+ *
+ * Notably this does **not** match `git difftool`, which prints a different
+ * format and would be corrupted by hunk-header rewriting.
  */
 export declare const gitDiffFilter: IToolResultFilter;
+/** Trim `git log` output: collapse multiple blank-line runs. */
+export declare const gitLogFilter: IToolResultFilter;
+/** Drop the long "(use ... )" hint blocks in `git status`. */
+export declare const gitStatusFilter: IToolResultFilter;
 /**
  * Compresses `ls -l` / `ls -la` output by dropping permission/owner/size
  * columns and keeping only the entry name. Plain `ls` is already terse and
  * passes through.
  */
 export declare const lsFilter: IToolResultFilter;
+export declare const findFilter: IToolResultFilter;
+export declare const grepFilter: IToolResultFilter;
+export declare const treeFilter: IToolResultFilter;
+export declare const testRunnerFilter: IToolResultFilter;
+export declare const buildToolFilter: IToolResultFilter;
+export declare const linterFilter: IToolResultFilter;
 /**
  * Compresses `npm install` / `yarn` / `pnpm install` output by stripping
  * progress lines and audit summary noise, keeping the package summary plus
  * any error/warning lines.
  */
 export declare const npmInstallFilter: IToolResultFilter;
+/** Sort + dedupe `env` / `printenv` output. */
+export declare const envFilter: IToolResultFilter;
 export declare function registerTerminalCompressors(compressor: IToolResultCompressor): void;