onlycode 1.18.0 → 1.20.0

package/src/tool/edit.txt

@@ -1,10 +0,0 @@
-Performs exact string replacements in files. 
-
-Usage:
-- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
-- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + colon + space (e.g., `1: `). Everything after that space is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.
-- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
-- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-- The edit will FAIL if `oldString` is not found in the file with an error "oldString not found in content".
-- The edit will FAIL if `oldString` is found multiple times in the file with an error "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match." Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every instance of `oldString`. 
-- Use `replaceAll` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.

package/src/tool/edit.zh.txt

@@ -1,10 +0,0 @@
-在文件中执行精确的字符串替换。
-
-用法：
-- 在编辑之前，您必须在对话中至少使用一次 `Read` 工具。如果您尝试在未读取文件的情况下进行编辑，此工具将报错。
-- 编辑来自 Read 工具输出的文本时，请确保保留行号前缀之后的精确缩进（制表符/空格）。行号前缀格式为：行号 + 冒号 + 空格（例如，`1: `）。该空格之后的所有内容都是要匹配的实际文件内容。切勿在 oldString 或 newString 中包含行号前缀的任何部分。
-- 始终优先编辑代码库中的现有文件。除非明确要求，否则切勿写入新文件。
-- 仅在用户明确请求时才使用表情符号。除非被要求，否则避免在文件中添加表情符号。
-- 如果在文件中未找到 `oldString`，编辑将失败，并显示错误 "oldString not found in content"。
-- 如果在文件中找到多个 `oldString` 匹配项，编辑将失败，并显示错误 "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match."。请提供更大的字符串和更多周围上下文以使其唯一，或使用 `replaceAll` 更改 `oldString` 的每个实例。
-- 使用 `replaceAll` 在文件中替换和重命名字符串。例如，如果您想重命名变量，此参数很有用。

package/src/tool/external-directory.ts

@@ -1,49 +0,0 @@
-import path from "path"
-import { Effect } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import type * as Tool from "./tool"
-import { containsPath } from "../project/instance-context"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-
-type Kind = "file" | "directory"
-
-type Options = {
-  bypass?: boolean
-  kind?: Kind
-}
-
-export const assertExternalDirectoryEffect = Effect.fn("Tool.assertExternalDirectory")(function* (
-  ctx: Tool.Context,
-  target?: string,
-  options?: Options,
-) {
-  if (!target) return false
-
-  if (options?.bypass) return false
-
-  const ins = yield* InstanceState.context
-  const full = process.platform === "win32" ? FSUtil.normalizePath(target) : target
-  if (containsPath(full, ins)) return false
-
-  const kind = options?.kind ?? "file"
-  const dir = kind === "directory" ? full : path.dirname(full)
-  const glob =
-    process.platform === "win32"
-      ? FSUtil.normalizePathPattern(path.join(dir, "*"))
-      : path.join(dir, "*").replaceAll("\\", "/")
-
-  yield* ctx.ask({
-    permission: "external_directory",
-    patterns: [glob],
-    always: [glob],
-    metadata: {
-      filepath: full,
-      parentDir: dir,
-    },
-  })
-  return true
-})
-
-export async function assertExternalDirectory(ctx: Tool.Context, target?: string, options?: Options) {
-  return Effect.runPromise(assertExternalDirectoryEffect(ctx, target, options))
-}

package/src/tool/glob.ts

