@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/look-at/multimodal-fallback-chain.ts

@@ -1,66 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import type { VisionCapableModel } from "../../plugin-state"
-
-const MULTIMODAL_LOOKER_REQUIREMENT = AGENT_MODEL_REQUIREMENTS["ui"]
-
-function getFullModelKey(providerID: string, modelID: string): string {
-  return `${providerID}/${modelID}`
-}
-
-function findHardcodedFallbackEntry(
-  providerID: string,
-  modelID: string,
-): FallbackEntry | undefined {
-  return MULTIMODAL_LOOKER_REQUIREMENT.fallbackChain.find((entry) =>
-    entry.model === modelID && entry.providers.includes(providerID),
-  )
-}
-
-export function isHardcodedMultimodalFallbackModel(model: VisionCapableModel): boolean {
-  return MULTIMODAL_LOOKER_REQUIREMENT.fallbackChain.some((entry) =>
-    entry.providers.some((providerID) =>
-      getFullModelKey(providerID, entry.model) === getFullModelKey(model.providerID, model.modelID),
-    ),
-  )
-}
-
-export function buildMultimodalLookerFallbackChain(
-  visionCapableModels: VisionCapableModel[],
-): FallbackEntry[] {
-  const seen = new Set<string>()
-  const fallbackChain: FallbackEntry[] = []
-
-  for (const visionCapableModel of visionCapableModels) {
-    const key = getFullModelKey(visionCapableModel.providerID, visionCapableModel.modelID)
-    if (seen.has(key)) continue
-
-    const hardcodedEntry = findHardcodedFallbackEntry(
-      visionCapableModel.providerID,
-      visionCapableModel.modelID,
-    )
-
-    seen.add(key)
-    fallbackChain.push({
-      providers: [visionCapableModel.providerID],
-      model: visionCapableModel.modelID,
-      ...(hardcodedEntry?.variant ? { variant: hardcodedEntry.variant } : {}),
-    })
-  }
-
-  for (const entry of MULTIMODAL_LOOKER_REQUIREMENT.fallbackChain) {
-    const providerModelKeys = entry.providers.map((providerID) =>
-      getFullModelKey(providerID, entry.model),
-    )
-    if (providerModelKeys.every((key) => seen.has(key))) {
-      continue
-    }
-
-    providerModelKeys.forEach((key) => {
-      seen.add(key)
-    })
-    fallbackChain.push(entry)
-  }
-
-  return fallbackChain
-}

package/src/tools/look-at/session-poller.ts

@@ -1,42 +0,0 @@
-import type { createOpencodeClient } from "@opencode-ai/sdk"
-import { log } from "../../shared"
-
-type Client = ReturnType<typeof createOpencodeClient>
-
-export interface PollOptions {
-  pollIntervalMs?: number
-  timeoutMs?: number
-}
-
-const DEFAULT_POLL_INTERVAL_MS = 1000
-const DEFAULT_TIMEOUT_MS = 120_000
-
-export async function pollSessionUntilIdle(
-  client: Client,
-  sessionID: string,
-  options?: PollOptions,
-): Promise<void> {
-  const pollInterval = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
-  const timeout = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  const startTime = Date.now()
-
-  while (Date.now() - startTime < timeout) {
-    const statusResult = await client.session.status().catch((error) => {
-      log(`[look_at] session.status error (treating as idle):`, error)
-      return { data: undefined, error }
-    })
-
-    if (statusResult.error || !statusResult.data) {
-      return
-    }
-
-    const sessionStatus = statusResult.data[sessionID]
-    if (!sessionStatus || sessionStatus.type === "idle") {
-      return
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, pollInterval))
-  }
-
-  throw new Error(`[look_at] Polling timed out after ${timeout}ms waiting for session ${sessionID} to become idle`)
-}

package/src/tools/look-at/tools.ts

