Metadata-Version: 2.4
Name: lmcoding-local
Version: 3.2.1
Summary: Agente de programación local para LM Studio con interfaz tipo Codex y seguridad por workspace
Author: TV Ofertas Ecuador
License-Expression: MIT
Project-URL: Homepage, https://pypi.org/project/lmcoding-local/
Keywords: lm-studio,coding-agent,cli,local-llm,codex-style
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: openai>=1.40.0
Requires-Dist: rich>=13.7.0
Dynamic: license-file

# llmCodex 3.2.1

Agente de programación local para **LM Studio**, con experiencia de terminal inspirada en agentes modernos tipo Codex, colores violeta propios y herramientas para inspeccionar, editar, verificar y reparar proyectos.

> No es el Codex oficial ni utiliza marcas o recursos gráficos de OpenAI. Es un proyecto independiente conectado a la API local compatible de LM Studio.

## Características

- Comandos instalables: `llmCodex`, `llmcodex` y `lmcoding`.
- Chat interactivo y modo no interactivo `exec`.
- Lectura, búsqueda, creación y edición de archivos.
- Ediciones atómicas y transaccionales.
- Checkpoints automáticos y `/undo`.
- Git status y diff.
- Sesiones persistentes y `resume --last`.
- Modos de permisos:
  - `read-only`
  - `workspace-write`
  - `full-access`
- Clasificación de comandos seguros, revisables, peligrosos y bloqueados.
- Verificación automática de proyectos:
  - Python
  - Node.js
  - Rust
  - Go
  - Gradle
  - Maven
  - .NET
  - PHP
- Ciclo de reparación automática con varios intentos y rollback.
- Reintentos frente a fallos temporales de LM Studio.
- Recuperación básica de argumentos JSON mal formados.
- Detección de llamadas de herramientas repetidas en bucle.

## Requisitos

- Windows, Linux o macOS.
- Python 3.10 o superior.
- LM Studio con un modelo cargado.
- Servidor local de LM Studio iniciado en `http://localhost:1234/v1`.
- Para mejores resultados, un modelo coder con soporte de tool/function calling.

## Instalación sencilla en Windows

1. Descomprime el ZIP.
2. Ejecuta:

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

3. Cierra y abre nuevamente CMD o PowerShell.
4. Comprueba:

```powershell
llmCodex --version
```

El instalador crea un entorno privado en:

```text
%LOCALAPPDATA%\llmCodex
```

Y agrega al PATH:

```text
%LOCALAPPDATA%\llmCodex\bin
```

## Instalar el wheel manualmente

```powershell
py -m pip install dist\lmcoding_local-3.2.1-py3-none-any.whl
```

Para aplicaciones CLI es recomendable usar `pipx`:

```powershell
pipx install dist\lmcoding_local-3.2.1-py3-none-any.whl
```

## Preparar LM Studio

1. Abre LM Studio.
2. Carga un modelo coder.
3. Abre **Developer**.
4. Pulsa **Start Server**.

## Uso básico

Dentro de cualquier proyecto:

```powershell
cd C:\ruta\de\tu\proyecto
llmCodex
```

También puedes indicar la carpeta:

```powershell
llmCodex -C C:\ruta\de\tu\proyecto
```

## Permisos

Modo recomendado, con escritura solo dentro del proyecto:

```powershell
llmCodex -C . --sandbox workspace-write
```

Solo lectura:

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

Modo automático dentro del workspace:

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

Acceso completo sin confirmaciones:

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

El último modo es peligroso. Los comandos se ejecutan con los permisos del usuario del sistema.

## Comandos interactivos

```text
/help
/status
/models
/model ID
/permissions read-only
/permissions workspace-write
/permissions full-access
/plan on
/plan off
/verify quick
/verify full
/doctor
/review
/diff
/undo
/compact
/new
/rename NOMBRE
/save
/exit
```

Ejecutar un comando directo:

```text
!python -m unittest
```

Adjuntar un archivo al mensaje:

```text
Analiza @src/app.py y corrige el error
```

## Modo no interactivo

```powershell
llmCodex exec "revisa el proyecto y corrige el error" -C . --full-auto
```

Salida JSON:

```powershell
llmCodex exec "resume el proyecto" -C . --json
```

## Revisión de cambios

```powershell
llmCodex review -C .
```

## Verificación y reparación

Verificación rápida:

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

Verificación completa:

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

Diagnóstico:

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

Corrección automática:

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

Con una instrucción:

```powershell
llmCodex fix "corrige las pruebas y no ocultes errores" -C . --full-auto --attempts 5
```

## Sesiones

Listar sesiones:

```powershell
llmCodex sessions
```

Reanudar la última:

```powershell
llmCodex resume --last
```

Reanudar por ID:

```powershell
llmCodex resume ID_DE_SESION
```

Las sesiones se guardan en:

```text
~/.lmcoding/sessions
```

## Configuración

Variables disponibles:

```text
LMSTUDIO_BASE_URL
LMSTUDIO_API_KEY
LMSTUDIO_MODEL
LMCODING_HOME
```

Archivo de configuración:

```text
~/.lmcoding/config.json
```

Ejemplo:

```json
{
  "base_url": "http://localhost:1234/v1",
  "api_key": "lm-studio",
  "model": null,
  "temperature": 0.2,
  "max_agent_steps": 24,
  "max_repair_attempts": 4,
  "verify_mode": "quick",
  "permission_mode": "workspace-write",
  "approval_policy": "on-request",
  "auto_verify": true,
  "auto_rollback": true
}
```

## Construir el paquete

```powershell
py -m pip install --upgrade build twine
py -m build
py -m twine check dist\*
```

O ejecuta:

```text
scripts\construir.bat
```

## Publicar en PyPI

Después de crear un token válido para toda la cuenta:

```powershell
py -m twine upload --verbose dist\*
```

También está incluido:

```text
scripts\publicar-pypi.bat
```

## Crear instalador EXE

Instala Inno Setup, abre:

```text
llmCodex-installer.iss
```

Y selecciona **Build → Compile**.

## Límites reales

El sistema puede detectar, probar, corregir y revertir muchos errores, pero ningún agente puede garantizar reparar absolutamente cualquier bug. Puede necesitar credenciales, servicios externos, hardware, datos privados o una especificación más precisa. llmCodex evita declarar éxito cuando sus verificaciones siguen fallando y puede restaurar el checkpoint anterior.


## Corrección 3.2.1

Incluye un parser de compatibilidad para modelos que devuelven llamadas de herramientas como texto en lugar de `tool_calls` estructurados.
