@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/tools/lsp/lsp-server.ts

@@ -1,217 +0,0 @@
-import { LSPClient } from "./lsp-client";
-import { registerLspManagerProcessCleanup, type LspProcessCleanupHandle } from "./lsp-manager-process-cleanup";
-import { cleanupTempDirectoryLspClients } from "./lsp-manager-temp-directory-cleanup";
-import type { ResolvedServer } from "./types";
-interface ManagedClient {
-  client: LSPClient;
-  lastUsedAt: number;
-  refCount: number;
-  initPromise?: Promise<void>;
-  isInitializing: boolean;
-  initializingSince?: number;
-}
-class LSPServerManager {
-  private static instance: LSPServerManager;
-  private clients = new Map<string, ManagedClient>();
-  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
-  private readonly IDLE_TIMEOUT = 5 * 60 * 1000;
-  private readonly INIT_TIMEOUT = 60 * 1000;
-  private cleanupHandle: LspProcessCleanupHandle | null = null;
-  private constructor() {
-    this.startCleanupTimer();
-    this.registerProcessCleanup();
-  }
-  private registerProcessCleanup(): void {
-    this.cleanupHandle = registerLspManagerProcessCleanup({
-      getClients: () => this.clients.entries(),
-      clearClients: () => {
-        this.clients.clear();
-      },
-      clearCleanupInterval: () => {
-        if (this.cleanupInterval) {
-          clearInterval(this.cleanupInterval);
-          this.cleanupInterval = null;
-        }
-      },
-    });
-  }
-
-  static getInstance(): LSPServerManager {
-    if (!LSPServerManager.instance) {
-      LSPServerManager.instance = new LSPServerManager();
-    }
-    return LSPServerManager.instance;
-  }
-
-  private getKey(root: string, serverId: string): string {
-    return `${root}::${serverId}`;
-  }
-
-  private startCleanupTimer(): void {
-    if (this.cleanupInterval) return;
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupIdleClients();
-    }, 60000);
-    if (typeof this.cleanupInterval === "object" && "unref" in this.cleanupInterval) {
-      this.cleanupInterval.unref();
-    }
-  }
-
-  private cleanupIdleClients(): void {
-    const now = Date.now();
-    for (const [key, managed] of this.clients) {
-      if (managed.refCount === 0 && now - managed.lastUsedAt > this.IDLE_TIMEOUT) {
-        managed.client.stop();
-        this.clients.delete(key);
-      }
-    }
-  }
-
-  async getClient(root: string, server: ResolvedServer): Promise<LSPClient> {
-    const key = this.getKey(root, server.id);
-    let managed = this.clients.get(key);
-    if (managed) {
-      const now = Date.now();
-      if (
-        managed.isInitializing &&
-        managed.initializingSince !== undefined &&
-        now - managed.initializingSince >= this.INIT_TIMEOUT
-      ) {
-        // Stale init can permanently block subsequent calls (e.g., LSP process hang)
-        try {
-          await managed.client.stop();
-        } catch {}
-        this.clients.delete(key);
-        managed = undefined;
-      }
-    }
-    if (managed) {
-      if (managed.initPromise) {
-        try {
-          await managed.initPromise;
-        } catch {
-          // Failed init should not keep the key blocked forever.
-          try {
-            await managed.client.stop();
-          } catch {}
-          this.clients.delete(key);
-          managed = undefined;
-        }
-      }
-
-      if (managed) {
-        if (managed.client.isAlive()) {
-          managed.refCount++;
-          managed.lastUsedAt = Date.now();
-          return managed.client;
-        }
-        try {
-          await managed.client.stop();
-        } catch {}
-        this.clients.delete(key);
-      }
-    }
-
-    const client = new LSPClient(root, server);
-    const initPromise = (async () => {
-      await client.start();
-      await client.initialize();
-    })();
-    const initStartedAt = Date.now();
-    this.clients.set(key, {
-      client,
-      lastUsedAt: initStartedAt,
-      refCount: 1,
-      initPromise,
-      isInitializing: true,
-      initializingSince: initStartedAt,
-    });
-
-    try {
-      await initPromise;
-    } catch (error) {
-      this.clients.delete(key);
-      try {
-        await client.stop();
-      } catch {}
-      throw error;
-    }
-    const m = this.clients.get(key);
-    if (m) {
-      m.initPromise = undefined;
-      m.isInitializing = false;
-      m.initializingSince = undefined;
-    }
-
-    return client;
-  }
-
-  warmupClient(root: string, server: ResolvedServer): void {
-    const key = this.getKey(root, server.id);
-    if (this.clients.has(key)) return;
-    const client = new LSPClient(root, server);
-    const initPromise = (async () => {
-      await client.start();
-      await client.initialize();
-    })();
-
-    const initStartedAt = Date.now();
-    this.clients.set(key, {
-      client,
-      lastUsedAt: initStartedAt,
-      refCount: 0,
-      initPromise,
-      isInitializing: true,
-      initializingSince: initStartedAt,
-    });
-
-    initPromise
-      .then(() => {
-        const m = this.clients.get(key);
-        if (m) {
-          m.initPromise = undefined;
-          m.isInitializing = false;
-          m.initializingSince = undefined;
-        }
-      })
-      .catch(() => {
-        // Warmup failures must not permanently block future initialization.
-        this.clients.delete(key);
-        void client.stop().catch(() => {});
-      });
-  }
-
-  releaseClient(root: string, serverId: string): void {
-    const key = this.getKey(root, serverId);
-    const managed = this.clients.get(key);
-    if (managed && managed.refCount > 0) {
-      managed.refCount--;
-      managed.lastUsedAt = Date.now();
-    }
-  }
-
-  isServerInitializing(root: string, serverId: string): boolean {
-    const key = this.getKey(root, serverId);
-    const managed = this.clients.get(key);
-    return managed?.isInitializing ?? false;
-  }
-
-  async stopAll(): Promise<void> {
-    this.cleanupHandle?.unregister();
-    this.cleanupHandle = null;
-    for (const [, managed] of this.clients) {
-      await managed.client.stop();
-    }
-    this.clients.clear();
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-
-  async cleanupTempDirectoryClients(): Promise<void> {
-    await cleanupTempDirectoryLspClients(this.clients);
-  }
-}
-
-export const lspManager = LSPServerManager.getInstance();

