feat: cherry-pick 2 upstream features (PRs anomalyco#9126, anomalyco#14085)

- anomalyco#9126: Add experimental Ruff language server support for Python
  projects. Enabled via OPENCODE_EXPERIMENTAL_LSP_RUFF flag. Detects
  virtual environments and supports all Python file extensions.

- anomalyco#14085: Configurable tool alias map for repairing miscalled tools.
  LLMs frequently call wrong tool names (todo_write→todowrite,
  search→grep). Adds experimental.tool_aliases config to map
  common mistakes to correct tool names.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: EBrown

packages/opencode/src/config/config.ts

@@ -1190,6 +1190,10 @@ export namespace Config {
             .positive()
             .optional()
             .describe("Timeout in milliseconds for model context protocol (MCP) requests"),
+          tool_aliases: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe("Map of alias → canonical tool name for repairing miscalled tools"),
         })
         .optional(),
     })

packages/opencode/src/flag/flag.ts

@@ -54,6 +54,7 @@ export namespace Flag {
   export const OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX")
   export const OPENCODE_EXPERIMENTAL_OXFMT = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT")
   export const OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY")
+  export const OPENCODE_EXPERIMENTAL_LSP_RUFF = truthy("OPENCODE_EXPERIMENTAL_LSP_RUFF")
   export const OPENCODE_EXPERIMENTAL_LSP_TOOL = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL")
   export const OPENCODE_DISABLE_FILETIME_CHECK = truthy("OPENCODE_DISABLE_FILETIME_CHECK")
   export const OPENCODE_EXPERIMENTAL_PLAN_MODE = OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE")

packages/opencode/src/lsp/index.ts

@@ -62,17 +62,26 @@ export namespace LSP {
   export type DocumentSymbol = z.infer<typeof DocumentSymbol>
 
   const filterExperimentalServers = (servers: Record<string, LSPServer.Info>) => {
+    const disable = (id: string, reason?: string) => {
+      if (!servers[id]) return
+      if (reason) log.info(reason)
+      delete servers[id]
+    }
+
     if (Flag.OPENCODE_EXPERIMENTAL_LSP_TY) {
-      // If experimental flag is enabled, disable pyright
-      if (servers["pyright"]) {
-        log.info("LSP server pyright is disabled because OPENCODE_EXPERIMENTAL_LSP_TY is enabled")
-        delete servers["pyright"]
-      }
-    } else {
-      // If experimental flag is disabled, disable ty
-      if (servers["ty"]) {
-        delete servers["ty"]
-      }
+      disable("pyright", "LSP server pyright is disabled because OPENCODE_EXPERIMENTAL_LSP_TY is enabled")
+    }
+
+    if (!Flag.OPENCODE_EXPERIMENTAL_LSP_TY) {
+      disable("ty")
+    }
+
+    if (Flag.OPENCODE_EXPERIMENTAL_LSP_RUFF) {
+      disable("pyright", "LSP server pyright is disabled because OPENCODE_EXPERIMENTAL_LSP_RUFF is enabled")
+    }
+
+    if (!Flag.OPENCODE_EXPERIMENTAL_LSP_RUFF) {
+      disable("ruff")
     }
   }
 

packages/opencode/src/lsp/server.ts

@@ -502,6 +502,57 @@ export namespace LSPServer {
     },
   }
 
+  export const Ruff: Info = {
+    id: "ruff",
+    extensions: [".py", ".pyi"],
+    root: NearestRoot([
+      "pyproject.toml",
+      "ruff.toml",
+      ".ruff.toml",
+      "setup.py",
+      "setup.cfg",
+      "requirements.txt",
+      "Pipfile",
+    ]),
+    async spawn(root) {
+      if (!Flag.OPENCODE_EXPERIMENTAL_LSP_RUFF) {
+        return undefined
+      }
+
+      const venvs = [process.env["VIRTUAL_ENV"], path.join(root, ".venv"), path.join(root, "venv")].filter(
+        (p): p is string => p !== undefined,
+      )
+
+      const binary = await (async () => {
+        const direct = Bun.which("ruff")
+        if (direct) return direct
+
+        for (const venv of venvs) {
+          const windows = process.platform === "win32"
+          const candidate = windows ? path.join(venv, "Scripts", "ruff.exe") : path.join(venv, "bin", "ruff")
+          if (await Bun.file(candidate).exists()) {
+            return candidate
+          }
+        }
+
+        return undefined
+      })()
+
+      if (!binary) {
+        log.error("ruff not found, please install ruff first")
+        return
+      }
+
+      const proc = spawn(binary, ["server"], {
+        cwd: root,
+      })
+
+      return {
+        process: proc,
+      }
+    },
+  }
+
   export const Pyright: Info = {
     id: "pyright",
     extensions: [".py", ".pyi"],

packages/opencode/src/session/llm.ts

@@ -176,21 +176,51 @@ export namespace LLM {
         })
       },
       async experimental_repairToolCall(failed) {
-        const lower = failed.toolCall.toolName.toLowerCase()
-        if (lower !== failed.toolCall.toolName && tools[lower]) {
+        const name = failed.toolCall.toolName
+        // try lowercase first
+        if (name !== name.toLowerCase() && tools[name.toLowerCase()]) {
           l.info("repairing tool call", {
-            tool: failed.toolCall.toolName,
-            repaired: lower,
+            tool: name,
+            repaired: name.toLowerCase(),
           })
-          return {
-            ...failed.toolCall,
-            toolName: lower,
+          return { ...failed.toolCall, toolName: name.toLowerCase() }
+        }
+        // try stripping underscores/hyphens and case-insensitive match
+        // handles todo_write -> todowrite, Web_Fetch -> webfetch, etc.
+        const normalized = name.replace(/[-_]/g, "").toLowerCase()
+        for (const toolName of Object.keys(tools)) {
+          if (toolName.toLowerCase() === normalized) {
+            l.info("repairing tool call", {
+              tool: name,
+              repaired: toolName,
+            })
+            return { ...failed.toolCall, toolName }
           }
         }
+        // try alias lookup (config overrides builtins)
+        const builtinAliases: Record<string, string> = {
+          search: "grep",
+          find: "glob",
+          cat: "read",
+          run: "bash",
+          shell: "bash",
+          todo: "todowrite",
+          fetch: "webfetch",
+        }
+        const userAliases = cfg.experimental?.tool_aliases ?? {}
+        const aliases = { ...builtinAliases, ...userAliases }
+        const aliasTarget = aliases[name] ?? aliases[name.toLowerCase()] ?? aliases[normalized]
+        if (aliasTarget && tools[aliasTarget]) {
+          l.info("repairing tool call via alias", {
+            tool: name,
+            alias: aliasTarget,
+          })
+          return { ...failed.toolCall, toolName: aliasTarget }
+        }
         return {
           ...failed.toolCall,
           input: JSON.stringify({
-            tool: failed.toolCall.toolName,
+            tool: name,
             error: failed.error.message,
           }),
           toolName: "invalid",