oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/skills/lsp-setup/references/rust/README.md

@@ -0,0 +1,59 @@
+# Rust — LSP setup
+
+- **Builtin server:** `rust` — `rust-analyzer`
+- **Extensions:** `.rs`
+- **Install hint:** `rustup component add rust-analyzer`
+
+## Install
+
+- **macOS:** `rustup component add rust-analyzer` (or `brew install rust-analyzer`)
+- **Linux:** `rustup component add rust-analyzer`
+- **Windows:** `rustup component add rust-analyzer`
+
+The rustup component is the recommended path — it stays pinned to your toolchain.
+`rust-analyzer` also needs the `rust-src` component to index the standard library
+(`rustup component add rust-src`).
+
+Confirm it resolves:
+
+```bash
+command -v rust-analyzer
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "rust": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+None commonly required. To switch the check command to clippy:
+
+```json
+{ "lsp": { "rust": { "initialization": { "check": { "command": "clippy" } } } } }
+```
+
+## Alternatives
+
+None — `rust-analyzer` is the official and sole Rust language server.
+
+## Troubleshooting
+- **PATH:** `rust-analyzer` must be on PATH; reopen shell after install. The rustup shim lives in `~/.cargo/bin`.
+- **Exits while loading rust-src:** if rust-analyzer crashes during stdlib indexing, reinstall the source component:
+
+  ```bash
+  rustup component remove rust-src && rustup component add rust-src
+  ```
+
+- **No proc-macro / build script support:** ensure the project builds with `cargo check`; rust-analyzer reuses the same toolchain.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/file.rs
+```

package/packages/omo-codex/plugin/skills/lsp-setup/references/swift/README.md

@@ -0,0 +1,51 @@
+# Swift — LSP setup
+
+- **Builtin server:** `sourcekit-lsp` — `sourcekit-lsp`
+- **Extensions:** `.swift .objc .objcpp`
+- **Install hint:** `Included with Xcode or the Swift toolchain`
+
+## Install
+
+`sourcekit-lsp` ships with the Swift toolchain — no separate install.
+
+- **macOS:** `xcode-select --install` (or install full Xcode). It resolves to the active toolchain selected by `xcode-select`.
+- **Linux:** Install a swift.org toolchain (`sourcekit-lsp` ships inside it); add the toolchain's `usr/bin` to PATH.
+- **Windows:** Install the swift.org Windows toolchain; `sourcekit-lsp` is bundled.
+
+Confirm it resolves:
+
+```bash
+command -v sourcekit-lsp
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "sourcekit-lsp": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+None commonly required. For best results the project needs a **SwiftPM `Package.swift`** or a `compile_commands.json` compilation database so the server can resolve modules. Pure-Xcode-project files without these resolve poorly.
+
+## Alternatives
+
+- **No mainstream alternative.** `sourcekit-lsp` is the official Apple/swift.org server and the only practical choice.
+
+## Troubleshooting
+
+- **PATH:** `sourcekit-lsp` on PATH; reopen shell after install (or after `xcode-select -s`).
+- **Wrong toolchain (macOS):** point `xcode-select` at the right Xcode/toolchain; mismatches cause stale or missing results.
+- **No `Package.swift` / compile db:** add a SwiftPM manifest or generate `compile_commands.json` for accurate indexing.
+- **Objective-C (`.objc`/`.objcpp`):** needs a compilation database to resolve headers and frameworks.
+- **First build slow:** the server builds the module graph on first open; wait for it.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/File.swift
+```

package/packages/omo-codex/plugin/skills/lsp-setup/references/terraform/README.md

@@ -0,0 +1,62 @@
+# Terraform — LSP setup
+
+- **Builtin server:** `terraform` — `terraform-ls serve`
+- **Extensions:** `.tf .tfvars`
+- **Install hint:** See https://github.com/hashicorp/terraform-ls
+
+An alias id `terraform-ls` exists with the identical command; either id works.
+
+## Install
+
+- **macOS:** `brew install hashicorp/tap/terraform-ls`
+- **Linux:** download a release from https://github.com/hashicorp/terraform-ls/releases and place `terraform-ls` on PATH (or `apt`/`dnf` via the HashiCorp repo)
+- **Windows:** `choco install terraform-ls` (or download a release zip)
+
+`terraform-ls` requires the `terraform` binary itself to be installed and on PATH.
+
+Confirm both resolve:
+
+```bash
+command -v terraform-ls
+command -v terraform
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "terraform": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+None commonly required. Provider/module completion comes from schemas generated by `terraform init`. Run it in each module root before expecting full completion:
+
+```bash
+terraform init
+```
+
+To force schema indexing, you can set experimental features via `initialization`:
+
+```json
+{ "lsp": { "terraform": { "initialization": { "experimentalFeatures": { "validateOnSave": true } } } } }
+```
+
+## Alternatives
+
+- `tflint` standalone for opinionated linting (complements the LSP).
+- `terraform fmt` for formatting.
+
+## Troubleshooting
+- **PATH:** `terraform-ls` AND `terraform` both on PATH; reopen shell after install.
+- **No provider completion:** run `terraform init` so the `.terraform/` schema cache exists.
+- **`.tfvars` not analyzed:** open the containing module so the server has root context.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/file.tf
+```

