agent-rules-init 0.1.3 → 0.2.0

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "./cli.js";
+main();

package/dist/cli.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { type WriteResult } from "./core/writer.js";
 import { type PromptFn } from "./core/prompt-engine.js";
 import { type ExecFn } from "./core/llm-bridge.js";
@@ -8,3 +7,4 @@ export interface RunCliOptions {
     skipLlm?: boolean;
 }
 export declare function runCli(rootPath: string, options?: RunCliOptions): Promise<WriteResult[]>;
+export declare function main(): Promise<void>;

package/dist/cli.js

@@ -1,16 +1,41 @@
-#!/usr/bin/env node
 import * as clack from "@clack/prompts";
-import { pathToFileURL } from "node:url";
 import { scanRepo } from "./core/scanner.js";
 import { writeGeneratedFiles } from "./core/writer.js";
 import { renderClaudeMd, renderAgentsMd, renderCopilotInstructions, renderPromptFiles, } from "./core/templates.js";
 import { collectLowConfidenceQuestions, askQuestions, applyAnswers, defaultPromptFn, hasInteractiveTty, } from "./core/prompt-engine.js";
 import { detectAvailableAssistants, polishWithAssistant, defaultExecFn } from "./core/llm-bridge.js";
-import { jsTsPack } from "agent-rules-pack-js-ts";
-import { pythonPack } from "agent-rules-pack-python";
-import { javaPack } from "agent-rules-pack-java";
-import { phpPack } from "agent-rules-pack-php";
-const ALL_PACKS = [jsTsPack, pythonPack, javaPack, phpPack];
+import { jsTsPack } from "./packs/js-ts.js";
+import { pythonPack } from "./packs/python.js";
+import { javaPack } from "./packs/java.js";
+import { phpPack } from "./packs/php.js";
+import { rubyPack } from "./packs/ruby.js";
+import { goPack } from "./packs/go.js";
+import { rustPack } from "./packs/rust.js";
+import { csharpPack } from "./packs/csharp.js";
+import { kotlinPack } from "./packs/kotlin.js";
+import { swiftPack } from "./packs/swift.js";
+import { dartPack } from "./packs/dart.js";
+import { cppPack } from "./packs/cpp.js";
+import { elixirPack } from "./packs/elixir.js";
+import { scalaPack } from "./packs/scala.js";
+import { rPack } from "./packs/r.js";
+const ALL_PACKS = [
+    jsTsPack,
+    pythonPack,
+    javaPack,
+    phpPack,
+    rubyPack,
+    goPack,
+    rustPack,
+    csharpPack,
+    kotlinPack,
+    swiftPack,
+    dartPack,
+    cppPack,
+    elixirPack,
+    scalaPack,
+    rPack,
+];
 export async function runCli(rootPath, options = {}) {
     const promptFn = options.promptFn ?? defaultPromptFn;
     const execFn = options.execFn ?? defaultExecFn;
@@ -61,7 +86,7 @@ export async function runCli(rootPath, options = {}) {
     }
     return writeGeneratedFiles(rootPath, files);
 }
