@hiai-gg/hiai-opencode 0.1.0

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,245 @@
+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

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

package/src/tools/lsp/AGENTS.md

@@ -0,0 +1,70 @@
+# 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

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

package/src/tools/lsp/config.ts

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

package/src/tools/lsp/constants.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,163 @@
+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")
+}