Adoptar un proyecto existente

elide adopt inicia un agente de programación con IA (Codex, Claude Code u OMP) en el directorio actual con un prompt de migración integrado. El agente lee la compilación, edita archivos y ejecuta Elide; Elide no edita nada por sí mismo. El prompt está pensado para proyectos Java y Kotlin compilados con Maven o Gradle, sobre todo Spring Boot, y le indica al agente que mantenga funcionando cualquier otro lenguaje.

elide adopt

elide adopt migra la compilación a elide.pkl. Para conservar Maven, Gradle o Bazel y usar los compiladores de Elide dentro de ellos, consulte Integración con herramientas de compilación.

A qué proyectos se adapta

Proyectos probados

Estos tipos de proyecto superan elide install, elide build, elide test, el arranque y la compilación original, partiendo de un checkout limpio, con el agente Codex:

El agente Claude Code se muestra con la aplicación Kotlin en el ejemplo completo.

Antes de empezar

1. Instale un agente e inicie sesión en él. Elide lo ejecuta desde PATH:

   Opción	Ejecutable	Agente
   codex	codex	OpenAI Codex CLI
   claude	claude	Claude Code
   omp	omp	OMP

2. Haga commit del proyecto, para que la migración sea un único diff revisable.

3. Compílelo una vez con Maven o Gradle, para tener una referencia que funciona.

4. Haga cd al proyecto o pase -p DIR.

Ejecutar de forma interactiva

elide adopt hace tres preguntas y luego inicia el agente. Las opciones responden una pregunta de antemano.

elide adopt --build elide --harness claude

Esc en una pregunta sale con 0 sin iniciar el agente. Ctrl+C detiene el agente y sale con 130.

Estrategia de compilación

Ambas terminan con un resumen de los archivos modificados, la validación ejecutada y lo que quede pendiente.

Modo de aprobación

Con auto-approve o yolo, Elide ejecuta el agente en modo por lotes (codex exec --skip-git-repo-check, claude --print, omp --print) y muestra una línea de progreso; --log también transmite la salida del agente. Con manual-approve, el agente se ejecuta de forma interactiva y su salida se muestra siempre.

Ejecutar sin preguntas

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

--non-interactive requiere --build, --harness y --approval; si falta alguna, sale con 2. Rechaza manual-approve. Sin terminal, elide adopt sale con 1 salvo que se indiquen --non-interactive y las tres.

Añadir indicaciones

--prompt-append FILE añade un archivo UTF-8 al final del prompt bajo Additional adoption guidance:. Repítala para añadir varios, en orden:

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

Úsela para datos que el agente no puede deducir: repositorios internos, qué compilación conservar, comandos que deben seguir funcionando.

Salida y códigos de salida

Las ediciones del agente son la única salida en el proyecto. En el ejemplo completo fueron un elide.pkl nuevo y entradas de .gitignore para .dev/. Elide imprime Adoption log: PATH antes de empezar; el registro se guarda en .dev/logs/adopt-<timestamp>-<pid>.log dentro del proyecto.

Validar la migración

Salir con 0 significa que el agente terminó, no que la migración sea correcta. Revise el diff: versiones de las dependencias, directorios de fuentes y de recursos, punto de entrada, pruebas y empaquetado. Después ejecute:

elide install
elide build
elide test
elide run

Ejecute también la compilación original de Maven o Gradle mientras exista. Si el resultado es incorrecto, revierta los cambios, añada indicaciones con --prompt-append y vuelva a ejecutarlo.

Ejemplo completo

Una aplicación de línea de comandos Kotlin de un solo módulo compilada con Gradle Kotlin DSL: Kotlin 2.3.20, JVM 17, kotlinx-coroutines-core 1.10.2, kotlinx-serialization-json 1.9.0 y una prueba kotlin("test"). Tras hacer 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

El agente añadió elide.pkl y un .gitignore, y no cambió nada más. El manifiesto conserva las versiones de Gradle y traslada el resto a los términos de 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"
  }
}

Validación desde un .dev/ limpio:

$ 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 generó .dev/artifacts/jar/kotlinx-cli/kotlinx-cli.jar, y gradle build siguió pasando.

Véase también

• Configurar un proyecto y la Referencia de elide.pkl
• Usuarios de Java, Usuarios de Kotlin
• Opciones de elide adopt