oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/skills/ast-grep/install.sh

@@ -0,0 +1,286 @@
+#!/usr/bin/env bash
+#
+# install.sh - install the ast-grep binary on POSIX systems (macOS, Linux, WSL, Git Bash).
+#
+# Tries package managers in priority order, then falls back to downloading a
+# pinned release binary from GitHub into <skill_root>/bin/sg.
+#
+# Order:
+#   1. Already installed?  -> nothing to do
+#   2. Homebrew (brew)
+#   3. npm (@ast-grep/cli)
+#   4. cargo binstall (faster) or cargo install (slower)
+#   5. pip (ast-grep-cli)
+#   6. nix-env (NixOS / Nix users)
+#   7. mise (asdf successor)
+#   8. GitHub release tarball -> <skill_root>/bin/sg
+#
+# Flags:
+#   --method=<m>     Force one method: brew | npm | cargo | pip | nix | mise | github
+#   --version=<v>    Pin a specific version when downloading from GitHub
+#   --no-fallback    Don't fall back to GitHub tarball; fail if all package managers miss
+#   --quiet, -q      Suppress non-error output
+#
+# Exit codes:
+#   0  Installed (or already present)
+#   1  Argument error
+#   2  All install methods failed
+#   3  Network failure during GitHub fallback
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_ROOT="$SCRIPT_DIR"
+CACHE_BIN_DIR="${OMO_AST_GREP_BIN_DIR:-$SKILL_ROOT/bin}"
+
+PINNED_VERSION="0.43.0"
+FORCED_METHOD=""
+USE_FALLBACK=1
+QUIET=0
+
+log() {
+  if [ "$QUIET" -eq 0 ]; then
+    printf '[install.sh] %s\n' "$*" >&2
+  fi
+}
+
+err() {
+  printf '[install.sh] error: %s\n' "$*" >&2
+}
+
+usage() {
+  sed -n '2,/^set -/p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//;/^set -/d'
+  exit "${1:-0}"
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --method=*) FORCED_METHOD="${1#*=}" ;;
+    --version=*) PINNED_VERSION="${1#*=}" ;;
+    --no-fallback) USE_FALLBACK=0 ;;
+    --quiet|-q) QUIET=1 ;;
+    --help|-h) usage 0 ;;
+    *) err "unknown argument: $1"; usage 1 ;;
+  esac
+  shift
+done
+
+# --- detect platform -----------------------------------------------------
+
+detect_os() {
+  case "$(uname -s)" in
+    Darwin) echo "darwin" ;;
+    Linux) echo "linux" ;;
+    MINGW*|MSYS*|CYGWIN*) echo "windows" ;;
+    *) echo "unknown" ;;
+  esac
+}
+
+detect_arch() {
+  case "$(uname -m)" in
+    arm64|aarch64) echo "aarch64" ;;
+    x86_64|amd64) echo "x86_64" ;;
+    *) echo "unknown" ;;
+  esac
+}
+
+OS="$(detect_os)"
+ARCH="$(detect_arch)"
+
+# --- already installed? --------------------------------------------------
+
+ast_grep_present() {
+  if command -v ast-grep >/dev/null 2>&1; then
+    return 0
+  fi
+  if command -v sg >/dev/null 2>&1; then
+    if [ "$OS" = "linux" ]; then
+      if "$(command -v sg)" --version 2>/dev/null | grep -qi 'ast-grep'; then
+        return 0
+      fi
+      return 1
+    fi
+    return 0
+  fi
+  if [ -x "$CACHE_BIN_DIR/sg" ] || [ -x "$CACHE_BIN_DIR/ast-grep" ]; then
+    return 0
+  fi
+  return 1
+}
+
+if [ -z "$FORCED_METHOD" ] && ast_grep_present; then
+  log "ast-grep already installed: $(command -v ast-grep 2>/dev/null || command -v sg)"
+  exit 0
+fi
+
+# --- per-method installers -----------------------------------------------
+
+try_brew() {
+  command -v brew >/dev/null 2>&1 || return 1
+  log "trying: brew install ast-grep"
+  brew install ast-grep && return 0 || return 1
+}
+
+try_npm() {
+  command -v npm >/dev/null 2>&1 || return 1
+  log "trying: npm install -g @ast-grep/cli"
+  npm install -g @ast-grep/cli && return 0 || return 1
+}
+
+try_cargo() {
+  if command -v cargo-binstall >/dev/null 2>&1; then
+    log "trying: cargo binstall ast-grep"
+    cargo binstall -y ast-grep && return 0 || true
+  fi
+  if command -v cargo >/dev/null 2>&1; then
+    log "trying: cargo install ast-grep --locked"
+    cargo install ast-grep --locked && return 0 || return 1
+  fi
+  return 1
+}
+
+try_pip() {
+  if command -v pipx >/dev/null 2>&1; then
+    log "trying: pipx install ast-grep-cli"
+    pipx install ast-grep-cli && return 0 || true
+  fi
+  command -v pip3 >/dev/null 2>&1 || command -v pip >/dev/null 2>&1 || return 1
+  PIP="$(command -v pip3 || command -v pip)"
+  log "trying: $PIP install --user ast-grep-cli"
+  $PIP install --user ast-grep-cli && return 0 || return 1
+}
+
+try_nix() {
+  command -v nix-env >/dev/null 2>&1 || return 1
+  log "trying: nix-env -iA nixpkgs.ast-grep"
+  nix-env -iA nixpkgs.ast-grep && return 0 || return 1
+}
+
+try_mise() {
+  command -v mise >/dev/null 2>&1 || return 1
+  log "trying: mise use -g ast-grep"
+  mise use -g ast-grep && return 0 || return 1
+}
+
+# Tarball assets are named like:
+#   app-aarch64-apple-darwin.zip
+#   app-x86_64-apple-darwin.zip
+#   app-aarch64-unknown-linux-gnu.zip
+#   app-x86_64-unknown-linux-gnu.zip
+#   app-x86_64-pc-windows-msvc.zip   (.zip only on windows)
+
+triple_for() {
+  case "$OS-$ARCH" in
+    darwin-aarch64) echo "aarch64-apple-darwin" ;;
+    darwin-x86_64)  echo "x86_64-apple-darwin" ;;
+    linux-aarch64)  echo "aarch64-unknown-linux-gnu" ;;
+    linux-x86_64)   echo "x86_64-unknown-linux-gnu" ;;
+    *) echo "" ;;
+  esac
+}
+
+try_github() {
+  TRIPLE="$(triple_for)"
+  if [ -z "$TRIPLE" ]; then
+    err "no GitHub release asset for $OS-$ARCH; install via package manager or build from source."
+    return 1
+  fi
+
+  command -v curl >/dev/null 2>&1 || command -v wget >/dev/null 2>&1 || {
+    err "need curl or wget for GitHub fallback"
+    return 1
+  }
+
+  ASSET="app-${TRIPLE}.zip"
+  URL="https://github.com/ast-grep/ast-grep/releases/download/${PINNED_VERSION}/${ASSET}"
+  TMP="$(mktemp -d -t ast-grep-install-XXXXXX)"
+  trap 'rm -rf "$TMP"' RETURN
+
+  log "downloading $URL"
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$URL" -o "$TMP/$ASSET" || return 3
+  else
+    wget -q "$URL" -O "$TMP/$ASSET" || return 3
+  fi
+
+  command -v unzip >/dev/null 2>&1 || {
+    err "need 'unzip' to extract GitHub release archives"
+    return 1
+  }
+
+  unzip -q "$TMP/$ASSET" -d "$TMP/extract"
+  mkdir -p "$CACHE_BIN_DIR"
+  if [ -f "$TMP/extract/ast-grep" ]; then
+    mv "$TMP/extract/ast-grep" "$CACHE_BIN_DIR/sg"
+  elif [ -f "$TMP/extract/sg" ]; then
+    mv "$TMP/extract/sg" "$CACHE_BIN_DIR/sg"
+  else
+    err "no ast-grep or sg binary found inside $ASSET"
+    return 1
+  fi
+  chmod +x "$CACHE_BIN_DIR/sg"
+
+  log "installed cached binary: $CACHE_BIN_DIR/sg"
+  log "verify: $CACHE_BIN_DIR/sg --version"
+  log ""
+  log "Add to PATH for direct sg use:"
+  log "  export PATH=\"$CACHE_BIN_DIR:\$PATH\""
+  return 0
+}
+
+# --- dispatch ------------------------------------------------------------
+
+run_method() {
+  case "$1" in
+    brew) try_brew ;;
+    npm) try_npm ;;
+    cargo) try_cargo ;;
+    pip) try_pip ;;
+    nix) try_nix ;;
+    mise) try_mise ;;
+    github) try_github ;;
+    *) err "unknown method: $1"; return 1 ;;
+  esac
+}
+
+if [ -n "$FORCED_METHOD" ]; then
+  if run_method "$FORCED_METHOD"; then
+    exit 0
+  else
+    err "method '$FORCED_METHOD' failed"
+    exit 2
+  fi
+fi
+
+# Try methods in OS-aware priority order.
+case "$OS" in
+  darwin) METHODS=(brew npm cargo pip mise) ;;
+  linux)  METHODS=(npm cargo pip nix mise brew) ;;
+  windows) METHODS=(npm cargo pip mise) ;;
+  *) METHODS=(npm cargo pip) ;;
+esac
+
+for m in "${METHODS[@]}"; do
+  if run_method "$m"; then
+    log "installed via $m"
+    exit 0
+  fi
+  log "$m unavailable or failed; trying next"
+done
+
+if [ "$USE_FALLBACK" -eq 1 ]; then
+  log "all package managers failed; falling back to GitHub release"
+  if try_github; then
+    exit 0
+  fi
+fi
+
+err "all install methods failed."
+err ""
+err "Manual options:"
+err "  brew install ast-grep                 # macOS / linuxbrew"
+err "  npm install -g @ast-grep/cli          # any OS with Node"
+err "  cargo install ast-grep --locked       # any OS with Rust"
+err "  pip install ast-grep-cli              # any OS with Python"
+err "  https://github.com/ast-grep/ast-grep/releases   # manual binary"
+exit 2