@@ -1,245 +0,0 @@
-import { basename } from "node:path"
-import { pathToFileURL } from "node:url"
-import { tool, type PluginInput, type ToolDefinition } from "@opencode-ai/plugin"
-import { LOOK_AT_DESCRIPTION, MULTIMODAL_LOOKER_AGENT } from "./constants"
-import type { LookAtArgs } from "./types"
-import { log, promptSyncWithModelSuggestionRetry } from "../../shared"
-import { extractLatestAssistantText } from "./assistant-message-extractor"
-import type { LookAtArgsWithAlias } from "./look-at-arguments"
-import { normalizeArgs, validateArgs } from "./look-at-arguments"
-import {
-  extractBase64Data,
-  inferMimeTypeFromBase64,
-  inferMimeTypeFromFilePath,
-} from "./mime-type-inference"
-import { resolveMultimodalLookerAgentMetadata } from "./multimodal-agent-metadata"
-import {
-  needsConversion,
-  convertImageToJpeg,
-  convertBase64ImageToJpeg,
-  cleanupConvertedImage,
-} from "./image-converter"
-
-function getTemporaryConversionPath(error: unknown): string | null {
-  if (!(error instanceof Error)) {
-    return null
-  }
-
-  const temporaryOutputPath = Reflect.get(error, "temporaryOutputPath")
-  if (typeof temporaryOutputPath === "string" && temporaryOutputPath.length > 0) {
-    return temporaryOutputPath
-  }
-
-  const temporaryDirectory = Reflect.get(error, "temporaryDirectory")
-  if (typeof temporaryDirectory === "string" && temporaryDirectory.length > 0) {
-    return temporaryDirectory
-  }
-
-  return null
-}
-
-
-export { normalizeArgs, validateArgs } from "./look-at-arguments"
-
-export function createLookAt(ctx: PluginInput): ToolDefinition {
-  return tool({
-    description: LOOK_AT_DESCRIPTION,
-    args: {
-      file_path: tool.schema.string().optional().describe("Absolute path to the file to analyze"),
-      image_data: tool.schema.string().optional().describe("Base64 encoded image data (for clipboard/pasted images)"),
-      goal: tool.schema.string().describe("What specific information to extract from the file"),
-    },
-    async execute(rawArgs: LookAtArgs, toolContext) {
-      const args = normalizeArgs(rawArgs as LookAtArgsWithAlias)
-      const validationError = validateArgs(args)
-      if (validationError) {
-        log(`[look_at] Validation failed: ${validationError}`)
-        return validationError
-      }
-
-      const isBase64Input = Boolean(args.image_data)
-      const sourceDescription = isBase64Input ? "clipboard/pasted image" : args.file_path
-      log(`[look_at] Analyzing ${sourceDescription}, goal: ${args.goal}`)
-
-      const imageData = args.image_data
-      const filePath = args.file_path
-
-      let mimeType: string
-      let filePart: { type: "file"; mime: string; url: string; filename: string }
-      let tempFilePath: string | null = null
-      let tempConversionPath: string | null = null
-      let tempFilesToCleanup: string[] = []
-
-      try {
-        if (imageData) {
-          mimeType = inferMimeTypeFromBase64(imageData)
-          
-          let finalBase64Data = extractBase64Data(imageData)
-          let finalMimeType = mimeType
-          
-          if (needsConversion(mimeType)) {
-            log(`[look_at] Detected unsupported Base64 format: ${mimeType}, converting to JPEG...`)
-            try {
-              const { base64, tempFiles } = convertBase64ImageToJpeg(finalBase64Data, mimeType)
-              finalBase64Data = base64
-              finalMimeType = "image/jpeg"
-              tempFilesToCleanup = tempFiles
-              log(`[look_at] Base64 conversion successful`)
-            } catch (conversionError) {
-              log(`[look_at] Base64 conversion failed: ${conversionError}`)
-              return `Error: Failed to convert Base64 image format. ${conversionError}`
-            }
-          }
-          
-          filePart = {
-            type: "file",
-            mime: finalMimeType,
-            url: `data:${finalMimeType};base64,${finalBase64Data}`,
-            filename: `clipboard-image.${finalMimeType.split("/")[1] || "png"}`,
-          }
-        } else if (filePath) {
-        mimeType = inferMimeTypeFromFilePath(filePath)
-        
-        let actualFilePath = filePath
-        if (needsConversion(mimeType)) {
-          log(`[look_at] Detected unsupported format: ${mimeType}, converting to JPEG...`)
-          try {
-            tempFilePath = convertImageToJpeg(filePath, mimeType)
-            tempConversionPath = tempFilePath
-            actualFilePath = tempFilePath
-            mimeType = "image/jpeg"
-            log(`[look_at] Conversion successful: ${tempFilePath}`)
-          } catch (conversionError) {
-            const failedConversionPath = getTemporaryConversionPath(conversionError)
-            if (failedConversionPath) {
-              tempConversionPath = failedConversionPath
-            }
-            log(`[look_at] Conversion failed: ${conversionError}`)
-            return `Error: Failed to convert image format. ${conversionError}`
-          }
-        }
-
-        filePart = {
-          type: "file",
-          mime: mimeType,
-          url: pathToFileURL(actualFilePath).href,
-          filename: basename(actualFilePath),
-        }
-      } else {
-        return "Error: Must provide either 'file_path' or 'image_data'."
-      }
-
-      const readEnabled = false
-      const subjectNoun = isBase64Input ? "image" : "file"
-      const sourceClause = readEnabled
-        ? `Use the Read tool on the provided file path to load its contents, then analyze it.`
-        : `The ${subjectNoun} is already attached to this message. Analyze it directly from the attachment. Do NOT attempt to use the Read tool. The Read tool is disabled for this invocation and the ${subjectNoun} cannot be loaded by path.`
-
-      const prompt = `Analyze the attached ${subjectNoun} and extract the requested information.
-
-${sourceClause}
-
-Goal: ${args.goal}
-
-Provide ONLY the extracted information that matches the goal.
-Be thorough on what was requested, concise on everything else.
-If the requested information is not found, clearly state what is missing.`
-
-      const { agentModel, agentVariant } = await resolveMultimodalLookerAgentMetadata(ctx)
-
-      log(`[look_at] Creating session with parent: ${toolContext.sessionID}`)
-      const parentSession = await ctx.client.session.get({
-        path: { id: toolContext.sessionID },
-      }).catch(() => null)
-      const parentDirectory = parentSession?.data?.directory ?? ctx.directory
-
-      const createResult = await ctx.client.session.create({
-        body: {
-          parentID: toolContext.sessionID,
-          title: `look_at: ${args.goal.substring(0, 50)}`,
-        },
-        query: { directory: parentDirectory },
-      })
-
-      if (createResult.error) {
-        log(`[look_at] Session create error:`, createResult.error)
-        const errorStr = String(createResult.error)
-        if (errorStr.toLowerCase().includes("unauthorized")) {
-          return `Error: Failed to create session (Unauthorized). This may be due to:
-1. OAuth token restrictions (e.g., Claude Code credentials are restricted to Claude Code only)
-2. Provider authentication issues
-3. Session permission inheritance problems
-
-Try using a different provider or API key authentication.
-
-Original error: ${createResult.error}`
-        }
-        return `Error: Failed to create session: ${createResult.error}`
-      }
-
-      const sessionID = createResult.data.id
-      log(`[look_at] Created session: ${sessionID}`)
-
-      log(`[look_at] Sending prompt with ${isBase64Input ? "base64 image" : "file"} to session ${sessionID}`)
-      try {
-        await promptSyncWithModelSuggestionRetry(ctx.client, {
-          path: { id: sessionID },
-          body: {
-            agent: MULTIMODAL_LOOKER_AGENT,
-            tools: {
-              task: false,
-              call_omo_agent: false,
-              look_at: false,
-              read: readEnabled,
-            },
-            parts: [
-              { type: "text", text: prompt },
-              filePart,
-            ],
-            ...(agentModel ? { model: { providerID: agentModel.providerID, modelID: agentModel.modelID } } : {}),
-            ...(agentVariant ? { variant: agentVariant } : {}),
-          },
-        })
-      } catch (promptError) {
-        log(`[look_at] Prompt error (ignored, will still fetch messages):`, promptError)
-      }
-
-      log(`[look_at] Fetching messages from session ${sessionID}...`)
-
-      const messagesResult = await ctx.client.session.messages({
-        path: { id: sessionID },
-      })
-
-      if (messagesResult.error) {
-        log(`[look_at] Messages error:`, messagesResult.error)
-        return `Error: Failed to get messages: ${messagesResult.error}`
-      }
-
-      const messages = messagesResult.data
-      log(`[look_at] Got ${messages.length} messages`)
-
-      const responseText = extractLatestAssistantText(messages)
-      if (!responseText) {
-        log("[look_at] No assistant message found")
-        return "Error: No response from ui agent"
-      }
-
-        log(`[look_at] Got response, length: ${responseText.length}`)
-        return responseText
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error)
-        log(`[look_at] Unexpected error analyzing ${sourceDescription}:`, error)
-        return `Error: Failed to analyze ${sourceDescription}: ${errorMessage}`
-      } finally {
-        if (tempConversionPath) {
-          cleanupConvertedImage(tempConversionPath)
-        } else if (tempFilePath) {
-          cleanupConvertedImage(tempFilePath)
-        }
-        tempFilesToCleanup.forEach(file => {
-          cleanupConvertedImage(file)
-        })
-      }
-    },
-  })
-}