package/src/tools/lsp/rename-tools.ts

@@ -1,53 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-
-import { formatApplyResult, formatPrepareRenameResult } from "./lsp-formatters"
-import { withLspClient } from "./lsp-client-wrapper"
-import { applyWorkspaceEdit } from "./workspace-edit"
-import type { PrepareRenameDefaultBehavior, PrepareRenameResult, WorkspaceEdit } from "./types"
-
-export const lsp_prepare_rename: ToolDefinition = tool({
-  description: "Check if rename is valid. Use BEFORE lsp_rename.",
-  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.prepareRename(args.filePath, args.line, args.character)) as
-          | PrepareRenameResult
-          | PrepareRenameDefaultBehavior
-          | null
-      })
-      const output = formatPrepareRenameResult(result)
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      return output
-    }
-  },
-})
-
-export const lsp_rename: ToolDefinition = tool({
-  description: "Rename symbol across entire workspace. APPLIES changes to all files.",
-  args: {
-    filePath: tool.schema.string(),
-    line: tool.schema.number().min(1).describe("1-based"),
-    character: tool.schema.number().min(0).describe("0-based"),
-    newName: tool.schema.string().describe("New symbol name"),
-  },
-  execute: async (args, _context) => {
-    try {
-      const edit = await withLspClient(args.filePath, async (client) => {
-        return (await client.rename(args.filePath, args.line, args.character, args.newName)) as WorkspaceEdit | null
-      })
-      const result = applyWorkspaceEdit(edit)
-      const output = formatApplyResult(result)
-      return output
-    } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`
-      return output
-    }
-  },
-})

package/src/tools/lsp/server-config-loader.ts

@@ -1,116 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { join } from "path"
-
-import { BUILTIN_SERVERS } from "./constants"
-import type { ResolvedServer } from "./types"
-import { getOpenCodeConfigDir } from "../../shared"
-import { parseJsonc, detectConfigFile, detectPluginConfigFile } from "../../shared/jsonc-parser"
-
-interface LspEntry {
-  disabled?: boolean
-  command?: string[]
-  extensions?: string[]
-  priority?: number
-  env?: Record<string, string>
-  initialization?: Record<string, unknown>
-}
-
-interface ConfigJson {
-  lsp?: Record<string, LspEntry>
-}
-
-type ConfigSource = "project" | "user" | "opencode"
-
-interface ServerWithSource extends ResolvedServer {
-  source: ConfigSource
-}
-
-export function loadJsonFile<T>(path: string): T | null {
-  if (!existsSync(path)) return null
-  try {
-    return parseJsonc(readFileSync(path, "utf-8")) as T
-  } catch {
-    return null
-  }
-}
-
-export function getConfigPaths(): { project: string; user: string; opencode: string } {
-  const cwd = process.cwd()
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" })
-  return {
-    project: detectPluginConfigFile(join(cwd, ".opencode")).path,
-    user: detectPluginConfigFile(configDir).path,
-    opencode: detectConfigFile(join(configDir, "opencode")).path,
-  }
-}
-
-export function loadAllConfigs(): Map<ConfigSource, ConfigJson> {
-  const paths = getConfigPaths()
-  const configs = new Map<ConfigSource, ConfigJson>()
-
-  const project = loadJsonFile<ConfigJson>(paths.project)
-  if (project) configs.set("project", project)
-
-  const user = loadJsonFile<ConfigJson>(paths.user)
-  if (user) configs.set("user", user)
-
-  const opencode = loadJsonFile<ConfigJson>(paths.opencode)
-  if (opencode) configs.set("opencode", opencode)
-
-  return configs
-}
-
-export function getMergedServers(): ServerWithSource[] {
-  const configs = loadAllConfigs()
-  const servers: ServerWithSource[] = []
-  const disabled = new Set<string>()
-  const seen = new Set<string>()
-
-  const sources: ConfigSource[] = ["project", "user", "opencode"]
-
-  for (const source of sources) {
-    const config = configs.get(source)
-    if (!config?.lsp) continue
-
-    for (const [id, entry] of Object.entries(config.lsp)) {
-      if (entry.disabled) {
-        disabled.add(id)
-        continue
-      }
-
-      if (seen.has(id)) continue
-      if (!entry.command || !entry.extensions) continue
-
-      servers.push({
-        id,
-        command: entry.command,
-        extensions: entry.extensions,
-        priority: entry.priority ?? 0,
-        env: entry.env,
-        initialization: entry.initialization,
-        source,
-      })
-      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: "opencode",
-    })
-  }
-
-  return servers.sort((a, b) => {
-    if (a.source !== b.source) {
-      const order: Record<ConfigSource, number> = { project: 0, user: 1, opencode: 2 }
-      return order[a.source] - order[b.source]
-    }
-    return b.priority - a.priority
-  })
-}

package/src/tools/lsp/server-definitions.ts

@@ -1,91 +0,0 @@
-import type { LSPServerConfig } from "./types"
-
-export const LSP_INSTALL_HINTS: Record<string, string> = {
-  typescript: "npm install -g typescript-language-server typescript",
-  deno: "Install Deno from https://deno.land",
-  vue: "npm install -g @vue/language-server",
-  eslint: "npm install -g vscode-langservers-extracted",
-  oxlint: "npm install -g oxlint",
-  biome: "npm install -g @biomejs/biome",
-  gopls: "go install golang.org/x/tools/gopls@latest",
-  "ruby-lsp": "gem install ruby-lsp",
-  basedpyright: "pip install basedpyright",
-  pyright: "pip install pyright",
-  ty: "pip install ty",
-  ruff: "pip install ruff",
-  "elixir-ls": "See https://github.com/elixir-lsp/elixir-ls",
-  zls: "See https://github.com/zigtools/zls",
-  csharp: "dotnet tool install -g csharp-ls",
-  fsharp: "dotnet tool install -g fsautocomplete",
-  "sourcekit-lsp": "Included with Xcode or Swift toolchain",
-  rust: "rustup component add rust-analyzer",
-  clangd: "See https://clangd.llvm.org/installation",
-  svelte: "npm install -g svelte-language-server",
-  astro: "npm install -g @astrojs/language-server",
-  "bash-ls": "npm install -g bash-language-server",
-  jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls",
-  "yaml-ls": "npm install -g yaml-language-server",
-  "lua-ls": "See https://github.com/LuaLS/lua-language-server",
-  php: "npm install -g intelephense",
-  dart: "Included with Dart SDK",
-  "terraform-ls": "See https://github.com/hashicorp/terraform-ls",
-  terraform: "See https://github.com/hashicorp/terraform-ls",
-  prisma: "npm install -g prisma",
-  "ocaml-lsp": "opam install ocaml-lsp-server",
-  texlab: "See https://github.com/latex-lsp/texlab",
-  dockerfile: "npm install -g dockerfile-language-server-nodejs",
-  gleam: "See https://gleam.run/getting-started/installing/",
-  "clojure-lsp": "See https://clojure-lsp.io/installation/",
-  nixd: "nix profile install nixpkgs#nixd",
-  tinymist: "See https://github.com/Myriad-Dreamin/tinymist",
-  "haskell-language-server": "ghcup install hls",
-  bash: "npm install -g bash-language-server",
-  "kotlin-ls": "See https://github.com/Kotlin/kotlin-lsp",
-}
-
-// Synced with OpenCode's server.ts
-// https://github.com/sst/opencode/blob/dev/packages/opencode/src/lsp/server.ts
-export const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, "id">> = {
-  typescript: { command: ["typescript-language-server", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"] },
-  deno: { command: ["deno", "lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"] },
-  vue: { command: ["vue-language-server", "--stdio"], extensions: [".vue"] },
-  eslint: { command: ["vscode-eslint-language-server", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"] },
-  oxlint: { command: ["oxlint", "--lsp"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"] },
-  biome: { command: ["biome", "lsp-proxy", "--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".json", ".jsonc", ".vue", ".astro", ".svelte", ".css", ".graphql", ".gql", ".html"] },
-  gopls: { command: ["gopls"], extensions: [".go"] },
-  "ruby-lsp": { command: ["rubocop", "--lsp"], extensions: [".rb", ".rake", ".gemspec", ".ru"] },
-  basedpyright: { command: ["basedpyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
-  pyright: { command: ["pyright-langserver", "--stdio"], extensions: [".py", ".pyi"] },
-  ty: { command: ["ty", "server"], extensions: [".py", ".pyi"] },
-  ruff: { command: ["ruff", "server"], extensions: [".py", ".pyi"] },
-  "elixir-ls": { command: ["elixir-ls"], extensions: [".ex", ".exs"] },
-  zls: { command: ["zls"], extensions: [".zig", ".zon"] },
-  csharp: { command: ["csharp-ls"], extensions: [".cs"] },
-  fsharp: { command: ["fsautocomplete"], extensions: [".fs", ".fsi", ".fsx", ".fsscript"] },
-  "sourcekit-lsp": { command: ["sourcekit-lsp"], extensions: [".swift", ".objc", ".objcpp"] },
-  rust: { command: ["rust-analyzer"], extensions: [".rs"] },
-  clangd: { command: ["clangd", "--background-index", "--clang-tidy"], extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"] },
-  svelte: { command: ["svelteserver", "--stdio"], extensions: [".svelte"] },
-  astro: { command: ["astro-ls", "--stdio"], extensions: [".astro"] },
-  bash: { command: ["bash-language-server", "start"], extensions: [".sh", ".bash", ".zsh", ".ksh"] },
-  // Keep legacy alias for backward compatibility
-  "bash-ls": { command: ["bash-language-server", "start"], extensions: [".sh", ".bash", ".zsh", ".ksh"] },
-  jdtls: { command: ["jdtls"], extensions: [".java"] },
-  "yaml-ls": { command: ["yaml-language-server", "--stdio"], extensions: [".yaml", ".yml"] },
-  "lua-ls": { command: ["lua-language-server"], extensions: [".lua"] },
-  php: { command: ["intelephense", "--stdio"], extensions: [".php"] },
-  dart: { command: ["dart", "language-server", "--lsp"], extensions: [".dart"] },
-  terraform: { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-  // Legacy alias for backward compatibility
-  "terraform-ls": { command: ["terraform-ls", "serve"], extensions: [".tf", ".tfvars"] },
-  prisma: { command: ["prisma", "language-server"], extensions: [".prisma"] },
-  "ocaml-lsp": { command: ["ocamllsp"], extensions: [".ml", ".mli"] },
-  texlab: { command: ["texlab"], extensions: [".tex", ".bib"] },
-  dockerfile: { command: ["docker-langserver", "--stdio"], extensions: [".dockerfile"] },
-  gleam: { command: ["gleam", "lsp"], extensions: [".gleam"] },
-  "clojure-lsp": { command: ["clojure-lsp", "listen"], extensions: [".clj", ".cljs", ".cljc", ".edn"] },
-  nixd: { command: ["nixd"], extensions: [".nix"] },
-  tinymist: { command: ["tinymist"], extensions: [".typ", ".typc"] },
-  "haskell-language-server": { command: ["haskell-language-server-wrapper", "--lsp"], extensions: [".hs", ".lhs"] },
-  "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] },
-}

package/src/tools/lsp/server-installation.ts

@@ -1,58 +0,0 @@
-import { existsSync } from "fs"
-import { delimiter, join } from "path"
-
-import { getLspServerAdditionalPathBases } from "./server-path-bases"
-
-export function isServerInstalled(command: string[]): boolean {
-  if (command.length === 0) return false
-
-  const cmd = command[0]
-
-  // Support absolute paths (e.g., C:\Users\...\server.exe or /usr/local/bin/server)
-  if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync(cmd)) return true
-  }
-
-  const isWindows = process.platform === "win32"
-
-  let exts = [""]
-  if (isWindows) {
-    const pathExt = process.env.PATHEXT || ""
-    if (pathExt) {
-      const systemExts = pathExt.split(";").filter(Boolean)
-      exts = [...new Set([...exts, ...systemExts, ".exe", ".cmd", ".bat", ".ps1"])]
-    } else {
-      exts = ["", ".exe", ".cmd", ".bat", ".ps1"]
-    }
-  }
-
-  let pathEnv = process.env.PATH || ""
-  if (isWindows && !pathEnv) {
-    pathEnv = process.env.Path || ""
-  }
-
-  const paths = pathEnv.split(delimiter)
-
-  for (const p of paths) {
-    for (const suffix of exts) {
-      if (existsSync(join(p, cmd + suffix))) {
-        return true
-      }
-    }
-  }
-
-  for (const base of getLspServerAdditionalPathBases(process.cwd())) {
-    for (const suffix of exts) {
-      if (existsSync(join(base, cmd + suffix))) {
-        return true
-      }
-    }
-  }
-
-  // Runtime wrappers (bun/node) are always available in hiai-opencode context
-  if (cmd === "bun" || cmd === "node") {
-    return true
-  }
-
-  return false
-}

package/src/tools/lsp/server-path-bases.ts

@@ -1,16 +0,0 @@
-import { join } from "path"
-
-import { getDataDir, getOpenCodeConfigDir } from "../../shared"
-
-export function getLspServerAdditionalPathBases(workingDirectory: string): string[] {
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" })
-  const dataDir = join(getDataDir(), "opencode")
-
-  return [
-    join(workingDirectory, "node_modules", ".bin"),
-    join(configDir, "bin"),
-    join(configDir, "node_modules", ".bin"),
-    join(dataDir, "bin"),
-    join(dataDir, "bin", "node_modules", ".bin"),
-  ]
-}

package/src/tools/lsp/server-resolution.ts

@@ -1,109 +0,0 @@
-import { BUILTIN_SERVERS, LSP_INSTALL_HINTS } from "./constants"
-import { getConfigPaths, getMergedServers, loadAllConfigs } from "./server-config-loader"
-import { isServerInstalled } from "./server-installation"
-import type { ServerLookupResult } from "./types"
-
-export function findServerForExtension(ext: string): ServerLookupResult {
-  const servers = getMergedServers()
-
-  for (const server of servers) {
-    if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
-      return {
-        status: "found",
-        server: {
-          id: server.id,
-          command: server.command,
-          extensions: server.extensions,
-          priority: server.priority,
-          env: server.env,
-          initialization: server.initialization,
-        },
-      }
-    }
-  }
-
-  for (const server of servers) {
-    if (server.extensions.includes(ext)) {
-      const installHint = LSP_INSTALL_HINTS[server.id] || `Install '${server.command[0]}' and ensure it's in your PATH`
-      return {
-        status: "not_installed",
-        server: {
-          id: server.id,
-          command: server.command,
-          extensions: server.extensions,
-        },
-        installHint,
-      }
-    }
-  }
-
-  const availableServers = [...new Set(servers.map((s) => s.id))]
-  return {
-    status: "not_configured",
-    extension: ext,
-    availableServers,
-  }
-}
-
-export function getAllServers(): Array<{
-  id: string
-  installed: boolean
-  extensions: string[]
-  disabled: boolean
-  source: string
-  priority: number
-}> {
-  const configs = loadAllConfigs()
-  const servers = getMergedServers()
-  const disabled = new Set<string>()
-
-  for (const config of configs.values()) {
-    if (!config.lsp) continue
-    for (const [id, entry] of Object.entries(config.lsp)) {
-      if (entry.disabled) disabled.add(id)
-    }
-  }
-
-  const result: Array<{
-    id: string
-    installed: boolean
-    extensions: string[]
-    disabled: boolean
-    source: string
-    priority: number
-  }> = []
-
-  const seen = new Set<string>()
-
-  for (const server of servers) {
-    if (seen.has(server.id)) continue
-    result.push({
-      id: server.id,
-      installed: isServerInstalled(server.command),
-      extensions: server.extensions,
-      disabled: false,
-      source: server.source,
-      priority: server.priority,
-    })
-    seen.add(server.id)
-  }
-
-  for (const id of disabled) {
-    if (seen.has(id)) continue
-    const builtin = BUILTIN_SERVERS[id]
-    result.push({
-      id,
-      installed: builtin ? isServerInstalled(builtin.command) : false,
-      extensions: builtin?.extensions || [],
-      disabled: true,
-      source: "disabled",
-      priority: 0,
-    })
-  }
-
-  return result
-}
-
-export function getConfigPaths_(): { project: string; user: string; opencode: string } {
-  return getConfigPaths()
-}