package/packages/omo-codex/plugin/skills/lsp-setup/references/typescript/README.md

@@ -0,0 +1,77 @@
+# TypeScript / JavaScript — LSP setup
+
+- **Builtin server:** `typescript` — `typescript-language-server --stdio`
+- **Extensions:** `.ts .tsx .js .jsx .mjs .cjs .mts .cts`
+- **Install hint:** `npm install -g typescript-language-server typescript`
+
+## Install
+
+- **macOS:** `npm install -g typescript-language-server typescript`
+- **Linux:** `npm install -g typescript-language-server typescript`
+- **Windows:** `npm install -g typescript-language-server typescript` (PowerShell or cmd)
+
+`typescript-language-server` is only a thin wrapper — it needs the `typescript`
+package (`tsserver`) present too, either globally or in the project's
+`node_modules`. Always install both.
+
+Confirm it resolves:
+
+```bash
+command -v typescript-language-server
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "typescript": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+None commonly required. To favor inlay hints or tweak preferences:
+
+```json
+{ "lsp": { "typescript": { "initialization": { "preferences": { "includeInlayParameterNameHints": "all" } } } } }
+```
+
+## Alternatives
+
+All builtin — pick by toolchain. Raise the alternative's `priority` and/or
+`disabled` the default so the file routes to your choice:
+
+| id           | command                                  | when to choose                          |
+| ------------ | ---------------------------------------- | --------------------------------------- |
+| `deno`       | `deno lsp`                               | Deno projects (handles `.ts/.tsx/.js`)  |
+| `biome`      | `biome lsp-proxy --stdio`                | Biome lint/format as the LSP            |
+| `eslint`     | `vscode-eslint-language-server --stdio`  | ESLint diagnostics (install below)      |
+| `oxlint`     | `oxlint --lsp`                           | fast Oxc-based linting                  |
+| `vue`        | `vue-language-server --stdio`            | `.vue` single-file components           |
+| `svelte`     | `svelteserver --stdio`                   | `.svelte` files                         |
+| `astro`      | `astro-ls --stdio`                       | `.astro` files                          |
+
+`eslint` install: `npm i -g vscode-langservers-extracted`.
+
+Pick Deno or Biome over the default:
+
+```json
+{ "lsp": {
+  "typescript": { "disabled": true },
+  "deno": { "priority": 100 }
+} }
+```
+
+(Swap `"deno"` for `"biome"` to use Biome instead.)
+
+## Troubleshooting
+- **PATH:** `typescript-language-server` must be on PATH; reopen shell after `npm i -g`. Check your global bin with `npm bin -g`.
+- **Missing tsserver:** errors like "Could not find tsserver" mean the `typescript` package is absent — install it globally or in the project.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/file.ts
+```

package/packages/omo-codex/plugin/skills/lsp-setup/references/yaml/README.md

