# Configuration du projet

Un projet est un répertoire qui contient un `elide.pkl`. Les sorties, les dépendances, les rapports et l'état du build
vont dans `.dev/`. Lancez les commandes depuis le répertoire du projet, ou passez `-p PATH`.

Consultez [Le répertoire .dev](/docs/toolchain/development-directory) pour les fichiers générés, les espaces de travail et le nettoyage.

```bash
elide init --templates   # android, java, ktjvm, spring, micronaut, testcontainers, web-simple, web-demo, workspace
```

## Créer un projet sans questions

`elide init` ouvre un éditeur dans le terminal. Dans les scripts et en CI, passez `--plain --skip-defaults`, un modèle
et ses paramètres sous la forme `name=value` :

```bash
elide init --template java --parameters          # list parameters and blocks
elide init --template java --parameters --json   # the same, as JSON
elide init --plain --skip-defaults --skip-run --template java \
  project_name=greeter package=dev.acme greeting="Hi there" tests=false
```

```text
elide.pkl
src/main/dev/acme/Hello.java
```

| Argument | Effet |
| --- | --- |
| `NAME=VALUE` ou `NAME VALUE` | Définit un paramètre ; les paramètres omis prennent leur valeur par défaut. |
| `BLOCK=true`, `BLOCK=false` | Active ou désactive un bloc facultatif : `tests` (sources de test), `mcp` (`.mcp.json`). |
| `--skip-run` | N'exécute pas Elide après la génération des fichiers. |
| `--overwrite` | Remplace les fichiers existants. |

| Entrée | Résultat |
| --- | --- |
| Pas de terminal, sans `--plain --skip-defaults` | Code de sortie `2` : `` `elide init` needs an interactive terminal. `` |
| Une valeur qui échoue à la validation | Code de sortie `2` : `Parameter "package" value "1bad" validation failed with error: "Not a valid Java package name."` |
| Une valeur de bloc autre que `true`/`false` | Code de sortie `2` : `Could not parse block "tests" value "maybe" as boolean, it must be true or false` |
| Un nom inconnu | Avertissement `No parameter or block "colour" exists, value "red" will be ignored` ; code de sortie `0` |

## Créer un projet JVM

```pkl
amends "elide:project.pkl"

name = "hello"

jvm {
  main = "sample.HelloKt"
}
```

`src/main/kotlin/sample/Hello.kt` :

```kotlin
package sample

fun main() {
  println("Hello from Kotlin")
}
```

```bash
elide install
elide build
elide run
```

`src/main/kotlin` ne nécessite pas de bloc `sources` ; voir [Source sets](/docs/toolchain/source-sets).

<img src="/assets/demos/project-build.gif" alt="Construction et exécution d'un projet Kotlin avec Elide" width="1591" height="910" loading="lazy" decoding="async" class="rounded-lg border border-border my-6 w-full" />

`elide build --inspect` liste les tâches et leurs options ; voir [Tâches de build](/docs/toolchain/build-tasks).

## Ajouter un script

```pkl
scripts {
  ["greet"] = "echo hello"
}
```

```bash
elide run greet
```

Les scripts s'exécutent sous `/bin/sh`. `elide run NAME` retient la première correspondance : un fichier, puis les
scripts de `elide.pkl`, puis ceux de `package.json` ou `pyproject.toml`, puis `node_modules/.bin`.

## Ajouter des dépendances

Déclarez les paquets Maven, npm et PyPI sous `dependencies` ; `elide install` résout les paquets Maven et npm, pas
PyPI ([paquets Python](/docs/python-packages)). Voir [Dépendances](/docs/toolchain/dependencies) et la
[référence](/docs/elide-pkl-reference#dependencies).

## Créer un espace de travail

La racine d'un espace de travail liste les projets membres et les construit comme un seul graphe de tâches.
`elide init --template workspace` en crée un. Voir [Espaces de travail](/docs/elide-pkl-reference#workspaces).

## Inspecter un projet

```bash
elide project info                 # resolved source sets, dependencies, artifacts
elide project advice               # usage advice for coding agents
elide project export               # the resolved manifest as JSON
elide project export --format=pom  # or intellij
elide classpath                    # the main compile classpath, `:`-separated
elide classpath test:runtime       # [<source-set>:]<usage>
```

Dans un projet qui déclare `android`, `elide project info` affiche aussi le SDK Android : sa racine et sa
provenance (le manifeste, `ANDROID_HOME`, `ANDROID_SDK_ROOT`, l'emplacement par défaut de la plateforme ou le SDK
géré par Elide), la plateforme, les build-tools, les platform-tools, l'émulateur et les images système résolus avec
leurs révisions installées, ce que le manifeste requiert et qui manque, ainsi que les appareils connectés et les
émulateurs en cours d'exécution ([SDK Android](/docs/toolchain/android/sdk#inspect-the-sdk)).

Les options `-f` modifient l'export. Formats : [Formats d'export du projet](/docs/cli-references#project-export-formats).
Usages du classpath : [Source sets](/docs/toolchain/source-sets#dependencies-and-classpaths).

## Épingler la version d'Elide

```bash
elide use 1.6.0               # write .elideversion and install that version
elide use 1.6.0 --no-install  # only write the file
```

`toolchain.engines` dans `elide.pkl` liste les versions acceptées ; voir
[Chaîne d'outils](/docs/elide-pkl-reference#toolchain).
