Guide Développeur

Référence complète d'Argy Code : TUI, exécution autonome, toutes les commandes, patterns agentiques, MCP, agents, skills, configuration et intégration SDK.

Argy aide les développeurs à livrer via des briques standardisées et gouvernées (modules / golden paths) et un accès IA gouverné (LLM Gateway), sans contourner la sécurité, la conformité ou les standards plateforme.

Argy Code

Argy Code est un agent IA pour les développeurs, fonctionnant entièrement dans votre terminal. Il supporte deux modes d'exécution et un riche ensemble de commandes pour le travail quotidien, l'automatisation et les pipelines agentiques.

Installation

Windows — winget est la méthode recommandée :

# winget (Windows Package Manager) — recommandé
winget install demkada.ArgyCode

# PowerShell one-liner
irm https://argy.cloud/install.ps1 | iex

# Scoop
scoop bucket add argy https://github.com/demkada/scoop-argy
scoop install argy

macOS — Homebrew est recommandé :

# Homebrew — recommandé
brew install demkada/tap/argy

# curl
curl -fsSL https://argy.cloud/install | sh

Linux :

curl -fsSL https://argy.cloud/install | sh

Toutes plateformes — npm (nécessite Node.js) :

npm install -g @argycloud/code

Premier lancement et authentification

Lancer argy ouvre le TUI interactif. Si aucun identifiant n'est trouvé, la connexion est déclenchée automatiquement.

# Open the TUI — login happens on first launch
argy

# Authenticate explicitly via Device Flow (RFC 8628)
argy auth login

# Authenticate with a Personal Access Token
argy auth login --pat

# Check authentication status and credits
argy auth status

# Remove stored credentials
argy auth logout

Device Flow (défaut) : ouvre un navigateur, vous confirmez le code appareil. Aucun mot de passe n'est stocké localement.

PAT : jeton généré depuis le portail Argy. Durée de 7 jours à 1 an, jusqu'à 25 jetons actifs par utilisateur, révocable à tout moment. Stocké dans ~/.config/argy/auth.json.

TUI — Mode interactif

La commande argy (sans sous-commande) ouvre l'interface terminal interactive construite avec SolidJS et OpenTUI.

argy

Ce que fournit le TUI