package/packages/omo-codex/plugin/skills/ast-grep/references/cli.md

@@ -0,0 +1,231 @@
+# CLI reference — `sg` / `ast-grep`
+
+Compact reference for the underlying `sg` binary that the helper wraps. Use this when the helper isn't enough or when you want to invoke `sg` directly.
+
+> **Binary name on Linux**: prefer `ast-grep` over `sg` because `sg` collides with `setgroups` from `util-linux`.
+
+---
+
+## `sg run` — one-shot search/rewrite
+
+The default subcommand. `sg -p 'foo'` is shorthand for `sg run -p 'foo'`.
+
+```bash
+sg run [OPTIONS] --pattern <PATTERN> [PATHS...]
+```
+
+| Flag | Purpose |
+|---|---|
+| `-p, --pattern <P>` | AST pattern to match. **Always single-quote** in shell to prevent `$VAR` expansion. |
+| `-r, --rewrite <R>` | Replacement pattern. Used with `-U` to apply. |
+| `-l, --lang <LANG>` | Language. Inferred from path extension if omitted. |
+| `--selector <KIND>` | When the pattern is ambiguous, extract only this AST kind. |
+| `--strictness <S>` | `cst` \| `smart` (default) \| `ast` \| `relaxed` \| `signature` |
+| `--debug-query[=<F>]` | Print parsed pattern. F: `pattern` \| `ast` \| `cst` \| `sexp` |
+| `--stdin` | Read code from stdin instead of files. Lang must be set. |
+| `--globs <G>` | Include/exclude glob (repeatable; prefix `!` to exclude). |
+| `--follow` | Follow symlinks. |
+| `--no-ignore <T>` | Disable a class of ignore: `hidden`, `dot`, `exclude`, `global`, `parent`, `vcs`. |
+| `-i, --interactive` | Step through matches and confirm each rewrite. |
+| `-U, --update-all` | Apply all rewrites without confirmation. **Mutually exclusive with `--json`** (silently). |
+| `--json[=<S>]` | Emit JSON. S: `pretty` \| `stream` \| `compact` (compact is best for piping). |
+| `--color <W>` | `auto` \| `always` \| `ansi` \| `never` |
+| `--inspect <G>` | Detail level: `nothing` \| `summary` \| `entity` |
+| `-A, -B, -C <N>` | Context lines after / before / around each match. |
+| `-j, --threads <N>` | Thread count (default: heuristic; `0` = auto). |
+
+### `--update-all` + `--json` — the trap
+
+`sg` silently ignores `--update-all` when `--json` is set. To preview AND apply, run **two passes**:
+
+```bash
+# Pass 1: preview
+sg run -p 'foo()' -r 'bar()' --json=compact src/
+
+# Pass 2: apply
+sg run -p 'foo()' -r 'bar()' --update-all src/
+```
+
+The `ast_grep_helper.py replace --apply` subcommand does this automatically.
+
+### Examples
+
+```bash
+# Basic search
+sg run -p 'console.log($MSG)' --lang ts src/
+
+# Search with context lines
+sg run -p 'eval($CODE)' --lang js -C 3 .
+
+# Rewrite, dry-run preview as JSON
+sg run -p 'console.log($MSG)' -r 'logger.info($MSG)' --json=compact --lang ts src/
+
+# Rewrite, apply
+sg run -p 'console.log($MSG)' -r 'logger.info($MSG)' --update-all --lang ts src/
+
+# Pattern from stdin
+echo 'console.log("x")' | sg run -p 'console.log($MSG)' --lang js --stdin
+
+# Limit to specific files
+sg run -p 'foo()' --lang ts --globs 'src/**/*.ts' --globs '!**/*.test.ts' .
+
+# Debug a pattern that returns 0 matches
+sg run -p 'def $F($$$):' --lang py --debug-query=ast --stdin <<< 'def foo(): pass'
+```
+
+---
+
+## `sg scan` — YAML rule scanner
+
+Run a configuration of YAML rules across files. Used for project-wide lints and codemods.
+
+```bash
+sg scan [OPTIONS] [PATHS...]
+```
+
+| Flag | Purpose |
+|---|---|
+| `-c, --config <C>` | Path to `sgconfig.yml` (default: walk up from cwd looking for one). |
+| `-r, --rule <F>` | Run a **single** rule file. Mutually exclusive with `--config`. |
+| `--inline-rules <Y>` | Pass YAML rule text inline. Use `---` to separate multiple rules. |
+| `--filter <RE>` | Only run rules whose `id` matches this regex. |
+| `--include-metadata` | Include rule `metadata` field in JSON output. |
+| `-U, --update-all` | Apply fixes from `fix:` automatically. |
+| `--report-style <S>` | `rich` \| `medium` \| `short` |
+| `--format <F>` | `github` \| `sarif` (CI-friendly outputs). |
+| `--error[=ID]`, `--warning[=ID]`, `--info[=ID]`, `--hint[=ID]`, `--off[=ID]` | Promote/demote severity. |
+| `-i, --interactive` | Confirm each fix interactively. |
+| `--json[=<S>]` | JSON output. |
+
+### Examples
+
+```bash
+# Run all rules in sgconfig.yml-discovered ruleDirs
+sg scan src/
+
+# Run a single rule file (no sgconfig.yml needed)
+sg scan -r rules/no-console.yml src/
+
+# Inline rule (great for one-offs and CI)
+sg scan --inline-rules '
+id: no-todo
+language: TypeScript
+severity: warning
+rule: { pattern: TODO }' src/
+
+# Apply all auto-fixes
+sg scan -U src/
+
+# CI-friendly GitHub annotations
+sg scan --format github src/
+
+# SARIF for security scanners
+sg scan --format sarif src/ > sarif.json
+```
+
+---
+
+## `sg test` — run rule snapshot tests
+
+```bash
+sg test [OPTIONS]
+```
+
+| Flag | Purpose |
+|---|---|
+| `-c, --config <C>` | Path to `sgconfig.yml`. |
+| `-t, --test-dir <D>` | Test directory. |
+| `--snapshot-dir <D>` | Snapshot directory (default: `__snapshots__`). |
+| `--skip-snapshot-tests` | Validate test code parses; don't compare snapshots. |
+| `-U, --update-all` | Update all changed snapshots. |
+| `-f, --filter <G>` | Filter test cases by glob on rule id. |
+| `--include-off` | Include rules with severity `off`. |
+| `-i, --interactive` | Step through changed snapshots and accept/reject each. |
+
+A test directory looks like:
+
+```
+test/
+├── no-console.yml          # `valid:` and `invalid:` snippets
+└── no-console-test.yml     # alternative test file format
+__snapshots__/
+└── no-console-snapshot.yml # expected match locations
+```
+
+---
+
+## `sg new` — scaffold
+
+```bash
+sg new <COMMAND> [NAME] [OPTIONS]
+```
+
+| Subcommand | Creates |
+|---|---|
+| `project` | `sgconfig.yml`, `rules/`, `utils/`, `__snapshots__/` directory tree |
+| `rule` | A new YAML rule file in the first `ruleDirs` entry |
+| `test` | A new test file in `testConfigs[0].testDir` |
+| `util` | A new utility rule in the first `utilDirs` entry |
+
+```bash
+# New project in current dir
+sg new project --yes
+
+# New rule
+sg new rule no-console --lang typescript
+
+# New test
+sg new test no-console --yes
+```
+
+---
+
+## `sg lsp` — language server
+
+```bash
+sg lsp -c sgconfig.yml
+```
+
+Speak LSP over stdin/stdout. Configure your editor (VS Code extension, Neovim `nvim-lspconfig`, Helix `languages.toml`) to spawn this command for live diagnostics.
+
+---
+
+## `sg completions` — shell completions
+
+```bash
+sg completions bash >> ~/.bashrc
+sg completions zsh > "${fpath[1]}/_sg"
+sg completions fish > ~/.config/fish/completions/sg.fish
+sg completions powershell >> $PROFILE
+```
+
+---
+
+## Useful one-liners
+
+```bash
+# Count matches per file
+sg run -p 'console.log($_)' --lang ts --json=compact . \
+  | jq -r '.[].file' | sort | uniq -c | sort -rn
+
+# Find all unique kinds in a file (great for figuring out kind names)
+sg run -p '$_' --lang ts --debug-query=cst src/foo.ts \
+  | grep -oE 'kind: [a-z_]+' | sort -u
+
+# Rewrite only in a subset of files
+sg run -p 'foo()' -r 'bar()' --update-all --globs 'src/**/*.ts' --globs '!src/legacy/**' .
+
+# Apply fixes from many rules but only ones matching a pattern in their id
+sg scan --filter 'no-' -U src/
+
+# Use ast-grep as a linter in pre-commit
+sg scan --format github src/ || exit 1
+```
+
+---
+
+## See also
+
+- `references/yaml-rules.md` — rule schema (`pattern`, `kind`, `regex`, `inside`, `has`, `all`, `any`, `not`, `matches`, `transform`, `fix`).
+- `references/sgconfig.md` — project configuration.
+- Official: <https://ast-grep.github.io/reference/cli.html>