@@ -0,0 +1,70 @@
+# YAML — LSP setup
+
+- **Builtin server:** `yaml-ls` — `yaml-language-server --stdio`
+- **Extensions:** `.yaml .yml`
+- **Install hint:** `npm install -g yaml-language-server`
+
+## Install
+
+- **macOS:** `npm install -g yaml-language-server`
+- **Linux:** `npm install -g yaml-language-server`
+- **Windows:** `npm install -g yaml-language-server` (PowerShell)
+
+Confirm it resolves:
+
+```bash
+command -v yaml-language-server
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "yaml-ls": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+Schema association is the main reason to configure yaml-ls. Map globs to a schema URL or local path under `yaml.schemas`:
+
+```json
+{
+  "lsp": {
+    "yaml-ls": {
+      "initialization": {
+        "yaml": {
+          "schemas": {
+            "https://json.schemastore.org/github-workflow.json": ".github/workflows/*.yml",
+            "https://json.schemastore.org/kustomization.json": "kustomization.yaml",
+            "./schemas/my-config.schema.json": "config/*.yaml"
+          },
+          "validate": true,
+          "completion": true,
+          "format": { "enable": true }
+        }
+      }
+    }
+  }
+}
+```
+
+Set `"yaml.schemaStore": { "enable": true }` to auto-resolve schemas from SchemaStore (catalog at https://www.schemastore.org/). Inline `# yaml-language-server: $schema=<url>` modelines also work without config.
+
+## Alternatives
+
+- `redhat.vscode-yaml` bundles the same server in editors.
+- `yamllint` standalone for style/lint-only checks.
+
+## Troubleshooting
+- **PATH:** `yaml-language-server` on PATH; reopen shell after `npm -g` install.
+- **No validation:** no schema matched — add a `yaml.schemas` glob or a `$schema` modeline.
+- **Wrong schema applied:** SchemaStore guessed by filename; pin explicitly under `yaml.schemas`.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/file.yaml
+```

package/packages/omo-codex/plugin/skills/lsp-setup/references/zig/README.md

@@ -0,0 +1,49 @@
+# Zig — LSP setup
+
+- **Builtin server:** `zls` — `zls`
+- **Extensions:** `.zig .zon`
+- **Install hint:** `https://github.com/zigtools/zls`
+
+## Install
+
+ZLS (the Zig Language Server) must be built against the **same Zig version** you use.
+See `https://github.com/zigtools/zls`.
+
+- **macOS:** `brew install zls`
+- **Linux:** download a prebuilt release matching your Zig version, or `zig build -Doptimize=ReleaseSafe` from the zls source
+- **Windows:** download the matching release from the zls GitHub releases, or build from source
+
+Confirm it resolves:
+
+```bash
+command -v zls
+```
+
+## Configure
+
+Builtin — usually NO config needed (auto-resolved by extension). Configure only to set priority, init options, override extensions, or disable. Same JSON shape in `.codex/lsp-client.json` (Codex) AND `.opencode/lsp.json` (OpenCode/omo):
+
+```json
+{ "lsp": { "zls": { "priority": 100 } } }
+```
+
+For builtin ids in a PROJECT config, `command` is supplied automatically — only set `priority`/`initialization`/`extensions`/`disabled`/`env`. A fully custom (non-builtin) server with its own `command` must go in the USER config (`~/.codex/lsp-client.json`).
+
+### Initialization options (only if commonly needed)
+
+None commonly required.
+
+## Alternatives
+
+None.
+
+## Troubleshooting
+- **VERSION MATCH (critical):** zls version MUST match your zig version — build/install zls against the exact same Zig. A mismatch causes crashes, parse errors, or silent failures. After upgrading Zig, upgrade/rebuild zls too.
+- **PATH:** `zls` must be on PATH; reopen the shell after install.
+- **zig not found:** zls invokes `zig` for builds — make sure `zig` itself is also on PATH.
+
+## Verify
+
+```bash
+bun ../../scripts/verify-lsp.ts path/to/file.zig
+```

