agent-rules-init 0.2.1 → 0.4.0

package/dist/packs/js-ts.js

@@ -1,3 +1,5 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
+import { canonicalOf } from "../core/canonical-commands.js";
 const FRAMEWORKS = {
     next: "next",
     "@nestjs/core": "nestjs",
@@ -25,77 +27,188 @@ function detectFromDeps(deps, table) {
     }
     return undefined;
 }
+function detectPackageManagerFromCi(signals) {
+    const managers = new Set();
+    for (const workflow of signals.githubWorkflows ?? []) {
+        for (const rawLine of workflow.content.split(/\r?\n/)) {
+            const command = rawLine.trim().replace(/^(?:-\s*)?run:\s*(?:[|>]\s*)?/, "").trim();
+            const manager = /^(npm|pnpm|yarn|bun)\b/.exec(command)?.[1];
+            if (manager)
+                managers.add(manager);
+        }
+    }
+    return managers.size === 1 ? { value: [...managers][0], confidence: "high" } : undefined;
+}
 function detect(signals) {
     if (!signals.packageJson)
         return null;
     const allDeps = { ...signals.packageJson.dependencies, ...signals.packageJson.devDependencies };
+    const hasAnyFileNamed = (name) => signals.files.some((file) => file.split(/[\\/]/).pop() === name);
+    const frameworkSource = signals.packageJson.name
+        ? FRAMEWORKS[signals.packageJson.name]
+        : undefined;
     const framework = detectFromDeps(allDeps, FRAMEWORKS) ?? {
         value: "none",
-        confidence: "low",
+        confidence: frameworkSource ? "high" : "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;
+    const packageManager = signals.packageJson.packageManager
+        ? { value: signals.packageJson.packageManager, confidence: "high" }
+        : signals.hasFile("bun.lock") || signals.hasFile("bun.lockb")
+            ? { value: "bun", confidence: "high" }
+            : signals.hasFile("pnpm-lock.yaml")
+                ? { value: "pnpm", confidence: "high" }
+                : signals.hasFile("yarn.lock")
+                    ? { value: "yarn", confidence: "high" }
+                    : signals.hasFile("package-lock.json") || signals.hasFile("npm-shrinkwrap.json")
+                        ? { value: "npm", confidence: "high" }
+                        : hasAnyFileNamed("bun.lock") || hasAnyFileNamed("bun.lockb")
+                            ? { value: "bun", confidence: "high" }
+                            : hasAnyFileNamed("pnpm-lock.yaml")
+                                ? { value: "pnpm", confidence: "high" }
+                                : hasAnyFileNamed("yarn.lock")
+                                    ? { value: "yarn", confidence: "high" }
+                                    : hasAnyFileNamed("package-lock.json") || hasAnyFileNamed("npm-shrinkwrap.json")
+                                        ? { value: "npm", confidence: "high" }
+                                        : detectPackageManagerFromCi(signals) ?? { value: "npm", confidence: "low" };
+    const usesTypeScript = Boolean(allDeps.typescript) || signals.hasFile("tsconfig.json") || hasAnyFileNamed("tsconfig.json");
+    const moduleTypes = new Set((signals.packageJsons?.length ? signals.packageJsons : [signals.packageJson]).map((p) => p.moduleType));
+    // Mixed ESM/CommonJS workspaces should not receive a repo-wide rule that is wrong
+    // for half of the packages.
+    const moduleFormat = moduleTypes.size === 1 ? [...moduleTypes][0] : undefined;
     return {
         packId: "js-ts",
         language: usesTypeScript ? "TypeScript" : "JavaScript",
         framework,
         testRunner,
         linter,
+        frameworkSource,
         packageManager,
         usesTypeScript,
         moduleFormat,
     };
 }
-function rules(detection) {
-    const framework = detection.framework?.value ?? "none";
-    const testRunner = detection.testRunner?.value ?? "unknown";
+const TEXTS = {
+    es: {
+        tsStrict: "Usa TypeScript estricto; evita `any` salvo justificación explícita.",
+        esModules: "Sigue el estilo de módulos ES existente (import/export), no mezcles con require().",
+        commonJs: "Sigue el estilo CommonJS existente (require()/module.exports), no mezcles con import/export.",
+        arch: [
+            "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.",
+        ],
+        reviewFocusTs: "errores de tipado, condiciones de carrera en async/await",
+        reviewFocusJs: "condiciones de carrera en async/await",
+        refactorExtra: "Respeta los tipos existentes.",
+    },
+    en: {
+        tsStrict: "Use strict TypeScript; avoid `any` unless explicitly justified.",
+        esModules: "Follow the existing ES modules style (import/export); do not mix in require().",
+        commonJs: "Follow the existing CommonJS style (require()/module.exports); do not mix in import/export.",
+        arch: [
+            "Keep components/modules small and single-purpose.",
+            "Place tests next to the code they cover or in a mirrored `test/` directory, following what the repo already uses.",
+        ],
+        reviewFocusTs: "typing errors, async/await race conditions",
+        reviewFocusJs: "async/await race conditions",
+        refactorExtra: "Respect the existing types.",
+    },
+};
+const FRAMEWORK_RISKS = {
+    express: {
+        es: "Presta especial atención al flujo de middleware, la propagación de errores con `next(err)` y el ciclo de vida de la respuesta.",
+        en: "Pay special attention to middleware control flow, error propagation through `next(err)` and response lifecycle handling.",
+    },
+    react: {
+        es: "Presta especial atención a las dependencias de hooks (`useEffect`), renders innecesarios y estado derivado.",
+        en: "Pay special attention to hook dependencies (`useEffect`), unnecessary re-renders and derived state.",
+    },
+    next: {
+        es: "Presta especial atención a la frontera servidor/cliente (`use client`), el data fetching y el caché de rutas.",
+        en: "Pay special attention to the server/client boundary (`use client`), data fetching and route caching.",
+    },
+    nestjs: {
+        es: "Presta especial atención a los scopes de providers, la inyección de dependencias y los pipes de validación.",
+        en: "Pay special attention to provider scopes, dependency injection and validation pipes.",
+    },
+    fastify: {
+        es: "Presta especial atención al ciclo de vida de plugins, la encapsulación y los schemas de validación.",
+        en: "Pay special attention to plugin lifecycle, encapsulation and validation schemas.",
+    },
+};
+function rules(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 testCmd = canonicalOf(ctx, "test", "js-ts")?.command ?? runner;
     const conventions = [];
-    if (detection.usesTypeScript) {
-        conventions.push("Usa TypeScript estricto; evita `any` salvo justificación explícita.");
+    if (detection.usesTypeScript)
+        conventions.push(t.tsStrict);
+    conventions.push(runTestsConvention(lang, testCmd));
+    if (detection.moduleFormat) {
+        conventions.push(detection.moduleFormat === "module" ? t.esModules : t.commonJs);
     }
-    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}` : ""}.`,
+        summary: detection.frameworkSource
+            ? lang === "es"
+                ? `Repositorio ${detection.usesTypeScript ? "TypeScript" : "JavaScript"} que implementa ${detection.frameworkSource}.`
+                : `${detection.usesTypeScript ? "TypeScript" : "JavaScript"} repository implementing ${detection.frameworkSource}.`
+            : summarySentence(lang, detection.usesTypeScript ? "TypeScript" : "JavaScript", 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.",
-        ],
+        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 focus = detection.usesTypeScript ? t.reviewFocusTs : t.reviewFocusJs;
+    const test = canonicalOf(ctx, "test", "js-ts");
+    const lint = canonicalOf(ctx, "lint", "js-ts");
+    const testDirs = ctx?.facts.testDirs ?? [];
+    const es = lang === "es";
+    const reviewParts = [];
+    const moduleLabel = detection.moduleFormat === "commonjs" ? "CommonJS" : detection.moduleFormat === "module" ? "ESM" : undefined;
+    reviewParts.push(es
+        ? `Revisa el diff actual contra las convenciones${moduleLabel ? ` ${moduleLabel}` : ""} de este repositorio${framework ? ` (${framework})` : ""}.`
+        : `Review the current diff against this repository's${moduleLabel ? ` ${moduleLabel}` : ""} conventions${framework ? ` (${framework})` : ""}.`);
+    if (test || lint) {
+        const commands = [test, lint].filter((c) => c !== undefined);
+        const list = commands.map((c) => `\`${c.command}\``).join(es ? " y " : " and ");
+        reviewParts.push(es ? `Ejecuta ${list} antes de dar por buena la revisión.` : `Run ${list} before approving the review.`);
+    }
+    const risk = FRAMEWORK_RISKS[framework ?? detection.frameworkSource ?? ""]?.[lang];
+    if (risk)
+        reviewParts.push(risk);
+    reviewParts.push(es ? `Busca también bugs: ${focus}.` : `Also look for bugs: ${focus}.`);
+    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 = [];
+    testingParts.push(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 (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.`,
+            body: ctx ? reviewParts.join(" ") : reviewBody(lang, focus, framework),
         },
+        { id: "refactor", title: "Refactor (JS/TS)", body: refactorBody(lang, detection.usesTypeScript ? t.refactorExtra : undefined) },
+        { id: "testing", title: "Testing (JS/TS)", body: ctx ? testingParts.join(" ") : testingBody(lang, runner) },
     ];
 }
 export const jsTsPack = { id: "js-ts", detect, rules, promptTemplates };

package/dist/packs/kotlin.js

@@ -1,12 +1,17 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 function detect(signals) {
-    const source = signals.buildGradle;
+    const gradleSource = signals.buildGradle && /\bkotlin\b/i.test(signals.buildGradle)
+        ? signals.buildGradle
+        : undefined;
+    const mavenSource = signals.pomXml && /\bkotlin\b/i.test(signals.pomXml)
+        ? signals.pomXml
+        : undefined;
+    const source = gradleSource ?? mavenSource;
     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)
@@ -24,42 +29,62 @@ function detect(signals) {
         language: "Kotlin",
         framework,
         testRunner,
-        packageManager: { value: "gradle", confidence: "high" },
+        packageManager: mavenSource && !gradleSource
+            ? 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" },
     };
 }
-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: [
+const TEXTS = {
+    es: {
+        style: "Sigue las convenciones de estilo oficiales de Kotlin (kotlinlang.org/docs/coding-conventions.html).",
+        nullsafety: "Prefiere tipos no-nulos y `val` sobre `var` salvo que la mutabilidad sea necesaria.",
+        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: "uso innecesario de `!!`",
+    },
+    en: {
+        style: "Follow the official Kotlin style conventions (kotlinlang.org/docs/coding-conventions.html).",
+        nullsafety: "Prefer non-null types and `val` over `var` unless mutability is required.",
+        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: "unnecessary `!!` usage",
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    return {
+        summary: summarySentence(lang, "Kotlin", framework, detection.packageManager?.value),
+        conventions: [
+            t.style,
+            runTestsConvention(lang, detection.packageManager?.value === "maven wrapper"
+                ? "`./mvnw test`"
+                : detection.packageManager?.value === "maven"
+                    ? "`mvn test`"
+                    : detection.packageManager?.value === "gradle wrapper"
+                        ? "`./gradlew test`"
+                        : "`gradle test`"),
+            t.nullsafety,
+        ],
+        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 (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.`,
-        },
+        { id: "review", title: "Code Review (Kotlin)", body: reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (Kotlin)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (Kotlin)", body: testingBody(lang, runner) },
     ];
 }
 export const kotlinPack = { id: "kotlin", detect, rules, promptTemplates };

package/dist/packs/php.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
 const FRAMEWORKS = {
     "laravel/framework": "laravel",
     "symfony/symfony": "symfony",
@@ -25,39 +26,41 @@ function detect(signals) {
         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: [
+const TEXTS = {
+    es: {
+        style: "Sigue PSR-12 para el estilo de código.",
+        deps: "Declara toda dependencia nueva en composer.json, nunca la instales sin registrarla.",
+        arch: [
             "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.",
         ],
+    },
+    en: {
+        style: "Follow PSR-12 for code style.",
+        deps: "Declare every new dependency in composer.json; never install one without registering it.",
+        arch: [
+            "Respect the framework's MVC structure if the project already follows it.",
+            "Avoid business logic in controllers when the project already uses service layers.",
+        ],
+    },
+};
+function rules(detection, lang) {
+    const t = TEXTS[lang];
+    const framework = detection.framework?.value !== "none" ? detection.framework?.value : undefined;
+    const testCmd = detection.testRunner?.value === "phpunit" ? "vendor/bin/phpunit" : undefined;
+    return {
+        summary: summarySentence(lang, "PHP", framework, "composer"),
+        conventions: [t.style, runTestsConvention(lang, testCmd), t.deps],
+        architectureNotes: t.arch,
     };
 }
-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 === "phpunit" ? "PHPUnit" : undefined;
     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.`,
-        },
+        { id: "review", title: "Code Review (PHP)", body: reviewBody(lang, "", framework) },
+        { id: "refactor", title: "Refactor (PHP)", body: refactorBody(lang) },
+        { id: "testing", title: "Testing (PHP)", body: testingBody(lang, runner) },
     ];
 }
 export const phpPack = { id: "php", detect, rules, promptTemplates };

package/dist/packs/python.js

@@ -1,3 +1,5 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, } from "../core/i18n.js";
+import { canonicalOf } from "../core/canonical-commands.js";
 const FRAMEWORKS = [
     ["fastapi", "fastapi"],
     ["django", "django"],
@@ -34,55 +36,126 @@ function extractPyprojectDependencySections(pyproject) {
         sections.push(...poetryDepsBlocks);
     return sections.length > 0 ? sections.join("\n") : pyproject;
 }
+function frameworkSourceProject(pyproject) {
+    const projectBlock = pyproject.match(/(?:^|\n)\[project\]([\s\S]*?)(?:\n\[|$)/)?.[1];
+    const name = projectBlock?.match(/(?:^|\n)\s*name\s*=\s*["']([^"']+)["']/i)?.[1].toLowerCase();
+    return FRAMEWORKS.find(([framework]) => framework === name)?.[1];
+}
 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 frameworkSource = signals.pyprojectToml
+        ? frameworkSourceProject(signals.pyprojectToml)
+        : undefined;
+    const framework = findIn(searchText, FRAMEWORKS) ?? {
+        value: "none",
+        confidence: frameworkSource
+            ? "high"
+            : "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 };
+        : signals.hasFile("uv.lock")
+            ? { value: "uv", 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, frameworkSource, 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: [
+const TEXTS = {
+    es: {
+        style: "Sigue PEP 8; usa type hints en funciones públicas.",
+        deps: "No introduzcas dependencias nuevas sin añadirlas al manifiesto de dependencias existente.",
+        arch: [
             "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.",
         ],
+        reviewFocus: "manejo de excepciones incorrecto",
+        refactorExtra: "Respeta los type hints existentes.",
+    },
+    en: {
+        style: "Follow PEP 8; use type hints on public functions.",
+        deps: "Do not introduce new dependencies without adding them to the existing dependency manifest.",
+        arch: [
+            "Keep business logic separate from the framework layer when the project already follows that pattern.",
+            "Use virtual environments; never install packages globally.",
+        ],
+        reviewFocus: "incorrect exception handling",
+        refactorExtra: "Respect the existing type hints.",
+    },
+};
+const FRAMEWORK_RISKS = {
+    flask: {
+        es: "Presta especial atención al contexto de aplicación/petición, los blueprints y el manejo de errores HTTP.",
+        en: "Pay special attention to application/request context, blueprints and HTTP error handling.",
+    },
+    django: {
+        es: "Presta especial atención a migraciones pendientes, consultas N+1 del ORM y validación en forms/serializers.",
+        en: "Pay special attention to pending migrations, ORM N+1 queries and validation in forms/serializers.",
+    },
+    fastapi: {
+        es: "Presta especial atención a los modelos Pydantic, las dependencias async y los códigos de respuesta declarados.",
+        en: "Pay special attention to Pydantic models, async dependencies and declared response codes.",
+    },
+};
+function rules(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 testCmd = canonicalOf(ctx, "test", "python")?.command ?? runner;
+    return {
+        summary: detection.frameworkSource
+            ? lang === "es"
+                ? `Repositorio Python que implementa ${detection.frameworkSource}.`
+                : `Python repository implementing ${detection.frameworkSource}.`
+            : summarySentence(lang, "Python", framework),
+        conventions: [t.style, 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", "python");
+    const testDirs = ctx?.facts.testDirs ?? [];
+    const hasTox = ctx?.facts.commands.some((c) => c.source === "tox") ?? false;
+    const es = lang === "es";
+    const reviewParts = [];
+    reviewParts.push(es
+        ? `Revisa el diff actual contra las convenciones Python de este repositorio${framework ? ` (${framework})` : ""}.`
+        : `Review the current diff against this repository's Python 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 (hasTox) {
+        reviewParts.push(es ? "La matriz completa de entornos se ejecuta con tox (`tox.ini`)." : "The full environment matrix runs through tox (`tox.ini`).");
+    }
+    const risk = FRAMEWORK_RISKS[framework ?? detection.frameworkSource ?? ""]?.[lang];
+    if (risk)
+        reviewParts.push(risk);
+    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 (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.`,
-        },
+        { id: "review", title: "Code Review (Python)", body: ctx ? reviewParts.join(" ") : reviewBody(lang, t.reviewFocus, framework) },
+        { id: "refactor", title: "Refactor (Python)", body: refactorBody(lang, t.refactorExtra) },
+        { id: "testing", title: "Testing (Python)", body: ctx ? testingParts.join(" ") : testingBody(lang, runner) },
     ];
 }
 export const pythonPack = { id: "python", detect, rules, promptTemplates };