package/packages/omo-codex/plugin/skills/ast-grep/references/install.md

@@ -0,0 +1,166 @@
+# Install ast-grep
+
+The skill ships an `install.sh` (POSIX) and `install.ps1` (Windows) that try every reasonable method in priority order and fall back to a GitHub release download as a last resort. **You usually do not need to read this page.** Run the installer:
+
+```bash
+bash install.sh                        # macOS / Linux / WSL / Git Bash
+pwsh -File install.ps1                 # Windows PowerShell
+```
+
+This page exists for the (rare) case the installer cannot find a working method, or you want to install ast-grep manually.
+
+---
+
+## Per-OS install commands (verbatim, copy-paste)
+
+### macOS
+
+```bash
+brew install ast-grep                  # Homebrew - the primary path
+sudo port install ast-grep             # MacPorts
+npm install -g @ast-grep/cli           # if you have Node already
+cargo install ast-grep --locked        # if you have Rust already
+```
+
+### Linux
+
+```bash
+# Universal (works on every distro)
+npm install -g @ast-grep/cli
+cargo install ast-grep --locked
+pip install ast-grep-cli
+
+# Distro-specific
+nix-env -iA nixpkgs.ast-grep           # NixOS / Nix
+brew install ast-grep                  # Linuxbrew
+
+# NixOS shell.nix
+nix-shell -p ast-grep
+```
+
+> **Linux gotcha**: the binary is named `sg`, but on most Linux systems `sg` is also the **`setgroups` command** from `util-linux`. The shell sees `setgroups` first and ignores ast-grep. Two options:
+>
+> 1. Always invoke `ast-grep` (full name).
+> 2. Add an alias: `alias sg=ast-grep` in your `~/.bashrc` / `~/.zshrc`.
+>
+> The `ast_grep_helper.py` script in `scripts/` already handles this — when it sees `sg` on PATH on Linux, it runs `--version` and rejects the binary if it isn't ast-grep.
+
+### Windows
+
+```powershell
+scoop install main/ast-grep            # Scoop (most common on dev machines)
+winget install --id ast-grep.ast-grep  # Winget (Microsoft built-in)
+choco install ast-grep                 # Chocolatey
+npm install -g @ast-grep/cli           # any OS with Node
+cargo install ast-grep --locked        # any OS with Rust
+```
+
+### WSL / Git Bash on Windows
+
+Treat as Linux. Use `npm`, `cargo`, `pip`, or `bash install.sh`.
+
+---
+
+## Cross-platform / language-ecosystem methods
+
+These work on every OS:
+
+| Method | Command | Pros | Cons |
+|---|---|---|---|
+| **npm** | `npm install -g @ast-grep/cli` | Fast, prebuilt platform binaries | Needs Node 18+ |
+| **cargo** | `cargo install ast-grep --locked` | Always builds latest from source | Slow (~3-5 min compile) |
+| **cargo binstall** | `cargo binstall ast-grep` | Fast (downloads release binary) | Needs `cargo-binstall` first |
+| **pip** | `pip install ast-grep-cli` | Works in any Python venv | Needs Python 3.8+ |
+| **pipx** | `pipx install ast-grep-cli` | Isolated install | Needs pipx |
+| **mise** | `mise use -g ast-grep` | asdf successor, version-pinning | Needs mise |
+| **GitHub release** | manual download | Pure binary, no toolchain | Manual PATH setup |
+
+---
+
+## GitHub release manual install
+
+If every package manager fails:
+
+```bash
+# 1. Pick the right asset for your OS+arch from the latest release:
+#    https://github.com/ast-grep/ast-grep/releases/latest
+#
+#    Naming pattern:
+#      app-aarch64-apple-darwin.zip          macOS Apple Silicon
+#      app-x86_64-apple-darwin.zip           macOS Intel
+#      app-aarch64-unknown-linux-gnu.zip     Linux ARM64 (glibc)
+#      app-x86_64-unknown-linux-gnu.zip      Linux x86_64 (glibc)
+#      app-x86_64-pc-windows-msvc.zip        Windows x86_64
+#      app-aarch64-pc-windows-msvc.zip       Windows ARM64
+
+# 2. Download and extract:
+VERSION=0.43.0
+TRIPLE=aarch64-apple-darwin
+curl -fsSL "https://github.com/ast-grep/ast-grep/releases/download/${VERSION}/app-${TRIPLE}.zip" -o /tmp/ast-grep.zip
+unzip /tmp/ast-grep.zip -d /tmp/ast-grep
+sudo mv /tmp/ast-grep/ast-grep /usr/local/bin/sg
+sudo chmod +x /usr/local/bin/sg
+
+# 3. Verify:
+sg --version
+```
+
+The skill's `install.sh` does steps 1-3 automatically and drops the binary in `<skill_root>/bin/sg` so you can use it without sudo.
+
+---
+
+## Build from source
+
+```bash
+git clone https://github.com/ast-grep/ast-grep.git
+cd ast-grep
+cargo install --path ./crates/cli --locked
+```
+
+Requires Rust 1.74+. Slowest path; only useful when you need a specific commit or unreleased fix.
+
+---
+
+## Verifying the install
+
+```bash
+ast-grep --version            # or `sg --version`
+# ast-grep 0.43.0
+```
+
+Then sanity-check a real query:
+
+```bash
+echo 'console.log("hello")' | sg run -p 'console.log($MSG)' --lang js --stdin
+```
+
+Expected: a single match with the `console.log("hello")` call highlighted.
+
+---
+
+## Editor integration
+
+After installing the CLI, set up your editor:
+
+- **VS Code**: install the [`ast-grep`](https://marketplace.visualstudio.com/items?itemName=ast-grep.ast-grep-vscode) extension. Requires `sgconfig.yml` in workspace root for live diagnostics.
+- **Neovim**: configure `nvim-lspconfig` with `ast_grep` server, or install [`telescope-ast-grep.nvim`](https://github.com/ray-x/telescope-ast-grep.nvim).
+- **Helix**: add `ast-grep lsp` as a language server in `languages.toml`.
+- **Emacs**: install [`ast-grep.el`](https://github.com/SunskyXH/ast-grep.el).
+
+See `references/cli.md` for `ast-grep lsp` flags.
+
+---
+
+## Uninstall
+
+| Method | Command |
+|---|---|
+| brew | `brew uninstall ast-grep` |
+| npm | `npm uninstall -g @ast-grep/cli` |
+| cargo | `cargo uninstall ast-grep` |
+| pip | `pip uninstall ast-grep-cli` |
+| pipx | `pipx uninstall ast-grep-cli` |
+| scoop | `scoop uninstall ast-grep` |
+| winget | `winget uninstall --id ast-grep.ast-grep` |
+| choco | `choco uninstall ast-grep` |
+| GitHub binary | `rm <skill_root>/bin/sg` |