# SiPi en cualquier editor/IDE

SiPi ya trae un servidor de lenguaje (`src/sipi_lsp.py`) que habla
**LSP** (Language Server Protocol), el mismo protocolo estandar que
usan `pyright`, `rust-analyzer`, `gopls`, etc. Esto significa que SiPi
no depende de que un editor puntual lo "soporte": **cualquier editor
que hable LSP puede usar SiPi**, incluyendo editores nuevos que todavia
no existen hoy, siempre que respeten el protocolo (que es un estandar
abierto, no algo propietario de un editor en particular).

Lo unico que necesita cualquier editor es:
1. Ejecutar `python3 sipi_lsp.py` como subproceso.
2. Hablarle por su entrada/salida estandar (stdin/stdout) usando
   JSON-RPC con framing `Content-Length` -- el formato exacto de LSP.
3. Asociar la extension de archivo `.sipi` (o el lenguaje "sipi") a ese
   servidor.

Que da hoy el servidor: diagnosticos en vivo (bloques sin `fin`,
errores de sintaxis reales) y autocompletado de los ~190 comandos del
lenguaje. Ver los comentarios al principio de `sipi_lsp.py` para el
detalle exacto.

A continuacion, configuracion lista para los editores mas comunes.
Si tu editor no esta en la lista, buscá en su documentacion "language
server" o "LSP client generico" -- casi todos lo tienen, y solo hace
falta indicarle el comando (`python3 sipi_lsp.py`) y la extension
(`.sipi`).

## Visual Studio Code

Carpeta `vscode-sipi/` de este mismo directorio: una extension con dos
capas independientes, para que el editor sea util incluso si una de
las dos no está disponible:

1. **Resaltado de sintaxis y snippets** (`syntaxes/sipi.tmLanguage.json`,
   `snippets/sipi.json`) — funciona sin depender de Python ni de
   `sipi_lsp.py`, apenas se instala la extension. Se generan con
   `generar_gramatica.py` a partir de `COMANDOS_CONOCIDOS` y
   `BLOQUES_QUE_ABREN` del motor real (`sipi.py`), nunca escritos a
   mano — la misma leccion que ya aplico el editor de escritorio
   despues del bug de la v35.0, donde una lista de palabras clave
   copiada a mano se desincronizo del motor real. Correlo de nuevo
   despues de agregar comandos nuevos al lenguaje:
   ```bash
   cd integracion_editores/vscode-sipi
   python3 generar_gramatica.py
   ```
2. **Diagnosticos y autocompletado en vivo**, conectando con
   `sipi_lsp.py` (ver seccion general mas arriba).

Instalacion (mientras no esta publicada en el Marketplace):
```bash
cd integracion_editores/vscode-sipi
npm install
npm install -g @vscode/vsce
vsce package
code --install-extension sipi-lang-1.0.0.vsix
```
Si `sipi_lsp.py` no esta dentro de la carpeta que tenes abierta en VS
Code, configura la ruta manualmente en Preferencias -> `sipi.lspPath`.

## Neovim (nvim-lspconfig)

```lua
local lspconfig = require("lspconfig")
local configs = require("lspconfig.configs")

if not configs.sipi then
  configs.sipi = {
    default_config = {
      cmd = { "python3", "/ruta/completa/a/sipi_lsp.py" },
      filetypes = { "sipi" },
      root_dir = lspconfig.util.root_pattern(".git", "sipi.py"),
    },
  }
end

vim.filetype.add({ extension = { sipi = "sipi" } })
lspconfig.sipi.setup({})
```

## Sublime Text (paquete LSP)

En `Preferences > Package Settings > LSP > Settings`:
```json
{
  "clients": {
    "sipi": {
      "enabled": true,
      "command": ["python3", "/ruta/completa/a/sipi_lsp.py"],
      "selector": "source.sipi"
    }
  }
}
```
(Y una definicion de sintaxis minima que asocie `.sipi` con
`source.sipi`, vía `Tools > Developer > New Syntax`.)

## Helix

En `languages.toml` (global o del proyecto):
```toml
[[language]]
name = "sipi"
file-types = ["sipi"]
language-servers = ["sipi-lsp"]

[language-server.sipi-lsp]
command = "python3"
args = ["/ruta/completa/a/sipi_lsp.py"]
```

## Emacs (eglot)

```elisp
(add-to-list 'auto-mode-alist '("\\.sipi\\'" . fundamental-mode))
(with-eval-after-load 'eglot
  (add-to-list 'eglot-server-programs
               '(fundamental-mode . ("python3" "/ruta/completa/a/sipi_lsp.py"))))
```

## Zed y otros editores nuevos

Zed (y en general cualquier editor moderno, sea o no popular todavia)
acepta un "language server" custom apuntando a un comando arbitrario.
En Zed, por ejemplo, se define una extension pequeña con un
`extension.toml` que declara el lenguaje y apunta el `language_server`
a `python3 sipi_lsp.py`. La idea es siempre la misma en cualquier
editor: **el editor no necesita saber nada de SiPi de antemano** --
solo necesita saber ejecutar un comando y hablarle LSP, y
`sipi_lsp.py` se encarga del resto.

## Notas

- `sipi_lsp.py` no tiene dependencias externas (solo la biblioteca
  estandar de Python), asi que cualquier editor puede levantarlo
  con solo tener `python3` instalado.
- Si tu instalacion de SiPi esta "protegida" (`sipi_protegido.py` en
  vez de `sipi.py`), `sipi_lsp.py` ya lo detecta solo -- no hace falta
  configuracion extra.