-async function main() {
+export async function main() {
     clack.intro("agent-rules-init");
     if (!hasInteractiveTty()) {
         console.warn("No se detectó una terminal interactiva (esto pasa a veces en Git Bash en Windows). " +
@@ -96,7 +121,3 @@ async function main() {
         process.exitCode = 1;
     }
 }
-const isMainModule = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
-if (isMainModule) {
-    main();
-}

package/dist/core/scanner.js

@@ -48,11 +48,19 @@ function readTextIfExists(filePath) {
         return undefined;
     }
 }
-function findFirst(files, fileName) {
-    const matches = files.filter((f) => path.basename(f) === fileName);
+function shallowest(matches) {
     if (matches.length === 0)
         return undefined;
-    return matches.reduce((shallowest, candidate) => candidate.split(path.sep).length < shallowest.split(path.sep).length ? candidate : shallowest);
+    return matches.reduce((shallowestSoFar, candidate) => candidate.split(path.sep).length < shallowestSoFar.split(path.sep).length ? candidate : shallowestSoFar);
+}
+function findFirst(files, fileName) {
+    return shallowest(files.filter((f) => path.basename(f) === fileName));
+}
+function findFirstByExtension(files, extension) {
+    return shallowest(files.filter((f) => f.toLowerCase().endsWith(extension)));
+}
+function pickShallowest(paths) {
+    return shallowest(paths.filter((p) => p !== undefined));
 }
 export function scanRepo(rootPath) {
     const files = walk(rootPath);
@@ -79,10 +87,34 @@ export function scanRepo(rootPath) {
             requireDev: rawComposerJson["require-dev"] ?? {},
         }
         : undefined;
-    const pyprojectPath = findFirst(files, "pyproject.toml");
-    const requirementsPath = findFirst(files, "requirements.txt");
+    const pyprojectCandidate = findFirst(files, "pyproject.toml");
+    const requirementsCandidate = findFirst(files, "requirements.txt");
+    const environmentYmlCandidate = findFirst(files, "environment.yml") ?? findFirst(files, "environment.yaml");
+    // Only the shallowest of the three "wins" as the project's Python manifest — otherwise an
+    // unrelated pyproject.toml nested inside a vendored/data subdirectory (e.g. a bundled dataset
+    // package) would always outrank a real root-level environment.yml just by file type.
+    const primaryPythonManifest = pickShallowest([
+        pyprojectCandidate,
+        requirementsCandidate,
+        environmentYmlCandidate,
+    ]);
+    const pyprojectPath = primaryPythonManifest === pyprojectCandidate ? pyprojectCandidate : undefined;
+    const requirementsPath = primaryPythonManifest === requirementsCandidate ? requirementsCandidate : undefined;
+    const environmentYmlPath = primaryPythonManifest === environmentYmlCandidate ? environmentYmlCandidate : undefined;
     const pomPath = findFirst(files, "pom.xml");
     const buildGradlePath = findFirst(files, "build.gradle") ?? findFirst(files, "build.gradle.kts");
+    const gemfilePath = findFirst(files, "Gemfile");
+    const goModPath = findFirst(files, "go.mod");
+    const cargoTomlPath = findFirst(files, "Cargo.toml");
+    const csprojPath = findFirstByExtension(files, ".csproj");
+    const packageSwiftPath = findFirst(files, "Package.swift");
+    const pubspecYamlPath = findFirst(files, "pubspec.yaml");
+    const cmakeListsPath = findFirst(files, "CMakeLists.txt");
+    const makefilePath = findFirst(files, "Makefile") ?? findFirst(files, "makefile");
+    const mixExsPath = findFirst(files, "mix.exs");
+    const buildSbtPath = findFirst(files, "build.sbt");
+    const rDescriptionPath = findFirst(files, "DESCRIPTION");
+    const renvLockPath = findFirst(files, "renv.lock");
     return {
         rootPath,
         files,
@@ -94,8 +126,23 @@ export function scanRepo(rootPath) {
         requirementsTxt: requirementsPath
             ? readTextIfExists(path.join(rootPath, requirementsPath))
             : undefined,
+        environmentYml: environmentYmlPath
+            ? readTextIfExists(path.join(rootPath, environmentYmlPath))
+            : undefined,
         pomXml: pomPath ? readTextIfExists(path.join(rootPath, pomPath)) : undefined,
         buildGradle: buildGradlePath ? readTextIfExists(path.join(rootPath, buildGradlePath)) : undefined,
         composerJson,
+        gemfile: gemfilePath ? readTextIfExists(path.join(rootPath, gemfilePath)) : undefined,
+        goMod: goModPath ? readTextIfExists(path.join(rootPath, goModPath)) : undefined,
+        cargoToml: cargoTomlPath ? readTextIfExists(path.join(rootPath, cargoTomlPath)) : undefined,
+        csproj: csprojPath ? readTextIfExists(path.join(rootPath, csprojPath)) : undefined,
+        packageSwift: packageSwiftPath ? readTextIfExists(path.join(rootPath, packageSwiftPath)) : undefined,
+        pubspecYaml: pubspecYamlPath ? readTextIfExists(path.join(rootPath, pubspecYamlPath)) : undefined,
+        cmakeLists: cmakeListsPath ? readTextIfExists(path.join(rootPath, cmakeListsPath)) : undefined,
+        makefile: makefilePath ? readTextIfExists(path.join(rootPath, makefilePath)) : undefined,
+        mixExs: mixExsPath ? readTextIfExists(path.join(rootPath, mixExsPath)) : undefined,
+        buildSbt: buildSbtPath ? readTextIfExists(path.join(rootPath, buildSbtPath)) : undefined,
+        rDescription: rDescriptionPath ? readTextIfExists(path.join(rootPath, rDescriptionPath)) : undefined,
+        renvLock: renvLockPath ? readTextIfExists(path.join(rootPath, renvLockPath)) : undefined,
     };
 }

package/dist/core/types.d.ts

@@ -1 +1,64 @@
-export * from "agent-rules-pack-types";
+export interface PackageJsonManifest {
+    name?: string;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+}
+export interface ComposerJsonManifest {
+    require: Record<string, string>;
+    requireDev: Record<string, string>;
+}
+export interface RepoSignals {
+    rootPath: string;
+    files: string[];
+    hasFile: (relativePath: string) => boolean;
+    hasDir: (relativeDir: string) => boolean;
+    packageJson?: PackageJsonManifest;
+    pyprojectToml?: string;
+    requirementsTxt?: string;
+    environmentYml?: string;
+    pomXml?: string;
+    buildGradle?: string;
+    composerJson?: ComposerJsonManifest;
+    gemfile?: string;
+    goMod?: string;
+    cargoToml?: string;
+    csproj?: string;
+    packageSwift?: string;
+    pubspecYaml?: string;
+    cmakeLists?: string;
+    makefile?: string;
+    mixExs?: string;
+    buildSbt?: string;
+    rDescription?: string;
+    renvLock?: string;
+}
+export type Confidence = "high" | "low";
+export interface DetectionField<T> {
+    value: T;
+    confidence: Confidence;
+}
+export interface DetectionResult {
+    packId: string;
+    language: string;
+    framework?: DetectionField<string>;
+    packageManager?: DetectionField<string>;
+    testRunner?: DetectionField<string>;
+    linter?: DetectionField<string>;
+}
+export interface RuleSet {
+    summary: string;
+    conventions: string[];
+    architectureNotes: string[];
+}
+export interface PromptTemplate {
+    id: "review" | "refactor" | "testing";
+    title: string;
+    body: string;
+}
+export interface Pack {
+    id: string;
+    detect(signals: RepoSignals): DetectionResult | null;
+    rules(detection: DetectionResult): RuleSet;
+    promptTemplates(detection: DetectionResult): PromptTemplate[];
+}

package/dist/core/types.js

@@ -1 +1 @@
-export * from "agent-rules-pack-types";
+export {};

package/dist/packs/cpp.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const cppPack: Pack;

package/dist/packs/cpp.js

@@ -0,0 +1,70 @@
+const FRAMEWORKS = [
+    ["find_package(qt", "qt"],
+    ["find_package(boost", "boost"],
+    ["find_package(sdl2", "sdl2"],
+];
+const TEST_RUNNERS = [
+    ["gtest", "gtest"],
+    ["catch2", "catch2"],
+    ["doctest", "doctest"],
+];
+function detect(signals) {
+    const source = signals.cmakeLists ?? signals.makefile;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    let framework = { value: "none", confidence: "low" };
+    for (const [needle, label] of FRAMEWORKS) {
+        if (lower.includes(needle)) {
+            framework = { value: label, confidence: "high" };
+            break;
+        }
+    }
+    let testRunner = { value: "unknown", confidence: "low" };
+    for (const [needle, label] of TEST_RUNNERS) {
+        if (lower.includes(needle)) {
+            testRunner = { value: label, confidence: "high" };
+            break;
+        }
+    }
+    const packageManager = signals.cmakeLists
+        ? { value: "cmake", confidence: "high" }
+        : { 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: [
+            "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).",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const cppPack = { id: "cpp", detect, rules, promptTemplates };

package/dist/packs/csharp.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const csharpPack: Pack;

package/dist/packs/csharp.js

@@ -0,0 +1,59 @@
+function detect(signals) {
+    const source = signals.csproj;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    const framework = lower.includes("microsoft.aspnetcore")
+        ? { value: "aspnet-core", confidence: "high" }
+        : { value: "none", confidence: "low" };
+    const testRunner = lower.includes("xunit")
+        ? { value: "xunit", confidence: "high" }
+        : lower.includes("nunit")
+            ? { value: "nunit", confidence: "high" }
+            : lower.includes("mstest")
+                ? { value: "mstest", confidence: "high" }
+                : { value: "unknown", confidence: "low" };
+    return {
+        packId: "csharp",
+        language: "C#",
+        framework,
+        testRunner,
+        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: [
+            "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.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const csharpPack = { id: "csharp", detect, rules, promptTemplates };

package/dist/packs/dart.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const dartPack: Pack;

package/dist/packs/dart.js

@@ -0,0 +1,61 @@
+function detect(signals) {
+    const source = signals.pubspecYaml;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    const framework = /^\s*flutter\s*:/m.test(lower)
+        ? { value: "flutter", confidence: "high" }
+        : lower.includes("shelf")
+            ? { value: "shelf", confidence: "high" }
+            : { value: "none", confidence: "low" };
+    const testRunner = lower.includes("flutter_test")
+        ? { value: "flutter test", confidence: "high" }
+        : /^\s*test\s*:/m.test(lower)
+            ? { value: "dart test", confidence: "high" }
+            : { value: "unknown", confidence: "low" };
+    return {
+        packId: "dart",
+        language: "Dart",
+        framework,
+        testRunner,
+        packageManager: { value: "pub", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    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.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const dartPack = { id: "dart", detect, rules, promptTemplates };

package/dist/packs/elixir.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const elixirPack: Pack;

package/dist/packs/elixir.js

@@ -0,0 +1,52 @@
+function detect(signals) {
+    const source = signals.mixExs;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    const framework = lower.includes(":phoenix")
+        ? { value: "phoenix", confidence: "high" }
+        : { value: "none", confidence: "low" };
+    return {
+        packId: "elixir",
+        language: "Elixir",
+        framework,
+        testRunner: { value: "mix test", confidence: "high" },
+        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: [
+            "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.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const elixirPack = { id: "elixir", detect, rules, promptTemplates };

package/dist/packs/go.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const goPack: Pack;

package/dist/packs/go.js

@@ -0,0 +1,62 @@
+const FRAMEWORKS = [
+    ["gin-gonic/gin", "gin"],
+    ["labstack/echo", "echo"],
+    ["gofiber/fiber", "fiber"],
+    ["go-chi/chi", "chi"],
+];
+function detect(signals) {
+    const source = signals.goMod;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    let framework = { value: "none", confidence: "low" };
+    for (const [needle, label] of FRAMEWORKS) {
+        if (lower.includes(needle)) {
+            framework = { value: label, confidence: "high" };
+            break;
+        }
+    }
+    return {
+        packId: "go",
+        language: "Go",
+        framework,
+        testRunner: { value: "go test", confidence: "high" },
+        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: [
+            "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.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const goPack = { id: "go", detect, rules, promptTemplates };

package/dist/packs/java.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const javaPack: Pack;

package/dist/packs/java.js

@@ -0,0 +1,55 @@
+function detect(signals) {
+    const source = signals.pomXml ?? signals.buildGradle;
+    if (!source)
+        return null;
+    // A Gradle build that applies the Kotlin plugin is a Kotlin project, not Java —
+    // defer entirely to the Kotlin pack instead of also reporting a spurious Java match.
+    if (/kotlin\(|org\.jetbrains\.kotlin/i.test(source))
+        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" };
+    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: [
+            "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.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    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.`,
+        },
+    ];
+}
+export const javaPack = { id: "java", detect, rules, promptTemplates };

package/dist/packs/js-ts.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from "../core/types.js";
+export declare const jsTsPack: Pack;