@@ -1,78 +0,0 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Ripgrep } from "@opencode-ai/core/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./glob.txt"
-import DESCRIPTION_ZH from "./glob.zh.txt"
-import * as Tool from "./tool"
-import { loadDescription } from "./description"
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The glob pattern to match files against" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`,
-  }),
-})
-
-export const GlobTool = Tool.define(
-  "glob",
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const ripgrep = yield* Ripgrep.Service
-    return {
-      description: loadDescription(DESCRIPTION, DESCRIPTION_ZH),
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const ins = yield* InstanceState.context
-          yield* ctx.ask({
-            permission: "glob",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-            },
-          })
-
-          let search = params.path ?? ins.directory
-          search = path.isAbsolute(search) ? search : path.resolve(ins.directory, search)
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          if (info?.type === "File") {
-            throw new Error(`glob path must be a directory: ${search}`)
-          }
-          yield* assertExternalDirectoryEffect(ctx, search, {
-            bypass: false,
-            kind: "directory",
-          })
-
-          const limit = 100
-          const files = yield* ripgrep.glob({ cwd: search, pattern: params.pattern, limit })
-          const truncated = files.length === limit
-
-          const output = []
-          if (files.length === 0) output.push("No files found")
-          if (files.length > 0) {
-            output.push(...files.map((file) => path.resolve(search, file.path)))
-            if (truncated) {
-              output.push("")
-              output.push(
-                `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`,
-              )
-            }
-          }
-
-          return {
-            title: path.relative(ins.worktree, search),
-            metadata: {
-              count: files.length,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/glob.txt

@@ -1,6 +0,0 @@
-- Fast file pattern matching tool that works with any codebase size
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns matching file paths
-- Use this tool when you need to find files by name patterns
-- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
-- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.

package/src/tool/glob.zh.txt

@@ -1,6 +0,0 @@
-- 快速文件模式匹配工具，适用于任何大小的代码库
-- 支持 glob 模式，如 "**/*.js" 或 "src/**/*.ts"
-- 返回匹配的文件路径
-- 当您需要按名称模式查找文件时使用此工具
-- 当您进行可能需要多轮 glob 和 grep 的开放式搜索时，请改用 Task 工具
-- 您可以在单个响应中调用多个工具。最好作为一批推测性地执行多个可能有用的搜索。

package/src/tool/grep.ts

@@ -1,114 +0,0 @@
-import path from "path"
-import { Effect, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { Ripgrep } from "@opencode-ai/core/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./grep.txt"
-import DESCRIPTION_ZH from "./grep.zh.txt"
-import * as Tool from "./tool"
-import { loadDescription } from "./description"
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The regex pattern to search for in file contents" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: "The directory to search in. Defaults to the current working directory.",
-  }),
-  include: Schema.optional(Schema.String).annotate({
-    description: 'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")',
-  }),
-})
-
-export const GrepTool = Tool.define(
-  "grep",
-  Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    const ripgrep = yield* Ripgrep.Service
-    return {
-      description: loadDescription(DESCRIPTION, DESCRIPTION_ZH),
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string; include?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const empty = {
-            title: params.pattern,
-            metadata: { matches: 0, truncated: false },
-            output: "No files found",
-          }
-          if (!params.pattern) {
-            throw new Error("pattern is required")
-          }
-
-          yield* ctx.ask({
-            permission: "grep",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-              include: params.include,
-            },
-          })
-
-          const ins = yield* InstanceState.context
-          const requested = path.isAbsolute(params.path ?? ins.directory)
-            ? (params.path ?? ins.directory)
-            : path.join(ins.directory, params.path ?? ".")
-          const requestedInfo = yield* fs.stat(requested).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          yield* assertExternalDirectoryEffect(ctx, requested, {
-            bypass: false,
-            kind: requestedInfo?.type === "Directory" ? "directory" : "file",
-          })
-
-          const search = FSUtil.resolve(requested)
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          const cwd = info?.type === "Directory" ? search : path.dirname(search)
-          const result = yield* ripgrep.grep({
-            cwd,
-            pattern: params.pattern,
-            include: params.include,
-            limit: 100,
-          })
-          if (result.length === 0) return empty
-
-          const rows = result.map((item) => ({
-            path: path.resolve(cwd, item.entry.path),
-            line: item.line,
-            text: item.text,
-          }))
-
-          const limit = 100
-          const truncated = rows.length === limit
-          const final = rows
-          if (final.length === 0) return empty
-
-          const total = rows.length
-          const hasMore = truncated || result.length === limit
-          const output = [`Found ${total} matches${hasMore ? " (more matches available)" : ""}`]
-
-          let current = ""
-          for (const match of final) {
-            if (current !== match.path) {
-              if (current !== "") output.push("")
-              current = match.path
-              output.push(`${match.path}:`)
-            }
-            output.push(`  Line ${match.line}: ${match.text}`)
-          }
-
-          if (truncated) {
-            output.push("")
-            output.push("(Results truncated. Consider using a more specific path or pattern.)")
-          }
-
-          return {
-            title: params.pattern,
-            metadata: {
-              matches: total,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/grep.txt

@@ -1,8 +0,0 @@
-- Fast content search tool that works with any codebase size
-- Searches file contents using regular expressions
-- Supports full regex syntax (eg. "log.*Error", "function\s+\w+", etc.)
-- Filter files by pattern with the include parameter (eg. "*.js", "*.{ts,tsx}")
-- Returns file paths and line numbers with matching lines
-- Use this tool when you need to find files containing specific patterns
-- If you need to identify/count the number of matches within files, use the Bash tool with `rg` (ripgrep) directly. Do NOT use `grep`.
-- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead

package/src/tool/grep.zh.txt

@@ -1,8 +0,0 @@
-- 快速内容搜索工具，适用于任何大小的代码库
-- 使用正则表达式搜索文件内容
-- 支持完整的正则表达式语法（例如 "log.*Error"、"function\s+\w+" 等）
-- 使用 include 参数按模式筛选文件（例如 "*.js"、"*.{ts,tsx}"）
-- 返回文件路径和包含匹配行的行号
-- 当您需要查找包含特定模式的文件时使用此工具
-- 如果需要识别/计算文件中的匹配次数，请直接使用带有 `rg`（ripgrep）的 Bash 工具。不要使用 `grep`。
-- 当您进行可能需要多轮 glob 和 grep 的开放式搜索时，请改用 Task 工具

package/src/tool/invalid.ts

@@ -1,21 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-
-export const Parameters = Schema.Struct({
-  tool: Schema.String,
-  error: Schema.String,
-})
-
-export const InvalidTool = Tool.define(
-  "invalid",
-  Effect.succeed({
-    description: "Do not use",
-    parameters: Parameters,
-    execute: (params: { tool: string; error: string }) =>
-      Effect.succeed({
-        title: "Invalid Tool",
-        output: `The arguments provided to the tool are invalid: ${params.error}`,
-        metadata: {},
-      }),
-  }),
-)

package/src/tool/json-schema.ts

@@ -1,164 +0,0 @@
-import type { JSONSchema7 } from "@ai-sdk/provider"
-import { JsonSchema, Schema } from "effect"
-import type * as Tool from "./tool"
-
-type JsonObject = Record<string, unknown>
-const cache = new WeakMap<Schema.Top, JSONSchema7>()
-
-export function fromSchema(schema: Schema.Top): JSONSchema7 {
-  const cached = cache.get(schema)
-  if (cached) return cached
-
-  const document = Schema.toJsonSchemaDocument(schema, { additionalProperties: true })
-  const result = normalize({
-    $schema: JsonSchema.META_SCHEMA_URI_DRAFT_2020_12,
-    ...document.schema,
-    ...(Object.keys(document.definitions).length > 0 ? { $defs: document.definitions } : {}),
-  })
-  const inlined = dropDefinitionsIfResolved(inlineLocalReferences(result))
-  if (!isJsonSchema(inlined)) throw new Error("tool JSON Schema helper produced a non-schema value")
-  cache.set(schema, inlined)
-  return inlined
-}
-
-export function fromTool(tool: Tool.Def): JSONSchema7 {
-  return tool.jsonSchema ?? fromSchema(tool.parameters as Schema.Top)
-}
-
-function normalize(value: unknown, options: { stripNull?: boolean } = {}): unknown {
-  if (Array.isArray(value)) return value.map((item) => normalize(item))
-  if (!isRecord(value)) return value
-
-  const required = Array.isArray(value.required)
-    ? new Set(value.required.filter((item) => typeof item === "string"))
-    : undefined
-  const schema = Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [
-      key,
-      key === "properties" && isRecord(item)
-        ? Object.fromEntries(
-            Object.entries(item).map(([name, property]) => [
-              name,
-              normalize(property, { stripNull: !required?.has(name) }),
-            ]),
-          )
-        : normalize(item),
-    ]),
-  )
-
-  if (schema.additionalProperties === true) delete schema.additionalProperties
-
-  if (options.stripNull && Array.isArray(schema.anyOf)) {
-    const withoutNull = schema.anyOf.filter((item) => !isRecord(item) || item.type !== "null")
-    if (withoutNull.length !== schema.anyOf.length) return normalize({ ...schema, anyOf: withoutNull })
-  }
-
-  if (Array.isArray(schema.anyOf)) {
-    const withoutNull = schema.anyOf
-    const number = withoutNull.find((item) => isRecord(item) && item.type === "number")
-    const nonFinite = withoutNull.filter(
-      (item) => isRecord(item) && Array.isArray(item.enum) && item.enum.every((entry) => isNonFiniteNumber(entry)),
-    )
-    if (number && nonFinite.length === withoutNull.length - 1) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ ...number, ...rest })
-    }
-
-    if (isEmptyStructUnion(withoutNull)) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ type: "object", properties: {}, ...rest })
-    }
-
-    if (withoutNull.length === 1 && isRecord(withoutNull[0])) {
-      const { anyOf: _, ...rest } = schema
-      return normalize({ ...withoutNull[0], ...rest })
-    }
-  }
-
-  if (Array.isArray(schema.allOf) && schema.allOf.every(isRecord) && canFlattenAllOf(schema.allOf, schema)) {
-    const { allOf, ...rest } = schema
-    return normalize({ ...Object.assign({}, ...allOf), ...rest })
-  }
-
-  if (schema.type === "integer" && schema.maximum === undefined) {
-    return { minimum: Number.MIN_SAFE_INTEGER, ...schema, maximum: Number.MAX_SAFE_INTEGER }
-  }
-
-  return schema
-}
-
-function isRecord(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function isJsonSchema(value: unknown): value is JSONSchema7 {
-  return typeof value === "boolean" || isRecord(value)
-}
-
-function isNonFiniteNumber(value: unknown) {
-  return value === "NaN" || value === "Infinity" || value === "-Infinity"
-}
-
-function isEmptyStructUnion(items: unknown[]) {
-  return (
-    items.length === 2 &&
-    items.some((item) => isRecord(item) && item.type === "object" && item.properties === undefined) &&
-    items.some((item) => isRecord(item) && item.type === "array" && item.items === undefined)
-  )
-}
-
-function canFlattenAllOf(allOf: JsonObject[], parent: JsonObject) {
-  const keys = new Set(Object.keys(parent).filter((key) => key !== "allOf"))
-  return allOf.every((item) =>
-    Object.keys(item).every((key) => {
-      if (keys.has(key)) return false
-      keys.add(key)
-      return true
-    }),
-  )
-}
-
-function inlineLocalReferences(value: unknown, definitions?: JsonObject, seen = new Set<string>()): unknown {
-  if (Array.isArray(value)) return value.map((item) => inlineLocalReferences(item, definitions, seen))
-  if (!isRecord(value)) return value
-
-  const localDefinitions = definitions ?? (isRecord(value.$defs) ? value.$defs : undefined)
-  if (typeof value.$ref === "string" && localDefinitions) {
-    const name = value.$ref.match(/^#\/\$defs\/(.+)$/)?.[1] ?? value.$ref.match(/^#\/definitions\/(.+)$/)?.[1]
-    if (name && !seen.has(name)) {
-      const target = localDefinitions[name]
-      if (target) {
-        const { $ref: _, ...rest } = value
-        return inlineLocalReferences(
-          { ...(isRecord(target) ? target : {}), ...rest },
-          localDefinitions,
-          new Set(seen).add(name),
-        )
-      }
-    }
-  }
-
-  return Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [key, inlineLocalReferences(item, localDefinitions, seen)]),
-  )
-}
-
-function dropDefinitionsIfResolved(value: unknown): unknown {
-  if (!isRecord(value) || hasLocalReference(value)) return value
-  const { $defs: _, definitions: __, ...rest } = value
-  return rest
-}
-
-function hasLocalReference(value: unknown): boolean {
-  if (Array.isArray(value)) return value.some(hasLocalReference)
-  if (!isRecord(value)) return false
-  if (
-    typeof value.$ref === "string" &&
-    (value.$ref.startsWith("#/$defs/") || value.$ref.startsWith("#/definitions/"))
-  ) {
-    return true
-  }
-  return Object.values(value).some(hasLocalReference)
-}
-
-export * as ToolJsonSchema from "./json-schema"