package/src/tools/look-at/types.ts

@@ -1,5 +0,0 @@
-export interface LookAtArgs {
-  file_path?: string
-  image_data?: string  // base64 encoded image data (for clipboard images)
-  goal: string
-}

package/src/tools/lsp/AGENTS.md

@@ -1,70 +0,0 @@
-# src/tools/lsp/ — LSP Tool Implementations
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-33 files. Full LSP (Language Server Protocol) client stack exposed as 6 tools. Custom implementation that manages server processes, opens files, and forwards requests — does NOT delegate to OpenCode's built-in LSP.
-
-## TOOL EXPOSURE
-
-| Tool | File | What It Does |
-|------|------|--------------|
-| `lsp_goto_definition` | `goto-definition-tool.ts` | Jump to symbol definition |
-| `lsp_find_references` | `find-references-tool.ts` | All usages of a symbol |
-| `lsp_symbols` | `symbols-tool.ts` | Document outline or workspace symbol search |
-| `lsp_diagnostics` | `diagnostics-tool.ts` | Errors/warnings from language server |
-| `lsp_prepare_rename` | `rename-tools.ts` | Validate rename before applying |
-| `lsp_rename` | `rename-tools.ts` | Apply safe rename across workspace |
-
-All 6 are direct `ToolDefinition` objects (not factory functions) — registered directly in `tool-registry.ts`.
-
-## ARCHITECTURE
-
-```
-tools.ts (6 ToolDefinition exports)
-  ↓ uses
-LspClientWrapper (lsp-client-wrapper.ts)
-  ↓ wraps
-LSPClient (lsp-client.ts) extends LSPClientConnection (lsp-client-connection.ts)
-  ↓ communicates via
-LSPClientTransport (lsp-client-transport.ts)
-  ↓ talks to
-LSPProcess (lsp-process.ts) — spawns server binary
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `lsp-client-wrapper.ts` | High-level entry: resolves server, opens file, runs request |
-| `lsp-client.ts` | `LSPClient` — file tracking, document sync (`didOpen`/`didChange`) |
-| `lsp-client-connection.ts` | JSON-RPC request/response/notification layer |
-| `lsp-client-transport.ts` | stdin/stdout byte-stream framing |
-| `lsp-process.ts` | Spawn + cleanup of LSP server process |
-| `lsp-manager-process-cleanup.ts` | Reap orphan LSP processes on exit |
-| `lsp-manager-temp-directory-cleanup.ts` | Clean temp dirs used by some servers |
-| `server-definitions.ts` | 40+ builtin servers synced from OpenCode's `server.ts` |
-| `server-config-loader.ts` | Load custom server config from `.opencode/lsp.json` |
-| `server-resolution.ts` | Resolve which server handles a file extension |
-| `server-installation.ts` | Detect missing binaries, surface install hints |
-| `language-mappings.ts` | Extension → language ID mapping |
-| `lsp-formatters.ts` | Format LSP responses into human-readable strings |
-| `workspace-edit.ts` | Apply `WorkspaceEdit` results to disk (for rename) |
-| `types.ts` | `LSPServerConfig`, `Position`, `Range`, `Location`, `Diagnostic` etc. |
-
-## SERVER RESOLUTION
-
-```
-file.ts → extension (.ts) → language-mappings → server ID (typescript)
-  → server-resolution: check user config (.opencode/lsp.json) → fall back to server-definitions.ts
-  → server-installation: verify binary exists (warn with install hint if not)
-  → LSPProcess.spawn(command[])
-```
-
-## NOTES
-
-- File must be opened via `didOpen` before any LSP request — `LSPClient.openFile()` handles this
-- 1s delay after `didOpen` for server initialization before sending requests
-- `lsp_servers` tool was removed — duplicates OpenCode's built-in `LspServers` tool
-- Synced with OpenCode's `server.ts` — when adding servers, check upstream first

package/src/tools/lsp/client.ts

@@ -1,3 +0,0 @@
-export { validateCwd } from "./lsp-process"
-export { lspManager } from "./lsp-server"
-export { LSPClient } from "./lsp-client"

package/src/tools/lsp/config.ts

@@ -1,3 +0,0 @@
-export { findServerForExtension, getAllServers, getConfigPaths_ } from "./server-resolution"
-export { getLanguageId } from "./language-config"
-export { isServerInstalled } from "./server-installation"

package/src/tools/lsp/constants.ts

@@ -1,7 +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 { SYMBOL_KIND_MAP, SEVERITY_MAP, EXT_TO_LANG } from "./language-mappings"
-export { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./server-definitions"

package/src/tools/lsp/diagnostics-tool.ts

@@ -1,75 +0,0 @@
-import { resolve } from "path"
-
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-
-import { DEFAULT_MAX_DIAGNOSTICS } from "./constants"
-import { aggregateDiagnosticsForDirectory } from "./directory-diagnostics"
-import { inferExtensionFromDirectory } from "./infer-extension"
-import { filterDiagnosticsBySeverity, formatDiagnostic } from "./lsp-formatters"
-import { isDirectoryPath, withLspClient } from "./lsp-client-wrapper"
-import type { Diagnostic } from "./types"
-
-export const lsp_diagnostics: ToolDefinition = tool({
-  description:
-    'Get errors, warnings, hints from language server BEFORE running build. Works for both single files and directories - file extension is auto-detected for directories.',
-  args: {
-    filePath: tool.schema
-      .string()
-      .describe("File or directory path to check diagnostics for"),
-    severity: tool.schema
-      .enum(["error", "warning", "information", "hint", "all"])
-      .optional()
-      .describe("Filter by severity level"),
-  },
-  execute: async (args, _context) => {
-    try {
-      if (!args.filePath) {
-        throw new Error("'filePath' parameter is required.")
-      }
-      const absPath = resolve(args.filePath)
-
-      if (isDirectoryPath(absPath)) {
-        const extension = inferExtensionFromDirectory(absPath)
-        if (!extension) {
-          throw new Error(
-            `No supported source files found in directory: ${absPath}`
-          )
-        }
-        return await aggregateDiagnosticsForDirectory(absPath, extension, args.severity)
-      }
-
-      const result = await withLspClient(args.filePath, async (client) => {
-        return (await client.diagnostics(args.filePath)) as { items?: Diagnostic[] } | Diagnostic[] | null
-      })
-
-      let diagnostics: Diagnostic[] = []
-      if (result) {
-        if (Array.isArray(result)) {
-          diagnostics = result
-        } else if (result.items) {
-          diagnostics = result.items
-        }
-      }
-
-      diagnostics = filterDiagnosticsBySeverity(diagnostics, args.severity)
-
-      if (diagnostics.length === 0) {
-        const output = "No diagnostics found"
-        return output
-      }
-
-      const total = diagnostics.length
-      const truncated = total > DEFAULT_MAX_DIAGNOSTICS
-      const limited = truncated ? diagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS) : diagnostics
-      const lines = limited.map(formatDiagnostic)
-      if (truncated) {
-        lines.unshift(`Found ${total} diagnostics (showing first ${DEFAULT_MAX_DIAGNOSTICS}):`)
-      }
-      const output = lines.join("\n")
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      throw new Error(output)
-    }
-  },
-})

package/src/tools/lsp/directory-diagnostics.ts

@@ -1,163 +0,0 @@
-import { existsSync, lstatSync, readdirSync, type Stats } from "fs"
-import { extname, join, resolve } from "path"
-
-import { findServerForExtension } from "./config"
-import { findWorkspaceRoot, formatServerLookupError } from "./lsp-client-wrapper"
-import { filterDiagnosticsBySeverity, formatDiagnostic } from "./lsp-formatters"
-import { LSPClient } from "./lsp-client"
-import { lspManager } from "./lsp-server"
-import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constants"
-import type { Diagnostic } from "./types"
-
-const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"])
-
-type FileDiagnostic = {
-  filePath: string
-  diagnostic: Diagnostic
-}
-
-function collectFilesWithExtension(dir: string, extension: string, maxFiles: number): string[] {
-  const files: string[] = []
-
-  function walk(currentDir: string): void {
-    if (files.length >= maxFiles) return
-
-    let entries: string[] = []
-    try {
-      entries = readdirSync(currentDir)
-    } catch {
-      return
-    }
-
-    for (const entry of entries) {
-      if (files.length >= maxFiles) return
-
-      const fullPath = join(currentDir, entry)
-
-      let stat: Stats | undefined
-      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()) {
-        if (extname(fullPath) === extension) {
-          files.push(fullPath)
-        }
-      }
-    }
-  }
-
-  walk(dir)
-  return files
-}
-
-export async function aggregateDiagnosticsForDirectory(
-  directory: string,
-  extension: string,
-  severity?: "error" | "warning" | "information" | "hint" | "all",
-  maxFiles: number = DEFAULT_MAX_DIRECTORY_FILES
-): Promise<string> {
-  if (!extension.startsWith(".")) {
-    throw new Error(
-      `Extension must start with a dot (e.g., ".ts", not "${extension}"). ` +
-        `Use ".${extension}" instead.`
-    )
-  }
-
-  const absDir = resolve(directory)
-  if (!existsSync(absDir)) {
-    throw new Error(`Directory does not exist: ${absDir}`)
-  }
-
-  const serverResult = findServerForExtension(extension)
-  if (serverResult.status !== "found") {
-    throw new Error(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 allDiagnostics: FileDiagnostic[] = []
-  const fileErrors: { file: string; error: string }[] = []
-
-  let client: LSPClient
-  try {
-    client = await lspManager.getClient(root, server)
-
-    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 {
-    lspManager.releaseClient(root, server.id)
-  }
-
-  const displayDiagnostics = allDiagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS)
-  const wasDiagCapped = allDiagnostics.length > DEFAULT_MAX_DIAGNOSTICS
-
-  const lines: string[] = [
-    `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")
-}