agent-rules-init 0.1.3 → 0.2.1

package/dist/packs/go.js

@@ -0,0 +1,74 @@
+const FRAMEWORKS = [
+    ["gin-gonic/gin", "gin"],
+    ["labstack/echo", "echo"],
+    ["gofiber/fiber", "fiber"],
+    ["go-chi/chi", "chi"],
+];
+// The `module` line of go.mod is the project's own import path, not a dependency —
+// searching the whole file would false-positive on a framework whose own repo module
+// path happens to match a known framework name (e.g. gofiber/fiber's own go.mod
+// declares `module github.com/gofiber/fiber/v3`). Scope the search to `require` entries.
+function extractGoRequireSection(goMod) {
+    const sections = [];
+    for (const m of goMod.matchAll(/require\s*\(([\s\S]*?)\)/g))
+        sections.push(m[1]);
+    for (const m of goMod.matchAll(/^require\s+(?!\()(.+)$/gm))
+        sections.push(m[1]);
+    return sections.length > 0 ? sections.join("\n") : goMod;
+}
+function detect(signals) {
+    const source = signals.goMod;
+    if (!source)
+        return null;
+    const lower = extractGoRequireSection(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,59 @@
+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.
+    // Modern Gradle projects often declare plugins via version catalogs
+    // (`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))
+        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;

package/dist/packs/js-ts.js

@@ -0,0 +1,101 @@
+const FRAMEWORKS = {
+    next: "next",
+    "@nestjs/core": "nestjs",
+    react: "react",
+    vue: "vue",
+    "@angular/core": "angular",
+    svelte: "svelte",
+    fastify: "fastify",
+    koa: "koa",
+    express: "express",
+};
+const TEST_RUNNERS = {
+    vitest: "vitest",
+    jest: "jest",
+    mocha: "mocha",
+};
+const LINTERS = {
+    eslint: "eslint",
+    biome: "biome",
+};
+function detectFromDeps(deps, table) {
+    for (const [depName, label] of Object.entries(table)) {
+        if (deps[depName])
+            return { value: label, confidence: "high" };
+    }
+    return undefined;
+}
+function detect(signals) {
+    if (!signals.packageJson)
+        return null;
+    const allDeps = { ...signals.packageJson.dependencies, ...signals.packageJson.devDependencies };
+    const framework = detectFromDeps(allDeps, FRAMEWORKS) ?? {
+        value: "none",
+        confidence: "low",
+    };
+    const testRunner = detectFromDeps(allDeps, TEST_RUNNERS) ?? {
+        value: "unknown",
+        confidence: "low",
+    };
+    const linter = detectFromDeps(allDeps, LINTERS) ?? { value: "unknown", confidence: "low" };
+    const packageManager = signals.hasFile("pnpm-lock.yaml")
+        ? { value: "pnpm", confidence: "high" }
+        : signals.hasFile("yarn.lock")
+            ? { value: "yarn", confidence: "high" }
+            : signals.hasFile("package-lock.json")
+                ? { value: "npm", confidence: "high" }
+                : { value: "npm", confidence: "low" };
+    const usesTypeScript = Boolean(allDeps.typescript) || signals.hasFile("tsconfig.json");
+    const moduleFormat = signals.packageJson.moduleType;
+    return {
+        packId: "js-ts",
+        language: usesTypeScript ? "TypeScript" : "JavaScript",
+        framework,
+        testRunner,
+        linter,
+        packageManager,
+        usesTypeScript,
+        moduleFormat,
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    const testRunner = detection.testRunner?.value ?? "unknown";
+    const conventions = [];
+    if (detection.usesTypeScript) {
+        conventions.push("Usa TypeScript estricto; evita `any` salvo justificación explícita.");
+    }
+    conventions.push(`Ejecuta los tests con ${testRunner === "unknown" ? "el test runner del proyecto" : testRunner} antes de dar por terminada una tarea.`);
+    conventions.push(detection.moduleFormat === "module"
+        ? "Sigue el estilo de módulos ES existente (import/export), no mezcles con require()."
+        : "Sigue el estilo CommonJS existente (require()/module.exports), no mezcles con import/export.");
+    return {
+        summary: `Proyecto ${detection.usesTypeScript ? "TypeScript" : "JavaScript"}${framework !== "none" ? ` con ${framework}` : ""}.`,
+        conventions,
+        architectureNotes: [
+            "Mantén los componentes/módulos pequeños y con una responsabilidad clara.",
+            "Coloca los tests junto al código que prueban o en un directorio `test/` espejo, según lo que ya use el repo.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (JS/TS)",
+            body: `Revisa el diff actual buscando bugs de tipado, condiciones de carrera en async/await, y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (JS/TS)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable. Respeta los tipos existentes.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (JS/TS)",
+            body: `Escribe tests para el código señalado usando el test runner detectado (${detection.testRunner?.value ?? "el del proyecto"}). Cubre el camino feliz y al menos un caso límite.`,
+        },
+    ];
+}
+export const jsTsPack = { id: "js-ts", detect, rules, promptTemplates };

package/dist/packs/kotlin.d.ts

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

package/dist/packs/kotlin.js

@@ -0,0 +1,65 @@
+function detect(signals) {
+    const source = signals.buildGradle;
+    if (!source)
+        return null;
+    // Modern Gradle projects often declare the Kotlin plugin via a version catalog alias
+    // (`alias(libs.plugins.kotlin.android)`) rather than the literal `kotlin("jvm")` or
+    // `org.jetbrains.kotlin` plugin id, so a plain word-boundary check is more robust.
+    if (!/\bkotlin\b/i.test(source))
+        return null;
+    const framework = /ktor/i.test(source)
+        ? { value: "ktor", confidence: "high" }
+        : /com\.android\.application|com\.android\.library/i.test(source)
+            ? { value: "android", confidence: "high" }
+            : /spring/i.test(source)
+                ? { value: "spring", confidence: "high" }
+                : { value: "none", confidence: "low" };
+    const testRunner = /kotlin\.test|kotest/i.test(source)
+        ? { value: "kotest", confidence: "high" }
+        : /junit/i.test(source)
+            ? { value: "junit", confidence: "high" }
+            : { value: "unknown", confidence: "low" };
+    return {
+        packId: "kotlin",
+        language: "Kotlin",
+        framework,
+        testRunner,
+        packageManager: { value: "gradle", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Kotlin${framework !== "none" ? ` con ${framework}` : ""} (gradle).`,
+        conventions: [
+            "Sigue las convenciones de estilo oficiales de Kotlin (kotlinlang.org/docs/coding-conventions.html).",
+            "Ejecuta los tests con `gradle test` antes de terminar una tarea.",
+            "Prefiere tipos no-nulos y `val` sobre `var` salvo que la mutabilidad sea necesaria.",
+        ],
+        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 (Kotlin)",
+            body: `Revisa el diff actual buscando bugs, uso innecesario de \`!!\` y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (Kotlin)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Kotlin)",
+            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 kotlinPack = { id: "kotlin", detect, rules, promptTemplates };

package/dist/packs/php.d.ts

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

package/dist/packs/php.js

@@ -0,0 +1,63 @@
+const FRAMEWORKS = {
+    "laravel/framework": "laravel",
+    "symfony/symfony": "symfony",
+    "codeigniter4/framework": "codeigniter",
+};
+function detect(signals) {
+    if (!signals.composerJson)
+        return null;
+    const allDeps = { ...signals.composerJson.require, ...signals.composerJson.requireDev };
+    let framework = { value: "none", confidence: "low" };
+    for (const [dep, label] of Object.entries(FRAMEWORKS)) {
+        if (allDeps[dep]) {
+            framework = { value: label, confidence: "high" };
+            break;
+        }
+    }
+    const testRunner = allDeps["phpunit/phpunit"]
+        ? { value: "phpunit", confidence: "high" }
+        : { value: "unknown", confidence: "low" };
+    return {
+        packId: "php",
+        language: "PHP",
+        framework,
+        testRunner,
+        packageManager: { value: "composer", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto PHP${framework !== "none" ? ` con ${framework}` : ""} (composer).`,
+        conventions: [
+            "Sigue PSR-12 para el estilo de código.",
+            `Ejecuta los tests con ${detection.testRunner?.value === "phpunit" ? "vendor/bin/phpunit" : "el test runner del proyecto"} antes de terminar una tarea.`,
+            "Declara toda dependencia nueva en composer.json, nunca la instales sin registrarla.",
+        ],
+        architectureNotes: [
+            "Respeta la estructura MVC del framework si el proyecto ya la sigue.",
+            "Evita lógica de negocio en los controladores cuando el proyecto ya use capas de servicio.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (PHP)",
+            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 (PHP)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (PHP)",
+            body: `Escribe tests con ${detection.testRunner?.value === "phpunit" ? "PHPUnit" : "el test runner del proyecto"} para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
+        },
+    ];
+}
+export const phpPack = { id: "php", detect, rules, promptTemplates };

package/dist/packs/python.d.ts

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

package/dist/packs/python.js

@@ -0,0 +1,88 @@
+const FRAMEWORKS = [
+    ["fastapi", "fastapi"],
+    ["django", "django"],
+    ["flask", "flask"],
+];
+const TEST_RUNNERS = [
+    ["pytest", "pytest"],
+    ["unittest", "unittest"],
+];
+function findIn(haystack, table) {
+    const lower = haystack.toLowerCase();
+    for (const [needle, label] of table) {
+        if (lower.includes(needle))
+            return { value: label, confidence: "high" };
+    }
+    return undefined;
+}
+// Searching the whole pyproject.toml text (project name, URLs, script entry points, etc.)
+// produces false positives — e.g. Flask's own pyproject.toml has `name = "flask"`, which
+// isn't a dependency at all. Scope the search to the actual dependency declarations.
+function extractPyprojectDependencySections(pyproject) {
+    const sections = [];
+    const mainDeps = pyproject.match(/(?:^|\n)dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (mainDeps)
+        sections.push(mainDeps[1]);
+    const optionalDeps = pyproject.match(/\[project\.optional-dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (optionalDeps)
+        sections.push(optionalDeps[1]);
+    const dependencyGroups = pyproject.match(/\[dependency-groups\]([\s\S]*?)(?:\n\[|$)/);
+    if (dependencyGroups)
+        sections.push(dependencyGroups[1]);
+    const poetryDepsBlocks = pyproject.match(/\[tool\.poetry(?:\.group\.\w+)?\.dependencies\]([\s\S]*?)(?:\n\[|$)/g);
+    if (poetryDepsBlocks)
+        sections.push(...poetryDepsBlocks);
+    return sections.length > 0 ? sections.join("\n") : pyproject;
+}
+function detect(signals) {
+    const source = signals.pyprojectToml ?? signals.requirementsTxt ?? signals.environmentYml;
+    if (!source)
+        return null;
+    const searchText = signals.pyprojectToml ? extractPyprojectDependencySections(signals.pyprojectToml) : source;
+    const framework = findIn(searchText, FRAMEWORKS) ?? { value: "none", confidence: "low" };
+    const testRunner = findIn(searchText, TEST_RUNNERS) ?? { value: "unknown", confidence: "low" };
+    const packageManager = signals.environmentYml
+        ? { value: "conda", confidence: "high" }
+        : signals.hasFile("poetry.lock")
+            ? { value: "poetry", confidence: "high" }
+            : signals.pyprojectToml
+                ? { value: "pip (pyproject.toml)", confidence: "low" }
+                : { value: "pip", confidence: "low" };
+    return { packId: "python", language: "Python", framework, testRunner, packageManager };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Python${framework !== "none" ? ` con ${framework}` : ""}.`,
+        conventions: [
+            "Sigue PEP 8; usa type hints en funciones públicas.",
+            `Ejecuta los tests con ${detection.testRunner?.value ?? "el test runner del proyecto"} antes de terminar una tarea.`,
+            "No introduzcas dependencias nuevas sin añadirlas al manifiesto de dependencias existente.",
+        ],
+        architectureNotes: [
+            "Mantén la lógica de negocio separada de la capa de framework cuando el proyecto ya siga ese patrón.",
+            "Usa entornos virtuales; no instales paquetes globalmente.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (Python)",
+            body: `Revisa el diff actual buscando bugs, manejo de excepciones incorrecto y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (Python)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable. Respeta los type hints existentes.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Python)",
+            body: `Escribe tests para el código señalado usando ${detection.testRunner?.value ?? "el test runner del proyecto"}. Cubre el camino feliz y al menos un caso límite.`,
+        },
+    ];
+}
+export const pythonPack = { id: "python", detect, rules, promptTemplates };

package/dist/packs/r.d.ts

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

package/dist/packs/r.js

@@ -0,0 +1,60 @@
+const FRAMEWORKS = [
+    ["shiny", "shiny"],
+    ["plumber", "plumber"],
+];
+function detect(signals) {
+    const source = signals.rDescription ?? signals.renvLock;
+    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;
+        }
+    }
+    const testRunner = lower.includes("testthat")
+        ? { value: "testthat", confidence: "high" }
+        : { value: "unknown", confidence: "low" };
+    const packageManager = signals.renvLock
+        ? { value: "renv", confidence: "high" }
+        : { value: "CRAN", confidence: "low" };
+    return { packId: "r", language: "R", framework, testRunner, packageManager };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto R${framework !== "none" ? ` con ${framework}` : ""} (${detection.packageManager?.value}).`,
+        conventions: [
+            "Sigue la guía de estilo tidyverse (style.tidyverse.org) salvo que el proyecto ya use otra.",
+            `Ejecuta los tests con ${detection.testRunner?.value === "testthat" ? "testthat::test_dir(\"tests\")" : "el test runner del proyecto"} antes de terminar una tarea.`,
+            "Declara toda dependencia nueva en DESCRIPTION y actualiza renv.lock si el proyecto usa renv.",
+        ],
+        architectureNotes: [
+            "Mantén las funciones puras y con una responsabilidad clara; evita modificar el entorno global.",
+            "Separa el análisis/scripts de la lógica reutilizable empaquetada en funciones.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (R)",
+            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 (R)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (R)",
+            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 rPack = { id: "r", detect, rules, promptTemplates };

package/dist/packs/ruby.d.ts

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

package/dist/packs/ruby.js

@@ -0,0 +1,59 @@
+function detect(signals) {
+    const source = signals.gemfile;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    const framework = /gem\s+['"]rails['"]/.test(lower)
+        ? { value: "rails", confidence: "high" }
+        : /gem\s+['"]sinatra['"]/.test(lower)
+            ? { value: "sinatra", confidence: "high" }
+            : { value: "none", confidence: "low" };
+    const testRunner = /gem\s+['"]rspec/.test(lower)
+        ? { value: "rspec", confidence: "high" }
+        : /gem\s+['"]minitest['"]/.test(lower)
+            ? { value: "minitest", confidence: "high" }
+            : { value: "unknown", confidence: "low" };
+    return {
+        packId: "ruby",
+        language: "Ruby",
+        framework,
+        testRunner,
+        packageManager: { value: "bundler", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Ruby${framework !== "none" ? ` con ${framework}` : ""} (bundler).`,
+        conventions: [
+            "Sigue la guía de estilo Ruby estándar (snake_case para métodos/variables, CamelCase para clases).",
+            `Ejecuta los tests con ${detection.testRunner?.value === "rspec" ? "bundle exec rspec" : detection.testRunner?.value === "minitest" ? "bundle exec rake test" : "el test runner del proyecto"} antes de terminar una tarea.`,
+            "Declara toda dependencia nueva en el Gemfile, nunca instales una gema sin registrarla.",
+        ],
+        architectureNotes: [
+            "Respeta la estructura MVC del framework si el proyecto ya la sigue.",
+            "Evita lógica de negocio en los controladores cuando el proyecto ya use capas de servicio.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (Ruby)",
+            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 (Ruby)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Ruby)",
+            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 rubyPack = { id: "ruby", detect, rules, promptTemplates };

package/dist/packs/rust.d.ts

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