Interface de chat : envoyez des messages et recevez des réponses en streaming avec appels d'outils en ligne
Confirmations d'outils : approuvez ou refusez les commandes bash, écritures de fichiers et autres opérations sensibles avant exécution
Gestion des sessions : créez de nouvelles sessions, poursuivez les précédentes et parcourez l'historique
Slash commands : tapez / pour accéder aux commandes intégrées et personnalisées
- /init — créer ou mettre à jour AGENTS.md dans votre projet (prompt système de l'agent)
- /review — examiner les changements non commités, un commit spécifique, une branche ou une PR
- Commandes personnalisées définies dans argy.json sous la clé command:
- Les prompts des serveurs MCP sont importés automatiquement comme slash commands
- Les skills de .argy/skill/*.md sont exposées automatiquement comme slash commands
Outils MCP : les serveurs MCP connectés apparaissent comme outils disponibles en ligne
Orchestration de sous-agents : l'agent peut lancer des sous-agents via l'outil task, en parallèle avec des permissions d'outils isolées

Flux de connexion TUI

Lancez argy
Si non authentifié : le prompt navigateur Device Flow s'ouvre automatiquement
Confirmez le code appareil dans le navigateur
Le TUI reprend — la session démarre immédiatement

Aucune étape séparée argy auth login n'est nécessaire pour un usage normal.

argy run — Mode autonome

argy run est le mode d'exécution non interactif pour les pipelines CI/CD, les tâches cron, les scripts et les orchestrateurs.

argy run [message..] [flags]

Codes de sortie

Code	Signification
`0`	Succès — l'agent a terminé la tâche
`1`	Échec — l'agent a rencontré une erreur
`2`	Arrêté — l'agent a atteint la limite de tours ou a été interrompu

Flags

Flag	Alias	Description
`--continue`	`-c`	Continuer la dernière session
`--session <id>`	`-s`	Continuer une session spécifique par ID
`--agent <nom>`		Utiliser un agent nommé spécifique
`--model <provider/model>`	`-m`	Forcer le modèle (ex: `argy-gateway/claude-sonnet-4-5`)
`--variant <nom>`		Variante de raisonnement (`high`, `max`, `minimal`)
`--max-turns <n>`		Tours max de l'agent avant arrêt (code de sortie 2)
`--format <fmt>`		Format de sortie : `default` (lisible) ou `json` (événements)
`--file <path>`	`-f`	Joindre un fichier au message (répétable)
`--title <texte>`		Définir le titre de la session
`--share`		Partager la session sur argy.cloud
`--attach <url>`		S'attacher à un serveur Argy (ex: `http://localhost:4096`)
`--port <n>`		Port du serveur local
`--thinking`		Afficher les blocs de réflexion (défaut : false)
`--command <nom>`		Lancer une slash command nommée en mode non interactif

Support stdin

Si stdin n'est pas un TTY, argy run le lit et ajoute le contenu au message :

git diff HEAD~1 | argy run "Résumer ces changements pour une description de PR"
cat error.log | argy run "Diagnostiquer cette erreur et suggérer un correctif"

Modèle de permissions en mode run

En mode autonome, les outils en lecture seule sont auto-autorisés sans confirmation : glob, grep, read, list, websearch, webfetch, codesearch, todowrite, todoread

Les outils interactifs (question, plan_enter, plan_exit) sont refusés. Les outils d'écriture (bash, write, edit) nécessitent une approbation explicite à moins que la politique de l'agent ne les autorise.

Exemples

# Exécution autonome de base
argy run "Écrire des tests unitaires pour src/auth.ts"

# Continuer la dernière session
argy run -c "Maintenant, corrige le test qui échoue"

# Continuer une session spécifique
argy run --session abc123 "Ajouter des cas limites"

# Utiliser un agent et un modèle spécifiques
argy run --agent code-reviewer --model argy-gateway/claude-sonnet-4-5 "Revoir la PR #42"

# Limiter les tours pour la sécurité
argy run --max-turns 10 "Refactoriser la couche base de données"

# Joindre des fichiers
argy run --file spec.md --file schema.sql "Implémenter cette spec par rapport à ce schéma"

# Sortie JSON pour les pipelines CI
argy run --format json "Analyser les vulnérabilités de sécurité" | jq '.events[]'

# Pipe stdin
git diff | argy run --format json --continue "Revoir et suggérer des correctifs"

# Partager le résultat de la session
argy run --share "Générer un plan de migration pour le monolithe"

# S'attacher à un serveur en cours d'exécution
argy run --attach http://localhost:4096 "Lancer un scan de sécurité"

# Utiliser une slash command nommée
argy run --command review

# Utilisation des codes de sortie dans les scripts shell
argy run "Déployer en staging" && echo "Déployé" || echo "Échec du déploiement"

Patterns de pipeline agentique

# Pipeline multi-étapes avec continuité de session
argy run "Analyser le code et lister tous les points de terminaison de l'API" && \
argy run -c "Maintenant, générer la documentation OpenAPI pour chaque point de terminaison" && \
argy run -c "Écrire des tests d'intégration pour les 3 points de terminaison les plus critiques"

# Exécutions parallèles avec différents agents
argy run --agent security-auditor "Auditer les flux d'authentification" &
argy run --agent performance-analyst "Profiler les requêtes de base de données" &
wait

# Tâche agentique planifiée (cron)
# 0 9 * * 1  argy run "Hebdomadaire : résumer les PR ouvertes et créer un rapport de tri"

# Intégration CI/CD
argy run --format json --max-turns 20 \
  "Lancer la suite complète de tests, corriger les échecs et commiter les correctifs" \
  | tee argy-run.json

argy auth — Authentification

argy auth login           # Device Flow (défaut)
argy auth login --pat     # Personal Access Token
argy auth status          # Afficher le statut, les crédits, le tenant, l'utilisateur
argy auth logout          # Supprimer les identifiants stockés

Scopes PAT : l'URL de la gateway, l'ID du tenant et l'ID de l'utilisateur sont extraits du JWT.

Stockage : les identifiants sont sauvegardés dans ~/.config/argy/auth.json.

argy models — Découverte des modèles

argy models                    # Lister tous les modèles disponibles
argy models <provider>         # Filtrer par fournisseur
argy models --verbose          # Inclure le coût et les métadonnées
argy models --refresh          # Rafraîchir le cache depuis la gateway

Les modèles sont récupérés via GET /v1/models sur l'Argy Gateway. Format de sortie : provider/modelID par ligne.

# Utiliser un modèle spécifique dans un run
argy run --model argy-gateway/gpt-4o "Traduire ce code en TypeScript"
argy run --model argy-gateway/claude-sonnet-4-5 --variant high "Résoudre ce problème algorithmique difficile"

argy agent — Gestion des agents

Les agents sont des fichiers Markdown avec un frontmatter YAML qui définit un prompt système spécialisé, un ensemble d'outils et un mode d'exécution.

argy agent list                # Lister tous les agents disponibles
argy agent create              # Assistant interactif de création d'agent
argy agent create \
  --description "Expert TypeScript code reviewer" \
  --mode primary \
  --tools bash,read,write,edit,glob,grep \
  --model argy-gateway/claude-sonnet-4-5

Format de fichier agent

Les agents sont stockés sous forme de fichiers Markdown dans :

.argy/agent/ — agents au scope projet
~/.config/argy/agent/ — agents globaux

---
description: "Relecteur de code TypeScript expert axé sur la sécurité et la performance"
mode: primary # primary | subagent | all
tools: bash,read,edit,glob,grep,webfetch
model: argy-gateway/claude-sonnet-4-5
---

Vous êtes un expert en relecture de code TypeScript. Concentrez-vous sur :

- Les vulnérabilités de sécurité (injection, XSS, contournements d'auth)
- Les goulots d'étranglement de performance (requêtes N+1, fuites de mémoire)
- La sécurité du typage et la gestion appropriée des erreurs

Fournissez toujours des commentaires exploitables et spécifiques avec des exemples de code.

Modes d'agent

Mode	Description
`primary`	Peut être sélectionné comme agent principal avec `--agent`
`subagent`	Utilisable uniquement via l'outil `task` par un autre agent
`all`	Disponible dans les deux modes

Agents natifs

Argy embarque plusieurs agents intégrés, toujours disponibles sans configuration :

Agent	Mode	Description
`build`	primary	Agent par défaut. Accès complet aux outils, gouvernance des écritures, confirmations interactives
`plan`	primary	Recherche en premier. Lecture seule par défaut, écritures uniquement dans `.argy/plans/`
`docgen`	primary	Génération de documents : PowerPoint (.pptx) et Excel (.xlsx) via pptxgenjs et exceljs. Demande la charte graphique en mode interactif ; utilise les defaults Argy en mode non interactif.
`general`	subagent	Sous-agent de recherche et d'exécution parallèle polyvalent
`explore`	subagent	Sous-agent d'exploration de code rapide en lecture seule

docgen — Agent de génération de documents

docgen génère des documents professionnels depuis le langage naturel :

# Interactif : demande couleurs, logo et police avant de générer
argy --agent docgen "Crée une présentation de 8 slides pour la roadmap Q3"

# Non interactif (argy run) : utilise la charte Argy par défaut, ne bloque jamais
argy run --agent docgen "Génère un tableau de bord KPI Excel avec graphiques"

# Pipe de données
cat ventes.csv | argy run --agent docgen "Crée un dashboard Excel depuis ces données"

Charte graphique : en mode interactif, docgen pose une question groupée (couleurs de marque, chemin du logo, police) avant d'écrire le moindre code. En mode argy run, l'outil question est désactivé — docgen infère silencieusement depuis le contexte ou applique la palette Argy par défaut (marine #1A1A2E, corail #E94560) et continue immédiatement sans bloquer.

Sortie : tous les fichiers générés ont author = "Argy" et company = "https://argy.cloud/" dans les métadonnées du document.

Outils disponibles pour les agents

bash, read, write, edit, list, glob, grep, webfetch, task, todowrite, todoread

Orchestration de sous-agents

L'outil task permet à un agent de lancer des sous-agents :

# Un agent peut déléguer du travail ainsi (dans son prompt système ou via le TUI) :
# "Utilise l'outil task pour lancer l'agent security-auditor sur src/auth/ en parallèle
#  avec l'agent performance-analyst sur src/db/"

argy mcp — Gestion des serveurs MCP

Argy Code prend en charge les serveurs Model Context Protocol pour étendre l'agent avec des outils externes.

argy mcp list                  # Liste les serveurs MCP configurés et leur statut
argy mcp add                   # Ajoute un serveur (assistant interactif)
argy mcp auth <name>           # Authentifie un serveur MCP OAuth
argy mcp auth list             # Liste les serveurs compatibles OAuth et leur statut
argy mcp logout <name>         # Supprime les identifiants OAuth
argy mcp debug <name>          # Débogue la connexion OAuth

Valeurs de statut des serveurs MCP

Statut	Signification
`connected`	Le serveur est en cours d'exécution et les outils sont disponibles
`disabled`	Le serveur est configuré mais désactivé
`needs_auth`	Authentification OAuth requise
`failed`	La connexion a échoué

Ajouter un serveur MCP dans argy.json

{
  "mcp": {
    "filesystem": {
      "type": "local",
      "command": ["npx", "@modelcontextprotocol/server-filesystem", "/workspace"],
    },
    "github": {
      "type": "local",
      "command": ["npx", "@modelcontextprotocol/server-github"],
    },
    "my-remote-mcp": {
      "type": "remote",
      "url": "https://my-mcp-server.example.com/mcp",
    },
  },
}

argy session — Gestion des sessions

argy session list              # Liste les sessions (vue en tableau)
argy session list -n 20        # Les 20 dernières sessions
argy session list --format json # Sortie au format JSON

Champs de sortie JSON : id, title, updated, created, projectId, directory.

# Continue une session spécifique en mode run
argy run --session <session-id> "Reprendre là où nous nous étions arrêtés"

# Exporte une session
argy export <session-id>

# Exporte la dernière session
argy export

# Importe une session depuis un fichier ou une URL de partage argy.cloud
argy import session-export.json
argy import https://argy.cloud/s/abc123

argy serve — Serveur HTTP headless

Démarre un serveur HTTP local basé sur Hono qui expose l'API Argy Code pour l'accès via le SDK, les plugins IDE ou des intégrations personnalisées.

argy serve
argy serve --port 4096 --hostname 0.0.0.0

Définissez ARGY_SERVER_PASSWORD pour protéger le serveur.

Le SDK TypeScript (@argy-cloud/code-sdk) se connecte à ce serveur :

import { ArgyClient } from "@argy-cloud/code-sdk/v2";

const client = new ArgyClient({ baseUrl: "http://localhost:4096" });
const session = await client.sessions.create({ title: "My automated task" });
const stream = await client.messages.stream(session.id, {
  content: "Analyze the codebase and list all TODO comments",
});
for await (const event of stream) {
  console.log(event);
}

argy acp — Intégration IDE (ACP)

Démarre un serveur Agent Client Protocol pour les plugins IDE (VS Code, JetBrains, etc.).

argy acp
argy acp --cwd /path/to/project --port 7777

Communique via des flux ndjson sur stdin/stdout. Définit ARGY_CLIENT=acp.

argy stats — Statistiques d'usage

argy stats

Affiche : nombre de sessions, messages, coût total, jetons consommés, répartition de l'utilisation des outils, répartition de l'utilisation des modèles.

argy pr — Workflow PR GitHub

Récupère et extrait une branche de PR GitHub, puis exécute Argy dessus :

argy pr 42

Utile pour les pipelines d'examen de PR automatisés :

# Dans la CI : examiner la PR actuelle
argy run --agent code-reviewer "Examine cette PR pour les problèmes de sécurité et de performances"

# Ou utiliser argy pr pour récupérer une PR spécifique
argy pr 42

argy upgrade — Mise à jour

argy upgrade                   # Met à jour vers la dernière version
argy upgrade 0.1.48            # Met à jour vers une version spécifique
argy upgrade --method brew     # Spécifie la méthode de mise à jour
argy upgrade --method npm
argy upgrade --method scoop
argy upgrade --method curl

argy uninstall — Désinstallation

argy uninstall                 # Désinstallation interactive
argy uninstall --keep-config   # Conserve ~/.config/argy/
argy uninstall --keep-data     # Conserve les données de session et les instantanés
argy uninstall --dry-run       # Prévisualise ce qui serait supprimé
argy uninstall --force         # Ignore les invites de confirmation

Flags globaux

Disponibles sur toutes les commandes :

Flag	Description
`--help` / `-h`	Affiche l'aide
`--version` / `-v`	Affiche la version
`--print-logs`	Affiche les journaux internes
`--log-level DEBUG\|INFO\|WARN\|ERROR`	Verbosité des journaux
`--env PROD\|STAGING\|DEV\|LOCAL`	Surcharge l'environnement

Configuration — argy.json

Project-level configuration file. Place argy.json or argy.jsonc at the project root.

{
  "$schema": "https://argy.cloud/config.json",

  // Custom slash commands
  "command": {
    "security-review": {
      "description": "Full security audit of the codebase",
      "template": "Run a comprehensive security audit. Check for: injection vulnerabilities, auth bypasses, secrets in code, insecure dependencies. Output a prioritized report.",
      "agent": "security-auditor",
      "model": "argy-gateway/claude-sonnet-4-5",
      "subtask": false,
    },
    "generate-docs": {
      "description": "Generate API documentation",
      "template": "Analyze all public API endpoints and generate OpenAPI 3.0 documentation in docs/api.yaml",
    },
  },

  // MCP servers
  "mcp": {
    "filesystem": {
      "type": "local",
      "command": ["npx", "@modelcontextprotocol/server-filesystem", "."],
    },
  },

  // Model provider settings
  "provider": {
    "argy-gateway": {
      "models": {
        "claude-sonnet-4-5": { "temperature": 0.3 },
      },
    },
  },

  // Auto-share sessions
  "share": "auto",

  // Environment override
  "environment": "PROD",
}

Ordre de recherche de configuration

argy.json / argy.jsonc in the current project root
~/.config/argy/ (global config)
.argy/ in project root (skills, tools, agents)
.claude/ (shared with Claude Code)
.agents/ (shared with other agent tools)

AGENTS.md — Prompt système de l'agent

Create AGENTS.md at the project root to give the agent persistent context about your project:

# Auto-generate AGENTS.md from your codebase
argy run --command init
# or inside the TUI:
/init

The agent reads AGENTS.md at the start of every session. Include: project overview, tech stack, coding conventions, key directories, and any constraints.

Variables d'environnement

Variable	Description
`ARGY_PAT`	Personal Access Token (alternative to file-based auth)
`ARGY_ENV`	Environment: `LOCAL`, `DEV`, `STAGING`, `PROD` (default: `PROD`)
`ARGY_BIN_PATH`	Override the binary path (useful in monorepos)
`ARGY_CONFIG_CONTENT`	Inline JSON config (overrides `argy.json`)
`ARGY_SERVER_PASSWORD`	Password for the headless server (`argy serve`)
`ARGY_AUTO_SHARE`	Auto-share all sessions
`ARGY_GIT_BASH_PATH`	Git Bash path on Windows
`ARGY_PRINT_LOGS`	Print internal logs (same as `--print-logs`)
`ARGY_LOG_LEVEL`	Log level (same as `--log-level`)
`ARGY_CLIENT`	Client identifier (e.g. `acp` for IDE integrations)

Skills — Modèles de prompts réutilisables

Skills are Markdown files in .argy/skill/ that are auto-exposed as slash commands in the TUI.

## <!-- .argy/skill/pr-review.md -->

## description: "Thorough PR review covering security, performance, and code quality"

Review the current git diff with focus on:

1. Security vulnerabilities
2. Performance implications
3. Test coverage gaps
4. Breaking changes
5. Code style consistency

Provide inline comments and a summary with a risk rating (low/medium/high).

Use it in the TUI with /pr-review or in run mode:

argy run --command pr-review

Référence des outils intégrés

Tool	Description
`bash`	Execute shell commands
`read`	Read file contents
`write`	Write files (creates or overwrites)
`edit`	Edit files with exact string replacement
`glob`	Find files by pattern (e.g. `*/.ts`)
`grep`	Search file contents with regex
`list`	List directory contents
`webfetch`	Fetch a URL and return content as markdown
`websearch`	Web search
`codesearch`	Semantic code search across the codebase
`task`	Spawn a sub-agent for parallel work
`skill`	Invoke a skill by name
`todowrite`	Write/update a structured todo list
`todoread`	Read the current todo list

LLM Gateway (API compatible OpenAI)

The LLM Gateway is the unified entry point to LLM providers (OpenAI, Anthropic, Mistral, xAI, Google) with governance built in: quotas, security filters, and full auditing.

Endpoints

POST /v1/chat/completions — Chat completions (streaming SSE)
POST /v1/embeddings — Text embeddings
POST /v1/agent/steps — Agent step execution
GET /v1/models — List available models
GET /v1/status — Auth validation and credit status

Argy is multi-tenant. Requests carry tenant and organization context:

x-tenant-id
x-org-id

Exemple : chat completion

curl -X POST https://llm.argy.cloud/v1/chat/completions \
  -H "Authorization: Bearer $ARGY_PAT" \
  -H "Content-Type: application/json" \
  -H "x-tenant-id: <tenant-id>" \
  -d '{
    "model": "argy-gateway/claude-sonnet-4-5",
    "stream": true,
    "messages": [
      { "role": "user", "content": "Summarize these run logs in 5 bullet points." }
    ]
  }'

Exemple : lister les modèles

curl https://llm.argy.cloud/v1/models \
  -H "Authorization: Bearer $ARGY_PAT"

Modules & Golden Paths

Argy packages enterprise standards as versioned modules (golden paths): infrastructure provisioning, CI/CD steps, security checks, approval gates, and operational conventions. Developers consume them through the portal and Argy Code, while platform teams keep control through versioning and governance.

See the Module Studio and consuming modules guides for details.