# PMOCrazyCoder

Environnement de développement conteneurisé avec assistance IA intégrée — Go, Rust, Python, TypeScript, R, Ruby — et outillage IA local (LM Studio) ou cloud (Claude Pro).

## Vision

> Un container de développement complet, multi-langages, avec LSP, outils IA et MCP intégrés,
> utilisable depuis Zed, VS Code ou Cursor, avec persistance par projet.

## Ce que contient l'image

### Langages et compilateurs
- **Go** (dernière version stable via script)
- **Rust** (stable + nightly, avec rustfmt, clippy, rust-analyzer, rust-src)
- **Python 3** (avec ruff, fastmcp, ipython, tasklin)
- **Node.js / npm** (avec TypeScript, ESLint, Prettier, Pyright, typescript-language-server)
- **Ruby** (avec github-linguist)
- **R**
- **Clang / LLVM** (clangd inclus)

### Outils de développement
- `jj` (Jujutsu VCS) + `jj-lsp`
- `gopls`, `mcp-language-server`
- `cargo-edit`, `cargo-watch`, `cargo-outdated`, `cargo-make`, `cargo-binstall`
- `sqlite3`, `cmake`, `make`, `git`
- `aichat` (client LLM CLI)

### MCP Servers installés

Le conteneur inclut plusieurs MCP servers pour l'intégration avec les outils de développement :

| MCP Server | Utilisation |
|---|---|
| `mcp-language-server` | LSP pour Go (gopls), Python (pyright-langserver), Rust (rust-analyzer), TypeScript |
| `github-mcp-server` | Intégration GitHub (repos, issues, PR) via `GITHUB_TOKEN` |
| `gitea-mcp` | Intégration Gitea/Forgejo via `GITEA_URL` et `GITEA_TOKEN` |
| `mcp-server-commands` | Exécution de commandes shell depuis l'assistant IA |

