@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/lsp/find-references-tool.ts

@@ -1,43 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-
-import { DEFAULT_MAX_REFERENCES } from "./constants"
-import { formatLocation } from "./lsp-formatters"
-import { withLspClient } from "./lsp-client-wrapper"
-import type { Location } from "./types"
-
-export const lsp_find_references: ToolDefinition = tool({
-  description: "Find ALL usages/references of a symbol across the entire workspace.",
-  args: {
-    filePath: tool.schema.string(),
-    line: tool.schema.number().min(1).describe("1-based"),
-    character: tool.schema.number().min(0).describe("0-based"),
-    includeDeclaration: tool.schema.boolean().optional().describe("Include the declaration itself"),
-  },
-  execute: async (args, _context) => {
-    try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return (await client.references(args.filePath, args.line, args.character, args.includeDeclaration ?? true)) as
-          | Location[]
-          | null
-      })
-
-      if (!result || result.length === 0) {
-        const output = "No references found"
-        return output
-      }
-
-      const total = result.length
-      const truncated = total > DEFAULT_MAX_REFERENCES
-      const limited = truncated ? result.slice(0, DEFAULT_MAX_REFERENCES) : result
-      const lines = limited.map(formatLocation)
-      if (truncated) {
-        lines.unshift(`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`)
-      }
-      const output = lines.join("\n")
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      return output
-    }
-  },
-})

package/src/tools/lsp/goto-definition-tool.ts

@@ -1,42 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-
-import { formatLocation } from "./lsp-formatters"
-import { withLspClient } from "./lsp-client-wrapper"
-import type { Location, LocationLink } from "./types"
-
-export const lsp_goto_definition: ToolDefinition = tool({
-  description: "Jump to symbol definition. Find WHERE something is defined.",
-  args: {
-    filePath: tool.schema.string(),
-    line: tool.schema.number().min(1).describe("1-based"),
-    character: tool.schema.number().min(0).describe("0-based"),
-  },
-  execute: async (args, _context) => {
-    try {
-      const result = await withLspClient(args.filePath, async (client) => {
-        return (await client.definition(args.filePath, args.line, args.character)) as
-          | Location
-          | Location[]
-          | LocationLink[]
-          | null
-      })
-
-      if (!result) {
-        const output = "No definition found"
-        return output
-      }
-
-      const locations = Array.isArray(result) ? result : [result]
-      if (locations.length === 0) {
-        const output = "No definition found"
-        return output
-      }
-
-      const output = locations.map(formatLocation).join("\n")
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      return output
-    }
-  },
-})

package/src/tools/lsp/index.ts

@@ -1,9 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export * from "./config"
-export * from "./client"
-export * from "./lsp-client-wrapper"
-export * from "./lsp-formatters"
-export * from "./workspace-edit"
-// NOTE: lsp_servers removed - duplicates OpenCode's built-in LspServers
-export { lsp_goto_definition, lsp_find_references, lsp_symbols, lsp_diagnostics, lsp_prepare_rename, lsp_rename } from "./tools"

package/src/tools/lsp/infer-extension.ts

@@ -1,65 +0,0 @@
-import { readdirSync, lstatSync } from "fs"
-import { extname, join } from "path"
-
-import { EXT_TO_LANG } from "./language-mappings"
-
-const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"])
-const MAX_SCAN_ENTRIES = 500
-
-export function inferExtensionFromDirectory(directory: string): string | null {
-  const extensionCounts = new Map<string, number>()
-  let scanned = 0
-
-  function walk(dir: string): void {
-    if (scanned >= MAX_SCAN_ENTRIES) return
-
-    let entries: string[]
-    try {
-      entries = readdirSync(dir)
-    } catch {
-      return
-    }
-
-    for (const entry of entries) {
-      if (scanned >= MAX_SCAN_ENTRIES) return
-
-      const fullPath = join(dir, entry)
-
-      let stat: ReturnType<typeof lstatSync> | undefined
-      try {
-        stat = lstatSync(fullPath)
-      } catch {
-        continue
-      }
-
-      if (stat.isSymbolicLink()) continue
-      scanned++
-
-      if (stat.isDirectory()) {
-        if (!SKIP_DIRECTORIES.has(entry)) {
-          walk(fullPath)
-        }
-      } else if (stat.isFile()) {
-        const ext = extname(fullPath)
-        if (ext && ext in EXT_TO_LANG) {
-          extensionCounts.set(ext, (extensionCounts.get(ext) ?? 0) + 1)
-        }
-      }
-    }
-  }
-
-  walk(directory)
-
-  if (extensionCounts.size === 0) return null
-
-  let maxExt = ""
-  let maxCount = 0
-  for (const [ext, count] of extensionCounts) {
-    if (count > maxCount) {
-      maxCount = count
-      maxExt = ext
-    }
-  }
-
-  return maxExt || null
-}

