Adopter un projet existant

elide adopt lance un agent de code IA (Codex, Claude Code ou OMP) dans le répertoire courant avec un prompt de migration intégré. L’agent lit le build, modifie les fichiers et exécute Elide ; Elide ne modifie rien lui-même. Le prompt vise les projets Java et Kotlin construits avec Maven ou Gradle, en particulier Spring Boot, et demande à l’agent de garder les autres langages fonctionnels.

elide adopt

elide adopt migre le build vers elide.pkl. Pour conserver Maven, Gradle ou Bazel et utiliser les compilateurs d’Elide à l’intérieur, voir Intégration aux outils de build.

Projets concernés

Projets testés

Ces types de projets passent elide install, elide build, elide test, le démarrage et le build d’origine, à partir d’un checkout neuf, avec l’agent Codex :

L’agent Claude Code est présenté sur l’application Kotlin dans l’exemple complet.

Avant de commencer

1. Installez un agent et connectez-vous. Elide le lance depuis PATH :

   Choix	Exécutable	Agent
   codex	codex	OpenAI Codex CLI
   claude	claude	Claude Code
   omp	omp	OMP

2. Commitez le projet, pour que la migration forme un seul diff à relire.

3. Construisez-le une fois avec Maven ou Gradle, pour disposer d’une référence qui fonctionne.

4. Placez-vous dans le projet avec cd, ou passez -p DIR.

Exécution interactive

elide adopt pose trois questions, puis lance l’agent. Les options répondent à une question à l’avance.

elide adopt --build elide --harness claude

Échap sur une question quitte avec le code 0 sans lancer l’agent. Ctrl+C arrête l’agent et quitte avec le code 130.

Stratégie de build

Les deux se terminent par un résumé des fichiers modifiés, de la validation effectuée et de ce qu’il reste à faire.

Mode d’approbation

Avec auto-approve ou yolo, Elide lance l’agent en mode batch (codex exec --skip-git-repo-check, claude --print, omp --print) et affiche une ligne de progression ; --log diffuse aussi la sortie de l’agent. Avec manual-approve, l’agent s’exécute de façon interactive et sa sortie est toujours affichée.

Exécution sans questions

elide adopt \
  --build elide \
  --harness codex \
  --approval auto-approve \
  --non-interactive

--non-interactive exige --build, --harness et --approval ; s’il en manque une, la commande sort avec 2. Elle refuse manual-approve. Sans terminal, elide adopt sort avec 1, sauf si --non-interactive et les trois options sont fournis.

Ajouter des consignes

--prompt-append FILE ajoute un fichier UTF-8 à la fin du prompt, sous Additional adoption guidance:. Répétez l’option pour en ajouter plusieurs, dans l’ordre :

elide adopt --prompt-append ./adoption-guidance.md --prompt-append ./team-rules.md

Utilisez-la pour les faits que l’agent ne peut pas déduire : dépôts internes, build à conserver, commandes qui doivent continuer à fonctionner.

Sortie et codes de sortie

Les modifications de l’agent sont la seule sortie dans le projet. Dans l’exemple complet, il s’agissait d’un nouveau elide.pkl et d’entrées .gitignore pour .dev/. Elide affiche Adoption log: PATH avant de commencer ; le journal est conservé dans .dev/logs/adopt-<timestamp>-<pid>.log dans le projet.

Valider la migration

Le code 0 signifie que l’agent a terminé, pas que la migration est correcte. Relisez le diff : versions des dépendances, répertoires des sources et des ressources, point d’entrée, tests et empaquetage. Puis lancez :

elide install
elide build
elide test
elide run

Lancez aussi le build Maven ou Gradle d’origine, tant qu’il existe. Si le résultat est incorrect, annulez les modifications, ajoutez des consignes avec --prompt-append et relancez.

Exemple complet

Une application Kotlin en ligne de commande à un seul module, construite avec Gradle Kotlin DSL : Kotlin 2.3.20, JVM 17, kotlinx-coroutines-core 1.10.2, kotlinx-serialization-json 1.9.0 et un test kotlin("test"). Après un commit :

elide adopt --build elide --harness claude --approval auto-approve --non-interactive

Adoption log: /path/to/project/.dev/logs/adopt-1767225600-973648.log
[3m 56s] ✓ Project adopted in 3m 56s

L’agent a ajouté elide.pkl et un .gitignore, sans rien changer d’autre. Le manifeste conserve les versions de Gradle et transpose le reste dans les termes d’Elide :

amends "elide:project.pkl"

import "elide:Jvm.pkl" as Jvm
import "elide:Kotlin.pkl" as Kotlin

name = "kotlinx-cli"
version = "1.0.0"

dependencies {
  maven {
    packages {
      "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
      "org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0"
      // Gradle mediates annotations to 23.0.0 (via coroutines); Elide's nearest-wins picks 13.0.
      "org.jetbrains:annotations:23.0.0"
    }
    testPackages {
      // Gradle's `kotlin("test")` with `useJUnitPlatform()` resolves to the JUnit 5 variant.
      "org.jetbrains.kotlin:kotlin-test-junit5:2.3.20"
      // The JUnit launcher; with `testing = false`, Elide does not bundle one.
      "org.junit.platform:junit-platform-console:1.10.1"
    }
  }
}

jvm {
  main = "dev.elide.samples.MainKt"
  target = 17
  features {
    // JUnit comes from testPackages above, as with Gradle's `kotlin("test")`; Elide's bundled JUnit is off.
    testing = false
  }
  java {
    source = 17
    release = 17
  }
}

kotlin {
  // Matches the Kotlin Gradle plugin version in build.gradle.kts.
  toolchain = new Kotlin.ManagedKotlinToolchain {
    version = "2.3.20"
  }
  compilerOptions {
    jvmTarget = 17
  }
  features {
    // KotlinX libraries are declared explicitly above, at the versions Gradle uses; only the
    // serialization compiler plugin (Gradle's `plugin.serialization`) is enabled.
    kotlinx = false
    serialization = true
    coroutines = false
    atomicfu = false
    powerAssert = false
    metro = false
    reflection = false
  }
}

artifacts {
  ["jar"] = new Jvm.Jar {
    name = "kotlinx-cli"
    main = "dev.elide.samples.MainKt"
  }
}

Validation à partir d’un .dev/ vide :

$ elide install
[504ms] ✓ Resolved 25 Maven dependencies (476ms)
[505ms] ✓ Dependencies installed in 484ms
$ elide test
 1 pass
 0 skip
 0 fail
Ran one test across one file. (0.57s)
$ elide run
[ 16ms] ⇥ Dependencies ready (Up to date)
[ 16ms] ⇥ Kotlin main compilation skipped (Up to date)
[ 16ms] ⇥ Java main compilation skipped (Up to date)
[ 17ms] ⇥ Packaging jar 'jar' skipped (Up to date)
{"completed":["PARSE","EMIT"]}
[138ms] ✓ JVM jar application completed successfully (121ms)
[139ms] ✓ Build successful in 126ms

elide build a produit .dev/artifacts/jar/kotlinx-cli/kotlinx-cli.jar, et gradle build passait toujours.

Voir aussi

• Configuration du projet et la Référence elide.pkl
• Utilisateurs de Java, Utilisateurs de Kotlin
• Options de elide adopt