Metadata-Version: 2.4
Name: lmcoding-local
Version: 3.1.0
Summary: Agente de programacion local autocorrectivo para LM Studio
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: openai>=1.40.0
Requires-Dist: rich>=13.7.0
Requires-Dist: prompt-toolkit>=3.0.47
Requires-Dist: tomli>=2.0.1; python_version < "3.11"

# LMCoding Codex Edition 3.1

LMCoding Ultra es un agente de programación autocorrectivo para modelos locales ejecutados en LM Studio. Inspecciona el proyecto, modifica archivos, ejecuta validaciones, detecta errores introducidos durante la tarea, intenta repararlos y puede revertir automáticamente los cambios si no consigue dejar el proyecto en un estado verificable.

Es una implementación independiente en Python inspirada en el flujo de los agentes modernos de terminal. No contiene código de Codex ni garantiza resolver todos los errores posibles: algunos fallos requieren servicios externos, credenciales, hardware, datos o decisiones humanas. Su objetivo es evitar afirmaciones falsas, comprobar los cambios y recuperarse de fallos comunes.

## Protección contra errores

- Verificación automática después de modificar código.
- Detección de proyectos Python, JavaScript/TypeScript, Rust, Go, Gradle, Maven, .NET y PHP.
- Modos de validación `quick` y `full`.
- Hasta varios ciclos automáticos de diagnóstico → corrección → nueva prueba.
- Reversión de todos los cambios de la tarea cuando las reparaciones no funcionan.
- Checkpoints atómicos por cada edición.
- Reparación de argumentos JSON malformados producidos por modelos pequeños.
- Detección y bloqueo de bucles que repiten la misma herramienta.
- Reintentos exponenciales cuando LM Studio responde con errores temporales.
- Timeout de comandos y captura unificada de salida.
- Sesiones guardadas de forma persistente.
- Modo `/doctor` para revisar el entorno y el proyecto.

## Preparar LM Studio

1. Abre LM Studio.
2. Carga un modelo de programación con soporte para herramientas/function calling.
3. Abre **Developer**.
4. Pulsa **Start Server**.
5. La URL predeterminada es `http://localhost:1234/v1`.

## Instalación global en Windows: comando `llmCodex`

Haz doble clic en:

```bat
INSTALAR-llmCodex-EN-PATH.bat
```

El instalador crea una copia privada en `%LOCALAPPDATA%\llmCodex`, instala las dependencias y agrega `%LOCALAPPDATA%\llmCodex\bin` al `PATH` del usuario. No agrega el Python del entorno virtual completo al PATH.

Cierra y vuelve a abrir PowerShell o CMD. Después podrás ejecutar desde cualquier carpeta:

```powershell
llmCodex -C .
llmCodex fix -C . --full-auto
llmCodex verify -C . --mode full
```

También se instalan los alias `llmcodex` y `lmcoding`. Para eliminar la instalación global ejecuta `DESINSTALAR-llmCodex.bat`.

## Instalación en Windows

Ejecuta:

```bat
install-windows.bat
```

Después abre la carpeta de tu proyecto y ejecuta LMCoding con:

```powershell
lmcoding -C .
```

También puedes usar `iniciar-lmcoding.bat` desde la carpeta del proyecto.

## Corregir automáticamente un proyecto

```powershell
llmCodex fix -C . --full-auto
```

Con una instrucción específica:

```powershell
llmCodex fix "corrige el error de compilación y todas las pruebas relacionadas" -C . --full-auto
```

En Windows también se incluye:

```bat
corregir-proyecto.bat
```

El subcomando `fix` activa verificación completa y hasta cinco ciclos de reparación.

## Verificar sin usar el modelo

Comprobación rápida:

```powershell
llmCodex verify -C . --mode quick
```

Pruebas y build cuando sean detectados:

```powershell
llmCodex verify -C . --mode full
```

Diagnóstico del entorno, LM Studio y proyecto:

```powershell
llmCodex doctor -C . --mode full
```

## Uso interactivo

```powershell
llmCodex -C . --full-auto
```

Ejemplos:

```text
Encuentra la causa de los errores y corrígelos sin eliminar pruebas.
Ejecuta el build, corrige cada fallo y vuelve a comprobarlo.
Analiza @src/app.py y arregla el bug sin cambiar la API pública.
```

Para enviar texto multilinea usa `Esc` seguido de `Enter`.

## Comandos internos

```text
/help
/status
/doctor
/verify quick
/verify full
/autofix on
/autofix off
/autofix quick
/autofix full
/permissions
/model
/models
/plan on
/plan off
/review
/diff
/undo
/compact
/new
/sessions
/resume ID
/rename NOMBRE
/save
/exit
```

También admite:

```text
!python -m pytest
!npm run build
```

Y archivos adjuntos al contexto:

```text
Revisa @src/app.py y @tests/test_app.py
```

## Modos de permisos

### Recomendado

```powershell
llmCodex -C . --full-auto
```

Permite editar el workspace y ejecutar verificaciones locales. Sigue bloqueando o preguntando por comandos peligrosos, red o rutas externas.

### Solo lectura

```powershell
lmcoding -C . --sandbox read-only
```

### Acceso completo

```powershell
lmcoding -C . --dangerously-bypass-approvals-and-sandbox
```

El acceso completo es peligroso. LMCoding controla permisos a nivel de aplicación, pero no crea una sandbox real del sistema operativo.

## Opciones del autocorrector

```text
--self-heal / --no-self-heal
--verification off|quick|full
--fix-attempts N
--rollback-on-failure / --no-rollback-on-failure
--api-retries N
```

Ejemplo estricto:

```powershell
lmcoding -C . --self-heal --verification full --fix-attempts 5 --rollback-on-failure
```

## Configuración

Global:

```text
~/.lmcoding/config.toml
```

Por proyecto:

```text
PROYECTO/.lmcoding/config.toml
```

Consulta `config.example.toml`.

## Pruebas de LMCoding

```powershell
python -m unittest discover -s tests -v
```

Las pruebas incluidas comprueban:

- argumentos de herramientas malformados;
- checkpoints y reversión;
- detección de errores de sintaxis;
- reparación automática tras una verificación fallida;
- restauración del proyecto cuando se agotan los intentos.