### Assistants IA
- **Claude Code** (installé au `postCreateCommand`)
- **opencode** (configuré via l'entrypoint)
- **aichat** (configuré via l'entrypoint, connecté au LLM local)

### Configuration MCP dans les assistants

Les MCP servers sont automatiquement configurés dans opencode et Claude Code via `crazycoder-setup.sh` (exécuté en `postStartCommand`) :

**opencode** (`~/.config/opencode/opencode.json`) :
- LSP pour Go, Python, Rust, TypeScript via `mcp-language-server`
- Commandes shell via `mcp-server-commands`
- GitHub MCP (si `GITHUB_TOKEN` défini)
- Gitea MCP (si `GITEA_URL` et `GITEA_TOKEN` définis)

**Claude Code** (`~/.claude/.claude.json`) :
- Même configuration MCP qu'opencode

Les configurations sont générées dynamiquement au démarrage du conteneur avec les variables d'environnement disponibles.

## Variables d'environnement (.env)

Le fichier `.env` (non versionné, ignoré par git) contient les credentials pour les services externes :

| Variable | Description | Exemple |
|---|---|---|
| `GITHUB_TOKEN` | Personal Access Token GitHub pour l'accès API | `ghp_xxxxxxxxxxxxxxxxxxxx` |
| `GITEA_URL` | URL de votre serveur Gitea/Forgejo | `https://gitea.example.com` |
| `GITEA_TOKEN` | Token d'accès API Gitea | `xxxxxxxxxxxxxxxxxxxx` |

Copiez `.devcontainer/.env.example` vers `.env` et renseignez vos tokens :

```bash
cp .devcontainer/.env.example .env
# Éditer .env avec vos credentials
```

Ces variables sont utilisées par :
- Le MCP Server GitHub (pour les opérations repo/issues/PR)
- Le MCP Server Gitea (intégration avec votre instance)

## Utilisation rapide

### Ajouter l'environnement à un projet existant

```bash
curl -fsSL https://gargoton.petite-maison-orange.fr/eric/PMOCrazycoder/raw/branch/main/setup-devcontainer.sh | bash
```

Ou avec un endpoint LLM personnalisé :

```bash
LOCAL_LLM_API=http://monserveur:1248/v1 bash setup-devcontainer.sh
```

Le script télécharge les fichiers `devcontainer.json` et `docker-compose.yml` directement depuis le dépôt Gitea, crée les répertoires de persistance dans `.devcontainer/config/` et met à jour `.gitignore`.

### Ouvrir dans le container

Ouvrir le projet dans VS Code, Zed ou Cursor et choisir "Reopen in Container". L'image est tirée automatiquement depuis le registry.

### Authentifier Claude Code

Dans le panneau Claude Agent de Zed, lancer `/login` et choisir "Log in with Claude.ai" (abonnement Pro/Max).

## Persistance par projet

Toutes les données et caches sont persistés dans `.devcontainer/config/` (ignoré par git) :

| Répertoire | Contenu |
|---|---|
| `config/claude/` | Sessions et config Claude Code |
| `config/opencode/` | Config opencode |
| `config/aichat/` | Config aichat |
| `config/ai_index/` | Index de code du projet |
| `config/cargo-registry/` | Cache crates.io |
| `config/cargo-git/` | Cache dépendances git Cargo |
| `config/cargo-bin/` | Binaires Rust installés pour le projet |
| `config/go-cache/` | Cache modules Go |
| `config/go-bin/` | Binaires Go installés pour le projet |
| `config/python-local/` | Paquets pip user + gems Ruby |
| `config/npm-cache/` | Cache npm |
| `config/r-libs/` | Paquets R installés |

### Installer des binaires persistants

```bash
# Rust — persiste dans .devcontainer/config/cargo-bin/
cargo install cargo-nextest

# Go — persiste dans .devcontainer/config/go-bin/
GOBIN=~/go/bin go install github.com/some/tool@latest

# Python — persiste dans .devcontainer/config/python-local/
pip install --user monpaquet

# R — persiste dans .devcontainer/config/r-libs/
R -e 'install.packages("tidyverse")'
```

## Configuration MCP détaillée

### opencode

Le fichier `~/.config/opencode/opencode.json` est généré à chaque démarrage avec :

- **LSP servers** : gopls, pyright-langserver, rust-analyzer, typescript-language-server
- **Shell commands** : `mcp-server-commands`
- **GitHub MCP** : activé si `GITHUB_TOKEN` est défini
- **Gitea MCP** : activé si `GITEA_URL` et `GITEA_TOKEN` sont définis
- **Provider LM Studio** : endpoint local configurable

### Claude Code

Le fichier `~/.claude/.claude.json` est mis à jour avec la section `mcpServers` contenant les mêmes serveurs que opencode.

## LLM local

L'entrypoint configure automatiquement opencode et aichat pour pointer sur `LOCAL_LLM_API`
(défaut : `http://host.docker.internal:1248/v1`).

Variables d'environnement disponibles dans le container :

| Variable | Défaut | Description |
|---|---|---|
| `LOCAL_LLM_API` | `http://host.docker.internal:1248/v1` | Endpoint OpenAI-compatible |
| `LLM_MODEL` | `ollama:qwen/qwen3-coder-next@4bit` | Modèle à utiliser |
| `TEMPERATURE` | `0.5` | Température |
| `NUM_CTX` | `32768` | Taille de contexte |
| `MAXTOKEN` | `4096` | Tokens max en sortie |

## Construire et publier l'image

```bash
# Build natif (local)
make build

# Build multi-arch (amd64 + arm64) + push vers le registry
make all

# Push uniquement (si l'archive OCI existe déjà)
make push

# Lister toutes les targets
make help
```

L'image est publiée sur `niepce.petite-maison-orange.fr/public/pmocrazycoder:latest`.
Le push utilise `skopeo` — assurez-vous d'être authentifié sur le registry.

## Sources

- Dépôt git : `https://gargoton.petite-maison-orange.fr/eric/PMOCrazycoder`
- Registry OCI : `niepce.petite-maison-orange.fr/public/pmocrazycoder:latest`

## Licence

CECILL-2.1