package/src/tools/lsp/language-config.ts

@@ -1,5 +0,0 @@
-import { EXT_TO_LANG } from "./constants"
-
-export function getLanguageId(ext: string): string {
-  return EXT_TO_LANG[ext] || "plaintext"
-}

package/src/tools/lsp/language-mappings.ts

@@ -1,171 +0,0 @@
-export const SYMBOL_KIND_MAP: Record<number, string> = {
-  1: "File",
-  2: "Module",
-  3: "Namespace",
-  4: "Package",
-  5: "Class",
-  6: "Method",
-  7: "Property",
-  8: "Field",
-  9: "Constructor",
-  10: "Enum",
-  11: "Interface",
-  12: "Function",
-  13: "Variable",
-  14: "Constant",
-  15: "String",
-  16: "Number",
-  17: "Boolean",
-  18: "Array",
-  19: "Object",
-  20: "Key",
-  21: "Null",
-  22: "EnumMember",
-  23: "Struct",
-  24: "Event",
-  25: "Operator",
-  26: "TypeParameter",
-}
-
-export const SEVERITY_MAP: Record<number, string> = {
-  1: "error",
-  2: "warning",
-  3: "information",
-  4: "hint",
-}
-
-// Synced with OpenCode's language.ts
-// https://github.com/sst/opencode/blob/dev/packages/opencode/src/lsp/language.ts
-export const EXT_TO_LANG: Record<string, string> = {
-  ".abap": "abap",
-  ".bat": "bat",
-  ".bib": "bibtex",
-  ".bibtex": "bibtex",
-  ".clj": "clojure",
-  ".cljs": "clojure",
-  ".cljc": "clojure",
-  ".edn": "clojure",
-  ".coffee": "coffeescript",
-  ".c": "c",
-  ".cpp": "cpp",
-  ".cxx": "cpp",
-  ".cc": "cpp",
-  ".c++": "cpp",
-  ".cs": "csharp",
-  ".css": "css",
-  ".d": "d",
-  ".pas": "pascal",
-  ".pascal": "pascal",
-  ".diff": "diff",
-  ".patch": "diff",
-  ".dart": "dart",
-  ".dockerfile": "dockerfile",
-  ".ex": "elixir",
-  ".exs": "elixir",
-  ".erl": "erlang",
-  ".hrl": "erlang",
-  ".fs": "fsharp",
-  ".fsi": "fsharp",
-  ".fsx": "fsharp",
-  ".fsscript": "fsharp",
-  ".gitcommit": "git-commit",
-  ".gitrebase": "git-rebase",
-  ".go": "go",
-  ".groovy": "groovy",
-  ".gleam": "gleam",
-  ".hbs": "handlebars",
-  ".handlebars": "handlebars",
-  ".hs": "haskell",
-  ".html": "html",
-  ".htm": "html",
-  ".ini": "ini",
-  ".java": "java",
-  ".js": "javascript",
-  ".jsx": "javascriptreact",
-  ".json": "json",
-  ".jsonc": "jsonc",
-  ".tex": "latex",
-  ".latex": "latex",
-  ".less": "less",
-  ".lua": "lua",
-  ".makefile": "makefile",
-  makefile: "makefile",
-  ".md": "markdown",
-  ".markdown": "markdown",
-  ".m": "objective-c",
-  ".mm": "objective-cpp",
-  ".pl": "perl",
-  ".pm": "perl",
-  ".pm6": "perl6",
-  ".php": "php",
-  ".ps1": "powershell",
-  ".psm1": "powershell",
-  ".pug": "jade",
-  ".jade": "jade",
-  ".py": "python",
-  ".pyi": "python",
-  ".r": "r",
-  ".cshtml": "razor",
-  ".razor": "razor",
-  ".rb": "ruby",
-  ".rake": "ruby",
-  ".gemspec": "ruby",
-  ".ru": "ruby",
-  ".erb": "erb",
-  ".html.erb": "erb",
-  ".js.erb": "erb",
-  ".css.erb": "erb",
-  ".json.erb": "erb",
-  ".rs": "rust",
-  ".scss": "scss",
-  ".sass": "sass",
-  ".scala": "scala",
-  ".shader": "shaderlab",
-  ".sh": "shellscript",
-  ".bash": "shellscript",
-  ".zsh": "shellscript",
-  ".ksh": "shellscript",
-  ".sql": "sql",
-  ".svelte": "svelte",
-  ".swift": "swift",
-  ".ts": "typescript",
-  ".tsx": "typescriptreact",
-  ".mts": "typescript",
-  ".cts": "typescript",
-  ".mtsx": "typescriptreact",
-  ".ctsx": "typescriptreact",
-  ".xml": "xml",
-  ".xsl": "xsl",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".vue": "vue",
-  ".zig": "zig",
-  ".zon": "zig",
-  ".astro": "astro",
-  ".ml": "ocaml",
-  ".mli": "ocaml",
-  ".tf": "terraform",
-  ".tfvars": "terraform-vars",
-  ".hcl": "hcl",
-  ".nix": "nix",
-  ".typ": "typst",
-  ".typc": "typst",
-  ".ets": "typescript",
-  ".lhs": "haskell",
-  ".kt": "kotlin",
-  ".kts": "kotlin",
-  ".prisma": "prisma",
-  // Additional extensions not in OpenCode
-  ".h": "c",
-  ".hpp": "cpp",
-  ".hh": "cpp",
-  ".hxx": "cpp",
-  ".h++": "cpp",
-  ".objc": "objective-c",
-  ".objcpp": "objective-cpp",
-  ".fish": "fish",
-  ".graphql": "graphql",
-  ".gql": "graphql",
-}

