oh-my-opencode 4.9.2 → 4.11.0

package/packages/lsp-tools-mcp/dist/lsp/cleanup-errors.js

@@ -1,6 +0,0 @@
-export function reportBestEffortCleanupError(operation, error) {
-    if (process.env["CODEX_LSP_DEBUG_CLEANUP"] !== "1")
-        return;
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`[codex-lsp] ignored ${operation} failure during cleanup: ${message}`);
-}

package/packages/lsp-tools-mcp/dist/lsp/client-wrapper.js

@@ -1,132 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { contextCwd } from "../request-context.js";
-import { effectiveExtension } from "./effective-extension.js";
-import { isLspDeadConnectionError, LspInvalidPathError, LspRequestTimeoutError, LspServerInitializingError, LspServerLookupError, } from "./errors.js";
-import { getLspManager } from "./manager.js";
-import { loadInstallDecision } from "./server-install-state.js";
-import { findServerForExtension } from "./server-resolution.js";
-const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
-export function isDirectoryPath(filePath) {
-    try {
-        return statSync(filePath).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export function findWorkspaceRoot(filePath) {
-    const abs = resolve(contextCwd(), filePath);
-    let dir = abs;
-    if (!isDirectoryPath(dir)) {
-        dir = dirname(dir);
-    }
-    let prevDir = "";
-    while (dir !== prevDir) {
-        for (const marker of WORKSPACE_MARKERS) {
-            if (existsSync(join(dir, marker))) {
-                return dir;
-            }
-        }
-        prevDir = dir;
-        dir = dirname(dir);
-    }
-    return dirname(abs);
-}
-export function formatServerLookupError(result) {
-    if (result.status === "not_installed") {
-        return formatNotInstalled(result);
-    }
-    return [
-        `No LSP server configured for extension: ${result.extension}`,
-        "",
-        `Available servers: ${result.availableServers.slice(0, 10).join(", ")}${result.availableServers.length > 10 ? "..." : ""}`,
-        "",
-        "Configure a custom server in '.codex/lsp-client.json':",
-        "  {",
-        '    "lsp": {',
-        '      "my-server": {',
-        '        "command": ["my-lsp", "--stdio"],',
-        `        "extensions": ["${result.extension}"]`,
-        "      }",
-        "    }",
-        "  }",
-    ].join("\n");
-}
-function formatNotInstalled(result) {
-    const { server, installHint } = result;
-    const extensions = server.extensions.join(", ");
-    const decision = loadInstallDecision(server.id)?.decision;
-    if (decision === "declined") {
-        return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
-    }
-    const header = [
-        `LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
-        "",
-        `Command not found: ${server.command[0]}`,
-        "",
-    ];
-    if (decision === "allowed") {
-        return [
-            ...header,
-            "The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
-            `  ${installHint}`,
-        ].join("\n");
-    }
-    return [
-        ...header,
-        "To install, run:",
-        `  ${installHint}`,
-        "",
-        "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
-        "- If the user agrees: run the install command above, then retry this tool.",
-        "- If the user declines, OR has NOT explicitly asked for LSP installation:",
-        `    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
-        "    then ignore this message and proceed WITHOUT LSP.",
-    ].join("\n");
-}
-const READ_ONLY_RETRY_TOOLS = new Set([
-    "diagnostics",
-    "definition",
-    "references",
-    "documentSymbols",
-    "workspaceSymbols",
-    "prepareRename",
-]);
-export async function withLspClient(filePath, fn, toolName, options = {}) {
-    const absPath = resolve(contextCwd(), filePath);
-    if (isDirectoryPath(absPath)) {
-        throw new LspInvalidPathError("Directory paths are not supported by this LSP tool. " +
-            "Use lsp.diagnostics with a directory path for directory diagnostics.");
-    }
-    const ext = effectiveExtension(absPath);
-    const result = findServerForExtension(ext);
-    if (result.status !== "found") {
-        throw new LspServerLookupError(formatServerLookupError(result));
-    }
-    const server = result.server;
-    const root = findWorkspaceRoot(absPath);
-    const manager = options.manager ?? getLspManager();
-    const acquireAndCall = async (allowRetry) => {
-        const client = await manager.getClient(root, server, options.signal);
-        try {
-            return await fn(client, root);
-        }
-        catch (err) {
-            if (allowRetry && READ_ONLY_RETRY_TOOLS.has(toolName) && isLspDeadConnectionError(err)) {
-                manager.invalidateClient(root, server.id, client);
-                return acquireAndCall(false);
-            }
-            if (err instanceof LspRequestTimeoutError) {
-                if (manager.isServerInitializing(root, server.id)) {
-                    throw new LspServerInitializingError(err);
-                }
-            }
-            throw err;
-        }
-        finally {
-            manager.releaseClient(root, server.id);
-        }
-    };
-    return acquireAndCall(true);
-}

package/packages/lsp-tools-mcp/dist/lsp/client.js

@@ -1,131 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { contextCwd } from "../request-context.js";
-import { LspClientConnection } from "./connection.js";
-import { effectiveExtension } from "./effective-extension.js";
-import { getLanguageId } from "./language-mappings.js";
-const POST_OPEN_DELAY_MS = 1000;
-const POST_DIAGNOSTICS_WAIT_MS = 500;
-export class LspClient extends LspClientConnection {
-    constructor() {
-        super(...arguments);
-        this.openedFiles = new Set();
-        this.documentVersions = new Map();
-        this.lastSyncedText = new Map();
-        this.diagnosticPullErrors = [];
-    }
-    getDiagnosticPullErrors() {
-        return this.diagnosticPullErrors;
-    }
-    async openFile(filePath) {
-        const absPath = resolve(contextCwd(), filePath);
-        const uri = pathToFileURL(absPath).href;
-        const text = readFileSync(absPath, "utf-8");
-        if (!this.openedFiles.has(absPath)) {
-            const ext = effectiveExtension(absPath);
-            const languageId = getLanguageId(ext);
-            const version = 1;
-            await this.sendNotification("textDocument/didOpen", {
-                textDocument: {
-                    uri,
-                    languageId,
-                    version,
-                    text,
-                },
-            });
-            this.openedFiles.add(absPath);
-            this.documentVersions.set(uri, version);
-            this.lastSyncedText.set(uri, text);
-            await new Promise((r) => setTimeout(r, POST_OPEN_DELAY_MS));
-            return;
-        }
-        const prevText = this.lastSyncedText.get(uri);
-        if (prevText === text) {
-            return;
-        }
-        const nextVersion = (this.documentVersions.get(uri) ?? 1) + 1;
-        this.documentVersions.set(uri, nextVersion);
-        this.lastSyncedText.set(uri, text);
-        await this.sendNotification("textDocument/didChange", {
-            textDocument: { uri, version: nextVersion },
-            contentChanges: [{ text }],
-        });
-        await this.sendNotification("textDocument/didSave", {
-            textDocument: { uri },
-            text,
-        });
-    }
-    async definition(filePath, line, character) {
-        const absPath = resolve(contextCwd(), filePath);
-        await this.openFile(absPath);
-        return this.sendRequest("textDocument/definition", {
-            textDocument: { uri: pathToFileURL(absPath).href },
-            position: { line: line - 1, character },
-        });
-    }
-    async references(filePath, line, character, includeDeclaration = true) {
-        const absPath = resolve(contextCwd(), filePath);
-        await this.openFile(absPath);
-        return this.sendRequest("textDocument/references", {
-            textDocument: { uri: pathToFileURL(absPath).href },
-            position: { line: line - 1, character },
-            context: { includeDeclaration },
-        });
-    }
-    async documentSymbols(filePath) {
-        const absPath = resolve(contextCwd(), filePath);
-        await this.openFile(absPath);
-        return this.sendRequest("textDocument/documentSymbol", {
-            textDocument: { uri: pathToFileURL(absPath).href },
-        });
-    }
-    async workspaceSymbols(query) {
-        return this.sendRequest("workspace/symbol", { query });
-    }
-    isUnsupportedDiagnosticPullError(error) {
-        if (!(error instanceof Error))
-            return false;
-        const code = "code" in error && typeof error.code === "number" ? error.code : undefined;
-        if (code === -32601)
-            return true;
-        return /unsupported|not supported|method not found|unknown request/i.test(error.message);
-    }
-    async diagnostics(filePath) {
-        const absPath = resolve(contextCwd(), filePath);
-        const uri = pathToFileURL(absPath).href;
-        await this.openFile(absPath);
-        await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
-        try {
-            const result = await this.sendRequest("textDocument/diagnostic", {
-                textDocument: { uri },
-            });
-            if (result.items) {
-                return { items: result.items };
-            }
-        }
-        catch (error) {
-            if (!this.isUnsupportedDiagnosticPullError(error)) {
-                this.diagnosticPullErrors.push(error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-        return { items: this.getStoredDiagnostics(uri) };
-    }
-    async prepareRename(filePath, line, character) {
-        const absPath = resolve(contextCwd(), filePath);
-        await this.openFile(absPath);
-        return this.sendRequest("textDocument/prepareRename", {
-            textDocument: { uri: pathToFileURL(absPath).href },
-            position: { line: line - 1, character },
-        });
-    }
-    async rename(filePath, line, character, newName) {
-        const absPath = resolve(contextCwd(), filePath);
-        await this.openFile(absPath);
-        return this.sendRequest("textDocument/rename", {
-            textDocument: { uri: pathToFileURL(absPath).href },
-            position: { line: line - 1, character },
-            newName,
-        });
-    }
-}

package/packages/lsp-tools-mcp/dist/lsp/config-loader.js

@@ -1,220 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { delimiter, isAbsolute, join } from "node:path";
-import { contextCwd, contextEnv } from "../request-context.js";
-import { BUILTIN_SERVERS } from "./server-definitions.js";
-export function getConfigPaths() {
-    return {
-        project: getProjectConfigPaths()[0] ?? join(process.cwd(), ".codex", "lsp-client.json"),
-        user: getUserConfigPath(),
-    };
-}
-function resolveProjectConfigPath(path) {
-    return isAbsolute(path) ? path : join(contextCwd(), path);
-}
-function getProjectConfigPaths() {
-    const projectOverride = contextEnv("LSP_TOOLS_MCP_PROJECT_CONFIG");
-    if (projectOverride) {
-        return projectOverride.split(delimiter).filter(Boolean).map(resolveProjectConfigPath);
-    }
-    return [join(contextCwd(), ".codex", "lsp-client.json")];
-}
-function getUserConfigPath() {
-    const userOverride = contextEnv("LSP_TOOLS_MCP_USER_CONFIG");
-    if (!userOverride)
-        return join(homedir(), ".codex", "lsp-client.json");
-    return isAbsolute(userOverride) ? userOverride : join(homedir(), userOverride);
-}
-function loadJsonFile(path) {
-    if (!existsSync(path))
-        return null;
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
-        return isConfigJson(parsed) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function loadAllConfigs() {
-    const configs = new Map();
-    const project = loadFirstJsonFile(getProjectConfigPaths());
-    if (project)
-        configs.set("project", project);
-    const user = loadJsonFile(getUserConfigPath());
-    if (user)
-        configs.set("user", user);
-    return configs;
-}
-function loadFirstJsonFile(paths) {
-    for (const path of paths) {
-        const config = loadJsonFile(path);
-        if (config)
-            return config;
-    }
-    return null;
-}
-export function getMergedServers() {
-    const configs = loadAllConfigs();
-    const servers = [];
-    const disabled = new Set();
-    const seen = new Set();
-    const sources = ["project", "user"];
-    for (const source of sources) {
-        const config = configs.get(source);
-        if (!config?.lsp)
-            continue;
-        for (const [id, rawEntry] of Object.entries(config.lsp)) {
-            const entry = parseLspEntry(rawEntry);
-            if (!entry)
-                continue;
-            if (entry.disabled) {
-                disabled.add(id);
-                continue;
-            }
-            if (seen.has(id))
-                continue;
-            const server = createServerFromEntry(id, entry, source);
-            if (!server)
-                continue;
-            servers.push(server);
-            seen.add(id);
-        }
-    }
-    for (const [id, config] of Object.entries(BUILTIN_SERVERS)) {
-        if (disabled.has(id) || seen.has(id))
-            continue;
-        servers.push({
-            id,
-            command: config.command,
-            extensions: config.extensions,
-            priority: -100,
-            source: "builtin",
-        });
-    }
-    return servers.sort((a, b) => {
-        if (a.source !== b.source) {
-            const order = {
-                project: 0,
-                user: 1,
-                builtin: 2,
-            };
-            return order[a.source] - order[b.source];
-        }
-        return b.priority - a.priority;
-    });
-}
-function createServerFromEntry(id, entry, source) {
-    const builtin = BUILTIN_SERVERS[id];
-    if (source === "project") {
-        if (!builtin)
-            return null;
-        const server = createServer({
-            id,
-            command: builtin.command,
-            extensions: entry.extensions ?? builtin.extensions,
-            priority: entry.priority ?? 0,
-            source,
-        });
-        if (entry.initialization !== undefined) {
-            server.initialization = entry.initialization;
-        }
-        return server;
-    }
-    if (entry.command && entry.extensions) {
-        const server = createServer({
-            id,
-            command: entry.command,
-            extensions: entry.extensions,
-            priority: entry.priority ?? 0,
-            source,
-        });
-        applyOptionalServerFields(server, entry);
-        return server;
-    }
-    if (!builtin)
-        return null;
-    const server = createServer({
-        id,
-        command: entry.command ?? builtin.command,
-        extensions: entry.extensions ?? builtin.extensions,
-        priority: entry.priority ?? 0,
-        source,
-    });
-    applyOptionalServerFields(server, entry);
-    return server;
-}
-function createServer(input) {
-    const server = {
-        id: input.id,
-        command: input.command,
-        extensions: input.extensions,
-        priority: input.priority,
-        source: input.source,
-    };
-    if (input.env !== undefined) {
-        server.env = input.env;
-    }
-    if (input.initialization !== undefined) {
-        server.initialization = input.initialization;
-    }
-    return server;
-}
-function applyOptionalServerFields(server, entry) {
-    if (entry.env !== undefined) {
-        server.env = entry.env;
-    }
-    if (entry.initialization !== undefined) {
-        server.initialization = entry.initialization;
-    }
-}
-function isConfigJson(value) {
-    if (!isRecord(value))
-        return false;
-    const lsp = value["lsp"];
-    return lsp === undefined || isRecord(lsp);
-}
-function parseLspEntry(value) {
-    return isLspEntry(value) ? value : null;
-}
-function isLspEntry(value) {
-    if (!isRecord(value))
-        return false;
-    const disabled = value["disabled"];
-    const command = value["command"];
-    const extensions = value["extensions"];
-    const priority = value["priority"];
-    const env = value["env"];
-    const initialization = value["initialization"];
-    return ((disabled === undefined || typeof disabled === "boolean") &&
-        (command === undefined || isStringArray(command)) &&
-        (extensions === undefined || isStringArray(extensions)) &&
-        (priority === undefined || typeof priority === "number") &&
-        (env === undefined || isStringRecord(env)) &&
-        (initialization === undefined || isRecord(initialization)));
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function isStringRecord(value) {
-    return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function getDisabledServerIds() {
-    const configs = loadAllConfigs();
-    const disabled = new Set();
-    for (const config of configs.values()) {
-        if (!config.lsp)
-            continue;
-        for (const [id, rawEntry] of Object.entries(config.lsp)) {
-            const entry = parseLspEntry(rawEntry);
-            if (!entry)
-                continue;
-            if (entry.disabled)
-                disabled.add(id);
-        }
-    }
-    return disabled;
-}

package/packages/lsp-tools-mcp/dist/lsp/connection.js

@@ -1,66 +0,0 @@
-import { pathToFileURL } from "node:url";
-import { LspClientTransport } from "./transport.js";
-const INITIALIZE_SETTLE_MS = 300;
-export class LspClientConnection extends LspClientTransport {
-    async initialize() {
-        const rootUri = pathToFileURL(this.root).href;
-        await this.sendRequest("initialize", {
-            processId: process.pid,
-            rootUri,
-            rootPath: this.root,
-            workspaceFolders: [{ uri: rootUri, name: "workspace" }],
-            capabilities: {
-                textDocument: {
-                    hover: { contentFormat: ["markdown", "plaintext"] },
-                    definition: { linkSupport: true },
-                    references: {},
-                    documentSymbol: { hierarchicalDocumentSymbolSupport: true },
-                    publishDiagnostics: {},
-                    rename: {
-                        prepareSupport: true,
-                        prepareSupportDefaultBehavior: 1,
-                        honorsChangeAnnotations: true,
-                    },
-                    codeAction: {
-                        codeActionLiteralSupport: {
-                            codeActionKind: {
-                                valueSet: [
-                                    "quickfix",
-                                    "refactor",
-                                    "refactor.extract",
-                                    "refactor.inline",
-                                    "refactor.rewrite",
-                                    "source",
-                                    "source.organizeImports",
-                                    "source.fixAll",
-                                ],
-                            },
-                        },
-                        isPreferredSupport: true,
-                        disabledSupport: true,
-                        dataSupport: true,
-                        resolveSupport: {
-                            properties: ["edit", "command"],
-                        },
-                    },
-                },
-                workspace: {
-                    symbol: {},
-                    workspaceFolders: true,
-                    configuration: true,
-                    applyEdit: true,
-                    workspaceEdit: {
-                        documentChanges: true,
-                    },
-                },
-            },
-            initializationOptions: this.server.initialization,
-        });
-        await this.sendNotification("initialized");
-        await this.sendNotification("workspace/didChangeConfiguration", {
-            settings: { json: { validate: { enable: true } } },
-        });
-        // Some servers accept initialized before their diagnostics/indexing handlers are ready.
-        await new Promise((r) => setTimeout(r, INITIALIZE_SETTLE_MS));
-    }
-}

package/packages/lsp-tools-mcp/dist/lsp/constants.js

@@ -1,10 +0,0 @@
-export const DEFAULT_MAX_REFERENCES = 200;
-export const DEFAULT_MAX_SYMBOLS = 200;
-export const DEFAULT_MAX_DIAGNOSTICS = 200;
-export const DEFAULT_MAX_DIRECTORY_FILES = 50;
-export const REQUEST_TIMEOUT_MS = 15_000;
-export const INIT_TIMEOUT_MS = 60_000;
-export const IDLE_TIMEOUT_MS = 5 * 60_000;
-export const REAPER_INTERVAL_MS = 60_000;
-export const STOP_HARD_KILL_TIMEOUT_MS = 5_000;
-export const STOP_SIGKILL_GRACE_MS = 1_000;

package/packages/lsp-tools-mcp/dist/lsp/directory-diagnostics.js

@@ -1,125 +0,0 @@
-import { existsSync, lstatSync, readdirSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { contextCwd } from "../request-context.js";
-import { findWorkspaceRoot, formatServerLookupError } from "./client-wrapper.js";
-import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constants.js";
-import { effectiveExtension } from "./effective-extension.js";
-import { LspInvalidPathError, LspServerLookupError } from "./errors.js";
-import { filterDiagnosticsBySeverity, formatDiagnostic } from "./formatters.js";
-import { getLspManager } from "./manager.js";
-import { findServerForExtension } from "./server-resolution.js";
-const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
-export function collectFilesWithExtension(dir, extension, maxFiles) {
-    const files = [];
-    function walk(currentDir) {
-        if (files.length >= maxFiles)
-            return;
-        let entries = [];
-        try {
-            entries = readdirSync(currentDir);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (files.length >= maxFiles)
-                return;
-            const fullPath = join(currentDir, entry);
-            let stat;
-            try {
-                stat = lstatSync(fullPath);
-            }
-            catch {
-                continue;
-            }
-            if (!stat || stat.isSymbolicLink())
-                continue;
-            if (stat.isDirectory()) {
-                if (!SKIP_DIRECTORIES.has(entry)) {
-                    walk(fullPath);
-                }
-            }
-            else if (stat.isFile() && effectiveExtension(fullPath) === extension) {
-                files.push(fullPath);
-            }
-        }
-    }
-    walk(dir);
-    return files;
-}
-export async function aggregateDiagnosticsForDirectory(directory, extension, severity, maxFiles = DEFAULT_MAX_DIRECTORY_FILES) {
-    if (!extension.startsWith(".")) {
-        throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
-    }
-    const absDir = resolve(contextCwd(), directory);
-    if (!existsSync(absDir)) {
-        throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
-    }
-    const serverResult = findServerForExtension(extension);
-    if (serverResult.status !== "found") {
-        throw new LspServerLookupError(formatServerLookupError(serverResult));
-    }
-    const server = serverResult.server;
-    const allFiles = collectFilesWithExtension(absDir, extension, maxFiles + 1);
-    const wasCapped = allFiles.length > maxFiles;
-    const filesToProcess = allFiles.slice(0, maxFiles);
-    if (filesToProcess.length === 0) {
-        return [
-            `Directory: ${absDir}`,
-            `Extension: ${extension}`,
-            "Files scanned: 0",
-            `No files found with extension "${extension}".`,
-        ].join("\n");
-    }
-    const root = findWorkspaceRoot(absDir);
-    const manager = getLspManager();
-    const allDiagnostics = [];
-    const fileErrors = [];
-    const client = await manager.getClient(root, server);
-    try {
-        for (const file of filesToProcess) {
-            try {
-                const result = await client.diagnostics(file);
-                const filtered = filterDiagnosticsBySeverity(result.items, severity);
-                allDiagnostics.push(...filtered.map((diagnostic) => ({
-                    filePath: file,
-                    diagnostic,
-                })));
-            }
-            catch (e) {
-                fileErrors.push({
-                    file,
-                    error: e instanceof Error ? e.message : String(e),
-                });
-            }
-        }
-    }
-    finally {
-        manager.releaseClient(root, server.id);
-    }
-    const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS);
-    const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS;
-    const lines = [
-        `Directory: ${absDir}`,
-        `Extension: ${extension}`,
-        `Files scanned: ${filesToProcess.length}${wasCapped ? ` (capped at ${maxFiles})` : ""}`,
-        `Files with errors: ${fileErrors.length}`,
-        `Total diagnostics: ${allDiagnostics.length}`,
-    ];
-    if (fileErrors.length > 0) {
-        lines.push("", "File processing errors:");
-        for (const { file, error } of fileErrors) {
-            lines.push(`  ${file}: ${error}`);
-        }
-    }
-    if (displayDiagnostics.length > 0) {
-        lines.push("");
-        for (const { filePath, diagnostic } of displayDiagnostics) {
-            lines.push(`${filePath}: ${formatDiagnostic(diagnostic)}`);
-        }
-        if (wasDiagCapped) {
-            lines.push("", `... (${allDiagnostics.length - DEFAULT_MAX_DIAGNOSTICS} more diagnostics not shown)`);
-        }
-    }
-    return lines.join("\n");
-}