agent-rules-init 0.2.1 → 0.4.0

package/dist/packs/cpp.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 const FRAMEWORKS = [
     ["find_package(qt", "qt"],
     ["find_package(boost", "boost"],
@@ -46,39 +47,44 @@ function detect(signals) {
         : { value: "make", confidence: "high" };
     return { packId: "cpp", language: "C/C++", framework, testRunner, packageManager };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    return {
-        summary: `Proyecto C/C++${framework !== "none" ? ` con ${framework}` : ""} (${detection.packageManager?.value}).`,
-        conventions: [
-            "Sigue el estilo de formato ya usado en el proyecto (revisa si hay un `.clang-format`).",
-            `Compila y ejecuta los tests con ${detection.packageManager?.value === "cmake" ? "cmake --build . && ctest" : "make test"} antes de terminar una tarea.`,
-            "Gestiona la memoria con cuidado: prefiere RAII/smart pointers sobre `new`/`delete` manuales cuando el proyecto ya lo haga.",
-        ],
-        architectureNotes: [
+const TEXTS = {
+    es: {
+        style: "Sigue el estilo de formato ya usado en el proyecto (revisa si hay un `.clang-format`).",
+        memory: "Gestiona la memoria con cuidado: prefiere RAII/smart pointers sobre `new`/`delete` manuales cuando el proyecto ya lo haga.",
+        arch: [
             "Mantén los headers con guardas de inclusión (`#pragma once` o include guards) consistentes con el resto del proyecto.",
             "Declara toda dependencia nueva en el sistema de build existente (CMakeLists.txt o Makefile).",
         ],
+        reviewFocus: "fugas de memoria, punteros colgantes",
+    },
+    en: {
+        style: "Follow the formatting style already used in the project (check for a `.clang-format`).",
+        memory: "Manage memory carefully: prefer RAII/smart pointers over manual `new`/`delete` when the project already does.",
+        arch: [
+            "Keep header include guards (`#pragma once` or include guards) consistent with the rest of the project.",
+            "Declare every new dependency in the existing build system (CMakeLists.txt or Makefile).",
+        ],
+        reviewFocus: "memory leaks, dangling pointers",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const testCmd = detection.packageManager?.value === "cmake" ? "cmake --build . && ctest" : "make test";
+    return {
+        summary: summarySentence(lang, "C/C++", framework, detection.packageManager?.value),
+        conventions: [t.style, runTestsConvention(lang, testCmd), t.memory],
+        architectureNotes: t.arch,
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : undefined;
     return [
-        {
-            id: "review",
-            title: "Code Review (C/C++)",
-            body: `Revisa el diff actual buscando fugas de memoria, punteros colgantes y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (C/C++)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (C/C++)",
-            body: `Escribe tests con ${detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : "el framework de tests del proyecto"} para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (C/C++)", body: reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (C/C++)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (C/C++)", body: testingBody(lang, runner) },
     ];
 }
 export const cppPack = { id: "cpp", detect, rules, promptTemplates };

package/dist/packs/csharp.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 function detect(signals) {
     const source = signals.csproj;
     if (!source)
@@ -21,39 +22,43 @@ function detect(signals) {
         packageManager: { value: "nuget", confidence: "high" },
     };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    return {
-        summary: `Proyecto C#/.NET${framework !== "none" ? ` con ${framework}` : ""} (NuGet).`,
-        conventions: [
-            "Sigue las convenciones de nombrado de .NET (PascalCase para clases/métodos públicos, camelCase para variables locales).",
-            `Ejecuta los tests con \`dotnet test\` antes de terminar una tarea.`,
-            "Declara toda dependencia nueva vía NuGet en el .csproj, nunca la añadas manualmente sin registrarla.",
-        ],
-        architectureNotes: [
+const TEXTS = {
+    es: {
+        naming: "Sigue las convenciones de nombrado de .NET (PascalCase para clases/métodos públicos, camelCase para variables locales).",
+        deps: "Declara toda dependencia nueva vía NuGet en el .csproj, nunca la añadas manualmente sin registrarla.",
+        arch: [
             "Respeta la separación en capas (controller/service/repository) si el proyecto ya la usa.",
             "Prefiere inyección de dependencias sobre instanciación manual cuando el framework ya la ofrezca.",
         ],
+        reviewFocus: "null-safety",
+    },
+    en: {
+        naming: ".NET naming conventions apply (PascalCase for classes/public methods, camelCase for local variables).",
+        deps: "Declare every new dependency via NuGet in the .csproj; never add it manually without registering it.",
+        arch: [
+            "Respect the layered separation (controller/service/repository) if the project already uses it.",
+            "Prefer dependency injection over manual instantiation when the framework already provides it.",
+        ],
+        reviewFocus: "null-safety",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    return {
+        summary: summarySentence(lang, "C#/.NET", framework, "NuGet"),
+        conventions: [t.naming, runTestsConvention(lang, "`dotnet test`"), t.deps],
+        architectureNotes: t.arch,
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : undefined;
     return [
-        {
-            id: "review",
-            title: "Code Review (C#/.NET)",
-            body: `Revisa el diff actual buscando bugs, null-safety y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (C#/.NET)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (C#/.NET)",
-            body: `Escribe tests con ${detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : "el test runner del proyecto"} para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (C#/.NET)", body: reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (C#/.NET)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (C#/.NET)", body: testingBody(lang, runner) },
     ];
 }
 export const csharpPack = { id: "csharp", detect, rules, promptTemplates };

package/dist/packs/dart.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 function detect(signals) {
     const source = signals.pubspecYaml;
     if (!source)
@@ -21,41 +22,39 @@ function detect(signals) {
         packageManager: { value: "pub", confidence: "high" },
     };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
+const TEXTS = {
+    es: {
+        style: "Sigue la guía de estilo oficial de Dart (dart.dev/effective-dart/style).",
+        deps: "Declara toda dependencia nueva en pubspec.yaml, nunca la instales sin registrarla.",
+        archFlutter: "Separa la lógica de negocio de los widgets cuando el proyecto ya siga ese patrón (p. ej. BLoC/Provider/Riverpod).",
+        archPlain: "Mantén los módulos con una responsabilidad clara.",
+        immutability: "Prefiere `final`/`const` sobre variables mutables cuando sea posible.",
+    },
+    en: {
+        style: "Follow the official Dart style guide (dart.dev/effective-dart/style).",
+        deps: "Declare every new dependency in pubspec.yaml; never install one without registering it.",
+        archFlutter: "Keep business logic out of widgets when the project already follows that pattern (e.g. BLoC/Provider/Riverpod).",
+        archPlain: "Keep modules single-purpose.",
+        immutability: "Prefer `final`/`const` over mutable variables when possible.",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : undefined;
     return {
-        summary: `Proyecto Dart${framework !== "none" ? ` con ${framework}` : ""} (pub).`,
-        conventions: [
-            "Sigue la guía de estilo oficial de Dart (dart.dev/effective-dart/style).",
-            `Ejecuta los tests con ${detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : "el test runner del proyecto"} antes de terminar una tarea.`,
-            "Declara toda dependencia nueva en pubspec.yaml, nunca la instales sin registrarla.",
-        ],
-        architectureNotes: [
-            framework === "flutter"
-                ? "Separa la lógica de negocio de los widgets cuando el proyecto ya siga ese patrón (p. ej. BLoC/Provider/Riverpod)."
-                : "Mantén los módulos con una responsabilidad clara.",
-            "Prefiere `final`/`const` sobre variables mutables cuando sea posible.",
-        ],
+        summary: summarySentence(lang, "Dart", framework, "pub"),
+        conventions: [t.style, runTestsConvention(lang, runner), t.deps],
+        architectureNotes: [framework === "flutter" ? t.archFlutter : t.archPlain, t.immutability],
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang) {
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : undefined;
     return [
-        {
-            id: "review",
-            title: "Code Review (Dart)",
-            body: `Revisa el diff actual buscando bugs y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (Dart)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (Dart)",
-            body: `Escribe tests con ${detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : "el test runner del proyecto"} para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (Dart)", body: reviewBody(lang, "", framework) },
+        { id: "refactor", title: "Refactor (Dart)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (Dart)", body: testingBody(lang, runner) },
     ];
 }
 export const dartPack = { id: "dart", detect, rules, promptTemplates };

package/dist/packs/elixir.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 function detect(signals) {
     const source = signals.mixExs;
     if (!source)
@@ -18,39 +19,42 @@ function detect(signals) {
         packageManager: { value: "mix", confidence: "high" },
     };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    return {
-        summary: `Proyecto Elixir${framework !== "none" ? ` con ${framework}` : ""} (mix).`,
-        conventions: [
-            "Sigue la guía de estilo oficial de Elixir; ejecuta `mix format` antes de terminar una tarea.",
-            "Ejecuta los tests con `mix test` antes de terminar una tarea.",
-            "Prefiere pattern matching y pipelines (`|>`) sobre anidar llamadas de función.",
-        ],
-        architectureNotes: [
+const TEXTS = {
+    es: {
+        style: "Sigue la guía de estilo oficial de Elixir; ejecuta `mix format` antes de terminar una tarea.",
+        patterns: "Prefiere pattern matching y pipelines (`|>`) sobre anidar llamadas de función.",
+        arch: [
             "Respeta la separación entre contextos (lógica de negocio) y la capa web si el proyecto ya usa Phoenix.",
             "Declara toda dependencia nueva en `mix.exs` y mantén `mix.lock` sincronizado.",
         ],
+        reviewFocus: "procesos sin supervisar correctamente",
+    },
+    en: {
+        style: "Follow the official Elixir style guide; run `mix format` before finishing a task.",
+        patterns: "Prefer pattern matching and pipelines (`|>`) over nesting function calls.",
+        arch: [
+            "Respect the separation between contexts (business logic) and the web layer if the project already uses Phoenix.",
+            "Declare every new dependency in `mix.exs` and keep `mix.lock` in sync.",
+        ],
+        reviewFocus: "improperly supervised processes",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    return {
+        summary: summarySentence(lang, "Elixir", framework, "mix"),
+        conventions: [t.style, runTestsConvention(lang, "`mix test`"), t.patterns],
+        architectureNotes: t.arch,
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
     return [
-        {
-            id: "review",
-            title: "Code Review (Elixir)",
-            body: `Revisa el diff actual buscando bugs, procesos sin supervisar correctamente y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (Elixir)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (Elixir)",
-            body: `Escribe tests con \`mix test\` (ExUnit) para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (Elixir)", body: reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (Elixir)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (Elixir)", body: testingBody(lang, "`mix test` (ExUnit)") },
     ];
 }
 export const elixirPack = { id: "elixir", detect, rules, promptTemplates };

package/dist/packs/go.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 const FRAMEWORKS = [
     ["gin-gonic/gin", "gin"],
     ["labstack/echo", "echo"],
@@ -36,39 +37,42 @@ function detect(signals) {
         packageManager: { value: "go modules", confidence: "high" },
     };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    return {
-        summary: `Proyecto Go${framework !== "none" ? ` con ${framework}` : ""} (go modules).`,
-        conventions: [
-            "Sigue el formato estándar de `gofmt`; no introduzcas estilos alternativos.",
-            "Ejecuta los tests con `go test ./...` antes de terminar una tarea.",
-            "Maneja los errores explícitamente (`if err != nil`); no los ignores en silencio.",
-        ],
-        architectureNotes: [
+const TEXTS = {
+    es: {
+        style: "Sigue el formato estándar de `gofmt`; no introduzcas estilos alternativos.",
+        errors: "Maneja los errores explícitamente (`if err != nil`); no los ignores en silencio.",
+        arch: [
             "Mantén los paquetes con una responsabilidad clara; evita paquetes `util` genéricos.",
             "Declara toda dependencia nueva vía `go get` y mantén `go.mod`/`go.sum` sincronizados.",
         ],
+        reviewFocus: "manejo de errores omitido",
+    },
+    en: {
+        style: "Follow the standard `gofmt` formatting; do not introduce alternative styles.",
+        errors: "Handle errors explicitly (`if err != nil`); never ignore them silently.",
+        arch: [
+            "Keep packages single-purpose; avoid generic `util` packages.",
+            "Declare every new dependency via `go get` and keep `go.mod`/`go.sum` in sync.",
+        ],
+        reviewFocus: "missing error handling",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    return {
+        summary: summarySentence(lang, "Go", framework, "go modules"),
+        conventions: [t.style, runTestsConvention(lang, "`go test ./...`"), t.errors],
+        architectureNotes: t.arch,
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
     return [
-        {
-            id: "review",
-            title: "Code Review (Go)",
-            body: `Revisa el diff actual buscando bugs, manejo de errores omitido y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (Go)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (Go)",
-            body: `Escribe tests con \`go test\` para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (Go)", body: reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (Go)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (Go)", body: testingBody(lang, "`go test`") },
     ];
 }
 export const goPack = { id: "go", detect, rules, promptTemplates };

package/dist/packs/java.js

@@ -1,3 +1,9 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
+import { canonicalOf } from "../core/canonical-commands.js";
+const SPRING_RISK = {
+    es: "Presta especial atención a los límites de transacción (@Transactional), la inyección de dependencias y la separación controller/service/repository.",
+    en: "Pay special attention to transaction boundaries (@Transactional), dependency injection and the controller/service/repository separation.",
+};
 function detect(signals) {
     const source = signals.pomXml ?? signals.buildGradle;
     if (!source)
@@ -8,52 +14,98 @@ function detect(signals) {
     // (`alias(libs.plugins.kotlin.android)`) rather than the literal `kotlin("jvm")` or
     // `org.jetbrains.kotlin` plugin id, so a plain word-boundary check on "kotlin" is
     // more robust than trying to match every DSL style.
-    if (/\bkotlin\b/i.test(source))
+    if ((signals.buildGradle && /\bkotlin\b/i.test(signals.buildGradle)) ||
+        (signals.pomXml && /\bkotlin\b/i.test(signals.pomXml)))
         return null;
     const framework = /spring/i.test(source)
         ? { value: "spring", confidence: "high" }
         : { value: "none", confidence: "low" };
     const packageManager = signals.pomXml
-        ? { value: "maven", confidence: "high" }
-        : { value: "gradle", confidence: "high" };
+        ? signals.hasFile("mvnw") || signals.hasFile("mvnw.cmd")
+            ? { value: "maven wrapper", confidence: "high" }
+            : { value: "maven", confidence: "high" }
+        : signals.hasFile("gradlew") || signals.hasFile("gradlew.bat")
+            ? { value: "gradle wrapper", confidence: "high" }
+            : { value: "gradle", confidence: "high" };
     const testRunner = /junit/i.test(source)
         ? { value: "junit", confidence: "high" }
         : { value: "unknown", confidence: "low" };
     return { packId: "java", language: "Java", framework, packageManager, testRunner };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    return {
-        summary: `Proyecto Java${framework !== "none" ? ` con ${framework}` : ""} (${detection.packageManager?.value}).`,
-        conventions: [
-            "Sigue las convenciones de nombrado estándar de Java (PascalCase para clases, camelCase para métodos).",
-            `Ejecuta los tests con ${detection.packageManager?.value === "maven" ? "mvn test" : "gradle test"} antes de terminar una tarea.`,
-            "No añadas dependencias nuevas sin declararlas en el gestor de build existente.",
-        ],
-        architectureNotes: [
+const TEXTS = {
+    es: {
+        naming: "Sigue las convenciones de nombrado estándar de Java (PascalCase para clases, camelCase para métodos).",
+        deps: "No añadas dependencias nuevas sin declararlas en el gestor de build existente.",
+        arch: [
             "Respeta la separación en capas (controller/service/repository) si el proyecto ya la usa.",
             "Prefiere inyección de dependencias sobre instanciación manual cuando el framework ya la ofrezca.",
         ],
+        reviewFocus: "null-safety",
+    },
+    en: {
+        naming: "Follow standard Java naming conventions (PascalCase for classes, camelCase for methods).",
+        deps: "Do not add new dependencies without declaring them in the existing build tool.",
+        arch: [
+            "Respect the layered separation (controller/service/repository) if the project already uses it.",
+            "Prefer dependency injection over manual instantiation when the framework already provides it.",
+        ],
+        reviewFocus: "null-safety",
+    },
+};
+function rules(detection, lang, ctx) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const wrapperCmd = detection.packageManager?.value === "maven wrapper"
+        ? "./mvnw test"
+        : detection.packageManager?.value === "maven"
+            ? "mvn test"
+            : detection.packageManager?.value === "gradle wrapper"
+                ? "./gradlew test"
+                : "gradle test";
+    const testCmd = canonicalOf(ctx, "test", "java")?.command ?? wrapperCmd;
+    return {
+        summary: summarySentence(lang, "Java", framework, detection.packageManager?.value),
+        conventions: [t.naming, runTestsConvention(lang, testCmd), t.deps],
+        architectureNotes: t.arch,
     };
 }
-function promptTemplates(detection) {
-    const framework = detection.framework?.value ?? "el framework del proyecto";
+function promptTemplates(detection, lang, ctx) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner?.value : undefined;
+    const test = canonicalOf(ctx, "test", "java");
+    const build = canonicalOf(ctx, "build", "java");
+    const testDirs = ctx?.facts.testDirs ?? [];
+    const es = lang === "es";
+    const reviewParts = [];
+    reviewParts.push(es
+        ? `Revisa el diff actual contra las convenciones Java de este repositorio${framework ? ` (${framework})` : ""}.`
+        : `Review the current diff against this repository's Java conventions${framework ? ` (${framework})` : ""}.`);
+    if (test) {
+        reviewParts.push(es ? `Ejecuta \`${test.command}\` antes de dar por buena la revisión.` : `Run \`${test.command}\` before approving the review.`);
+    }
+    if (build && build.command !== test?.command) {
+        reviewParts.push(es ? `CI también ejecuta \`${build.command}\`.` : `CI also runs \`${build.command}\`.`);
+    }
+    if (framework === "spring")
+        reviewParts.push(SPRING_RISK[lang]);
+    reviewParts.push(es ? `Busca también bugs: ${t.reviewFocus}.` : `Also look for bugs: ${t.reviewFocus}.`);
+    if (testDirs.length > 0) {
+        const dirs = testDirs.map((d) => `\`${d}\``).join(", ");
+        reviewParts.push(es ? `Los tests viven en ${dirs}.` : `Tests live under ${dirs}.`);
+    }
+    reviewParts.push(es ? "Señala solo hallazgos concretos con archivo y línea." : "Report only concrete findings with file and line references.");
+    const testingParts = [testingBody(lang, runner)];
+    if (test)
+        testingParts.push(es ? `Verifica la suite con \`${test.command}\` antes de terminar.` : `Verify the suite with \`${test.command}\` before finishing.`);
+    if (testDirs.length > 0) {
+        const dirs = testDirs.map((d) => `\`${d}\``).join(", ");
+        testingParts.push(es ? `Coloca los tests nuevos en ${dirs}.` : `Place new tests under ${dirs}.`);
+    }
     return [
-        {
-            id: "review",
-            title: "Code Review (Java)",
-            body: `Revisa el diff actual buscando bugs, null-safety y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
-        },
-        {
-            id: "refactor",
-            title: "Refactor (Java)",
-            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
-        },
-        {
-            id: "testing",
-            title: "Testing (Java)",
-            body: `Escribe tests con ${detection.testRunner?.value ?? "el test runner del proyecto"} para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
-        },
+        { id: "review", title: "Code Review (Java)", body: ctx ? reviewParts.join(" ") : reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (Java)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (Java)", body: ctx ? testingParts.join(" ") : testingBody(lang, runner) },
     ];
 }
 export const javaPack = { id: "java", detect, rules, promptTemplates };