package/src/tool/lsp.ts

@@ -1,115 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import path from "path"
-import { LSP } from "@/lsp/lsp"
-import DESCRIPTION from "./lsp.txt"
-import DESCRIPTION_ZH from "./lsp.zh.txt"
-import { InstanceState } from "@/effect/instance-state"
-import { pathToFileURL } from "url"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import { loadDescription } from "./description"
-
-const operations = [
-  "goToDefinition",
-  "findReferences",
-  "hover",
-  "documentSymbol",
-  "workspaceSymbol",
-  "goToImplementation",
-  "prepareCallHierarchy",
-  "incomingCalls",
-  "outgoingCalls",
-] as const
-
-export const Parameters = Schema.Struct({
-  operation: Schema.Literals(operations).annotate({ description: "The LSP operation to perform" }),
-  filePath: Schema.String.annotate({ description: "The absolute or relative path to the file" }),
-  line: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
-    description: "The line number (1-based, as shown in editors)",
-  }),
-  character: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
-    description: "The character offset (1-based, as shown in editors)",
-  }),
-  query: Schema.optional(Schema.String).annotate({
-    description: "Search query for workspaceSymbol. Empty string requests all symbols.",
-  }),
-})
-
-export const LspTool = Tool.define(
-  "lsp",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const fs = yield* FSUtil.Service
-    return {
-      description: loadDescription(DESCRIPTION, DESCRIPTION_ZH),
-      parameters: Parameters,
-      execute: (args: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const instance = yield* InstanceState.context
-          const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(instance.directory, args.filePath)
-          yield* assertExternalDirectoryEffect(ctx, file)
-          const meta =
-            args.operation === "workspaceSymbol"
-              ? { operation: args.operation }
-              : args.operation === "documentSymbol"
-                ? { operation: args.operation, filePath: file }
-                : { operation: args.operation, filePath: file, line: args.line, character: args.character }
-          yield* ctx.ask({
-            permission: "lsp",
-            patterns: ["*"],
-            always: ["*"],
-            metadata: meta,
-          })
-
-          const uri = pathToFileURL(file).href
-          const position = { file, line: args.line - 1, character: args.character - 1 }
-          const relPath = path.relative(instance.worktree, file)
-          const detail =
-            args.operation === "workspaceSymbol"
-              ? ""
-              : args.operation === "documentSymbol"
-                ? relPath
-                : `${relPath}:${args.line}:${args.character}`
-          const title = detail ? `${args.operation} ${detail}` : args.operation
-
-          const exists = yield* fs.existsSafe(file)
-          if (!exists) throw new Error(`File not found: ${file}`)
-
-          const available = yield* lsp.hasClients(file)
-          if (!available) throw new Error("No LSP server available for this file type.")
-
-          yield* lsp.touchFile(file, "document")
-
-          const result: unknown[] = yield* (() => {
-            switch (args.operation) {
-              case "goToDefinition":
-                return lsp.definition(position)
-              case "findReferences":
-                return lsp.references(position)
-              case "hover":
-                return lsp.hover(position)
-              case "documentSymbol":
-                return lsp.documentSymbol(uri)
-              case "workspaceSymbol":
-                return lsp.workspaceSymbol(args.query ?? "")
-              case "goToImplementation":
-                return lsp.implementation(position)
-              case "prepareCallHierarchy":
-                return lsp.prepareCallHierarchy(position)
-              case "incomingCalls":
-                return lsp.incomingCalls(position)
-              case "outgoingCalls":
-                return lsp.outgoingCalls(position)
-            }
-          })()
-
-          return {
-            title,
-            metadata: { result },
-            output: result.length === 0 ? `No results found for ${args.operation}` : JSON.stringify(result, null, 2),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/lsp.txt

@@ -1,24 +0,0 @@
-Interact with Language Server Protocol (LSP) servers to get code intelligence features.
-
-Supported operations:
-- goToDefinition: Find where a symbol is defined
-- findReferences: Find all references to a symbol
-- hover: Get hover information (documentation, type info) for a symbol
-- documentSymbol: Get all symbols (functions, classes, variables) in a document
-- workspaceSymbol: List project-wide symbols matching a query string
-- goToImplementation: Find implementations of an interface or abstract method
-- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
-- incomingCalls: Find all functions/methods that call the function at a position
-- outgoingCalls: Find all functions/methods called by the function at a position
-
-All operations require:
-- filePath: The file to operate on
-- line: The line number (1-based, as shown in editors)
-- character: The character offset (1-based, as shown in editors)
-
-workspaceSymbol also accepts:
-- query: A query string to filter symbols by. Empty string requests all symbols.
-
-For workspaceSymbol, filePath is not sent in the LSP workspace/symbol request. It is used by opencode to select and start the matching LSP server.
-
-Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.

package/src/tool/lsp.zh.txt

@@ -1,24 +0,0 @@
-与语言服务器协议（LSP）服务器交互以获取代码智能功能。
-
-支持的操作：
-- goToDefinition：查找符号定义的位置
-- findReferences：查找符号的所有引用
-- hover：获取符号的悬停信息（文档、类型信息）
-- documentSymbol：获取文档中的所有符号（函数、类、变量）
-- workspaceSymbol：列出与查询字符串匹配的项目范围符号
-- goToImplementation：查找接口或抽象方法的实现
-- prepareCallHierarchy：获取某个位置的调用层次结构项（函数/方法）
-- incomingCalls：查找调用某个位置函数的所有函数/方法
-- outgoingCalls：查找某个位置函数调用的所有函数/方法
-
-所有操作都需要：
-- filePath：要操作的文件
-- line：行号（从 1 开始，如编辑器中所示）
-- character：字符偏移量（从 1 开始，如编辑器中所示）
-
-workspaceSymbol 还接受：
-- query：用于筛选符号的查询字符串。空字符串请求所有符号。
-
-对于 workspaceSymbol，filePath 不会发送到 LSP workspace/symbol 请求中。OnlyCode 使用它来选择和启动匹配的 LSP 服务器。
-
-注意：必须为文件类型配置 LSP 服务器。如果没有可用的服务器，将返回错误。