package/packages/omo-codex/plugin/skills/lsp-setup/scripts/detect-lsp.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+// detect-lsp.ts <targetDir> [--json] — scan a directory for source languages and
+// report, per detected language: the builtin LSP server, whether its executable
+// is on PATH, an install hint, and whether a project LSP config references it.
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { delimiter, extname, join, sep } from "node:path"
+import process from "node:process"
+
+import { LANGUAGES, type LanguageServer, PROJECT_CONFIG_FILES } from "./lsp-server-table"
+
+const SKIP_DIRECTORIES = new Set<string>([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	"out",
+	"target",
+	".venv",
+	"venv",
+	"vendor",
+	".cache",
+	"__pycache__",
+	".turbo",
+	"coverage",
+])
+
+const MAX_FILES = 50_000
+
+// Mirrors effectiveExtension() in packages/lsp-tools-mcp/src/lsp/effective-extension.ts:
+// extensionless Dockerfile/Containerfile resolve to .dockerfile (exact-case basenames).
+const BASENAME_EXTENSIONS: Record<string, string> = {
+	Dockerfile: ".dockerfile",
+	Containerfile: ".dockerfile",
+}
+
+interface ConfigFileState {
+	readonly path: string
+	readonly exists: boolean
+	readonly serverIds: readonly string[]
+}
+
+interface DetectionResult {
+	readonly server: LanguageServer
+	readonly executable: string
+	readonly installed: boolean
+	readonly resolvedPath: string | null
+	readonly configuredIn: readonly string[]
+}
+
+function collectExtensions(root: string): ReadonlySet<string> {
+	const found = new Set<string>()
+	const stack: string[] = [root]
+	let visited = 0
+
+	while (stack.length > 0) {
+		const current = stack.pop()
+		if (current === undefined) break
+
+		let entries: string[]
+		try {
+			entries = readdirSync(current)
+		} catch {
+			continue
+		}
+
+		for (const entry of entries) {
+			if (visited >= MAX_FILES) return found
+			const fullPath = join(current, entry)
+
+			let kind: "dir" | "file" | "other" = "other"
+			try {
+				const stat = statSync(fullPath)
+				kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other"
+			} catch {
+				continue
+			}
+
+			if (kind === "dir") {
+				if (!SKIP_DIRECTORIES.has(entry)) stack.push(fullPath)
+			} else if (kind === "file") {
+				visited += 1
+				const ext = (BASENAME_EXTENSIONS[entry] ?? extname(entry)).toLowerCase()
+				if (ext.length > 0) found.add(ext)
+			}
+		}
+	}
+
+	return found
+}
+
+function pathDirectories(): readonly string[] {
+	return (process.env["PATH"] ?? "").split(delimiter).filter((dir: string) => dir.length > 0)
+}
+
+function resolveExecutable(command: string): string | null {
+	const extensions =
+		process.platform === "win32" ? (process.env["PATHEXT"]?.split(";") ?? [".EXE", ".CMD", ".BAT"]) : [""]
+	const bases = command.includes("/") || command.includes(sep) ? [command] : pathDirectories().map((dir: string) => join(dir, command))
+
+	for (const base of bases) {
+		for (const ext of extensions) {
+			const candidate = ext.length > 0 ? `${base}${ext}` : base
+			try {
+				if (existsSync(candidate) && statSync(candidate).isFile()) return candidate
+			} catch {
+				continue
+			}
+		}
+	}
+	return null
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function parseConfiguredServerIds(path: string): readonly string[] {
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf-8"))
+	} catch {
+		return []
+	}
+	if (!isRecord(parsed)) return []
+	const lsp = parsed["lsp"]
+	return isRecord(lsp) ? Object.keys(lsp) : []
+}
+
+function readConfigState(root: string): readonly ConfigFileState[] {
+	return PROJECT_CONFIG_FILES.map((relative: string): ConfigFileState => {
+		const path = join(root, relative)
+		if (!existsSync(path)) return { path: relative, exists: false, serverIds: [] }
+		return { path: relative, exists: true, serverIds: parseConfiguredServerIds(path) }
+	})
+}
+
+function detect(root: string, configState: readonly ConfigFileState[]): readonly DetectionResult[] {
+	const extensions = collectExtensions(root)
+	const results: DetectionResult[] = []
+
+	for (const server of LANGUAGES) {
+		if (!server.extensions.some((ext: string) => extensions.has(ext))) continue
+
+		const executable = server.command[0] ?? server.serverId
+		const resolvedPath = resolveExecutable(executable)
+		const configuredIn = configState
+			.filter((state) => state.serverIds.includes(server.serverId))
+			.map((state) => state.path)
+
+		results.push({ server, executable, installed: resolvedPath !== null, resolvedPath, configuredIn })
+	}
+
+	return results
+}
+
+function renderReport(root: string, results: readonly DetectionResult[], configState: readonly ConfigFileState[]): string {
+	const lines: string[] = [`LSP setup scan: ${root}`]
+	const configSummary = configState
+		.map((state) => `${state.path} (${state.exists ? `present: ${state.serverIds.length} server(s)` : "absent"})`)
+		.join(", ")
+	lines.push(`Config files: ${configSummary}`, "")
+
+	if (results.length === 0) {
+		lines.push("No languages with a builtin LSP server were detected here.")
+		return lines.join("\n")
+	}
+
+	lines.push("DETECTED LANGUAGES (primary builtin server per language)")
+	for (const result of results) {
+		const mark = result.installed ? "OK  " : "MISS"
+		const state = result.installed ? `installed (${result.resolvedPath})` : "NOT installed"
+		const config = result.configuredIn.length > 0 ? `configured in ${result.configuredIn.join(", ")}` : "builtin-default"
+		lines.push(`[${mark}] ${result.server.language.padEnd(12)} server=${result.server.serverId}  exe=${result.executable}  ${state}  ${config}`)
+		if (!result.installed) lines.push(`        install: ${result.server.installHint}`)
+	}
+
+	const missing = results.filter((result) => !result.installed)
+	lines.push(
+		"",
+		missing.length === 0
+			? `All ${results.length} detected server(s) installed.`
+			: `${missing.length}/${results.length} server(s) NOT installed: ${missing.map((m) => m.server.language).join(", ")}`,
+		"Next: read references/<language>/README.md, then configure .codex/lsp-client.json AND .opencode/lsp.json.",
+	)
+	return lines.join("\n")
+}
+
+function main(): void {
+	const args = process.argv.slice(2)
+	const wantsJson = args.includes("--json")
+	const root = args.find((arg: string) => !arg.startsWith("--")) ?? process.cwd()
+
+	if (!existsSync(root)) {
+		process.stderr.write(`detect-lsp: target directory does not exist: ${root}\n`)
+		process.exit(2)
+	}
+
+	const configState = readConfigState(root)
+	const results = detect(root, configState)
+
+	if (wantsJson) {
+		process.stdout.write(`${JSON.stringify({ root, configState, results }, null, 2)}\n`)
+		return
+	}
+	process.stdout.write(`${renderReport(root, results, configState)}\n`)
+}
+
+main()