package/src/tools/lsp/lsp-client-connection.ts

@@ -1,66 +0,0 @@
-import { pathToFileURL } from "node:url"
-
-import { LSPClientTransport } from "./lsp-client-transport"
-
-export class LSPClientConnection extends LSPClientTransport {
-  async initialize(): Promise<void> {
-    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,
-    })
-    this.sendNotification("initialized")
-    this.sendNotification("workspace/didChangeConfiguration", {
-      settings: { json: { validate: { enable: true } } },
-    })
-    await new Promise((r) => setTimeout(r, 300))
-  }
-}

package/src/tools/lsp/lsp-client-transport.ts

@@ -1,210 +0,0 @@
-import { Readable, Writable } from "node:stream"
-import { delimiter } from "path"
-import {
-  createMessageConnection,
-  StreamMessageReader,
-  StreamMessageWriter,
-  type MessageConnection,
-} from "vscode-jsonrpc/node"
-import type { Diagnostic, ResolvedServer } from "./types"
-import { spawnProcess, type UnifiedProcess } from "./lsp-process"
-import { getLspServerAdditionalPathBases } from "./server-path-bases"
-import { log } from "../../shared/logger"
-export class LSPClientTransport {
-  protected proc: UnifiedProcess | null = null
-  protected connection: MessageConnection | null = null
-  protected readonly stderrBuffer: string[] = []
-  protected processExited = false
-  protected readonly diagnosticsStore = new Map<string, Diagnostic[]>()
-  protected readonly REQUEST_TIMEOUT = 15000
-
-  constructor(protected root: string, protected server: ResolvedServer) {}
-  async start(): Promise<void> {
-    const env = {
-      ...process.env,
-      ...this.server.env,
-    }
-    const pathValue = process.platform === "win32" ? env.PATH ?? env.Path ?? "" : env.PATH ?? ""
-    const spawnPath = [pathValue, ...getLspServerAdditionalPathBases(this.root)]
-      .filter(Boolean)
-      .join(delimiter)
-    if (process.platform === "win32" && env.Path !== undefined) {
-      env.Path = spawnPath
-    }
-    env.PATH = spawnPath
-
-    this.proc = spawnProcess(this.server.command, {
-      cwd: this.root,
-      env,
-    })
-    if (!this.proc) {
-      throw new Error(`Failed to spawn LSP server: ${this.server.command.join(" ")}`)
-    }
-    this.startStderrReading()
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    if (this.proc.exitCode !== null) {
-      const stderr = this.stderrBuffer.join("\n")
-      throw new Error(`LSP server exited immediately with code ${this.proc.exitCode}` + (stderr ? `\nstderr: ${stderr}` : ""))
-    }
-
-    const stdoutReader = this.proc.stdout.getReader()
-    const nodeReadable = new Readable({
-      async read() {
-        try {
-          const { done, value } = await stdoutReader.read()
-          if (done || !value) {
-            this.push(null)
-          } else {
-            this.push(Buffer.from(value))
-          }
-        } catch {
-          this.push(null)
-        }
-      },
-    })
-
-    const stdin = this.proc.stdin
-    const nodeWritable = new Writable({
-      write(chunk, _encoding, callback) {
-        try {
-          stdin.write(chunk)
-          callback()
-        } catch (err) {
-          callback(err as Error)
-        }
-      },
-    })
-
-    this.connection = createMessageConnection(new StreamMessageReader(nodeReadable), new StreamMessageWriter(nodeWritable))
-
-    this.connection.onNotification("textDocument/publishDiagnostics", (params: { uri?: string; diagnostics?: Diagnostic[] }) => {
-      if (params.uri) {
-        this.diagnosticsStore.set(params.uri, params.diagnostics ?? [])
-      }
-    })
-
-    this.connection.onRequest("workspace/configuration", (params: { items?: Array<{ section?: string }> }) => {
-      const items = params?.items ?? []
-      return items.map((item) => {
-        if (item.section === "json") return { validate: { enable: true } }
-        return {}
-      })
-    })
-
-    this.connection.onRequest("client/registerCapability", () => null)
-    this.connection.onRequest("window/workDoneProgress/create", () => null)
-
-    this.connection.onClose(() => {
-      this.processExited = true
-    })
-
-    this.connection.onError((error) => {
-      log("LSP connection error:", error)
-    })
-
-    this.connection.listen()
-  }
-
-  protected startStderrReading(): void {
-    if (!this.proc) return
-    const reader = this.proc.stderr.getReader()
-    const read = async () => {
-      const decoder = new TextDecoder()
-      try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          const text = decoder.decode(value)
-          this.stderrBuffer.push(text)
-          if (this.stderrBuffer.length > 100) {
-            this.stderrBuffer.shift()
-          }
-        }
-      } catch {}
-    }
-    read()
-  }
-
-  protected sendRequest<T>(method: string): Promise<T>
-  protected sendRequest<T>(method: string, params: unknown): Promise<T>
-  protected async sendRequest<T>(method: string, ...args: [] | [unknown]): Promise<T> {
-    if (!this.connection) throw new Error("LSP client not started")
-
-    if (this.processExited || (this.proc && this.proc.exitCode !== null)) {
-      const stderr = this.stderrBuffer.slice(-10).join("\n")
-      throw new Error(`LSP server already exited (code: ${this.proc?.exitCode})` + (stderr ? `\nstderr: ${stderr}` : ""))
-    }
-
-    let timeoutId: ReturnType<typeof setTimeout>
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      timeoutId = setTimeout(() => {
-        const stderr = this.stderrBuffer.slice(-5).join("\n")
-        reject(new Error(`LSP request timeout (method: ${method})` + (stderr ? `\nrecent stderr: ${stderr}` : "")))
-      }, this.REQUEST_TIMEOUT)
-    })
-
-    const requestPromise = this.connection.sendRequest(method, ...args) as Promise<T>
-
-    try {
-      const result = await Promise.race([requestPromise, timeoutPromise])
-      clearTimeout(timeoutId!)
-      return result
-    } catch (error) {
-      clearTimeout(timeoutId!)
-      throw error
-    }
-  }
-
-  protected sendNotification(method: string): void
-  protected sendNotification(method: string, params: unknown): void
-  protected sendNotification(method: string, ...args: [] | [unknown]): void {
-    if (!this.connection) return
-    if (this.processExited || (this.proc && this.proc.exitCode !== null)) return
-    this.connection.sendNotification(method, ...args)
-  }
-
-  isAlive(): boolean {
-    return this.proc !== null && !this.processExited && this.proc.exitCode === null
-  }
-
-  async stop(): Promise<void> {
-    if (this.connection) {
-      try {
-        this.sendNotification("shutdown", {})
-        this.sendNotification("exit")
-      } catch {}
-      this.connection.dispose()
-      this.connection = null
-    }
-    const proc = this.proc
-    if (proc) {
-      this.proc = null
-      let exitedBeforeTimeout = false
-      try {
-        proc.kill()
-        // Wait for exit with timeout to prevent indefinite hang
-        let timeoutId: ReturnType<typeof setTimeout> | undefined
-        const timeoutPromise = new Promise<void>((resolve) => {
-          timeoutId = setTimeout(resolve, 5000)
-        })
-        await Promise.race([
-          proc.exited.then(() => {
-            exitedBeforeTimeout = true
-          }).finally(() => timeoutId && clearTimeout(timeoutId)),
-          timeoutPromise,
-        ])
-        if (!exitedBeforeTimeout) {
-          log("[LSPClient] Process did not exit within timeout, escalating to SIGKILL")
-          try {
-            proc.kill("SIGKILL")
-            // Wait briefly for SIGKILL to take effect
-            await Promise.race([proc.exited, new Promise<void>((resolve) => setTimeout(resolve, 1000))])
-          } catch {}
-        }
-      } catch {}
-    }
-    this.processExited = true
-    this.diagnosticsStore.clear()
-  }
-}