agent-rules-init 0.2.1 → 0.3.0

package/dist/core/repo-facts.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import { parse } from "yaml";
+import { UI } from "./i18n.js";
+const NPM_DIRECT_LIFECYCLE = new Set(["test", "start", "stop", "restart"]);
+export function extractNpmCommands(signals) {
+    const scripts = signals.packageJson?.scripts ?? {};
+    const entries = [];
+    for (const [name, body] of Object.entries(scripts)) {
+        if (typeof body !== "string" || body.trim() === "")
+            continue;
+        entries.push({
+            source: "npm",
+            invocation: NPM_DIRECT_LIFECYCLE.has(name) ? `npm ${name}` : `npm run ${name}`,
+            detail: body.trim(),
+        });
+    }
+    return entries;
+}
+export function extractMakeTargets(signals) {
+    const makefile = signals.makefile;
+    if (!makefile)
+        return [];
+    const targets = new Set();
+    for (const line of makefile.split(/\r?\n/)) {
+        // Un target va a inicio de línea (las recetas van indentadas con tab) y su nombre
+        // no lleva %, ni empieza por "." (targets especiales tipo .PHONY). El (?!=) evita
+        // asignaciones ":=". La clase de caracteres ya excluye espacios, con lo que
+        // "CFLAGS :=", los comentarios "#" y las URLs en comentarios tampoco matchean.
+        const match = /^([A-Za-z0-9_/-][A-Za-z0-9_./-]*)\s*:(?!=)/.exec(line);
+        if (!match)
+            continue;
+        targets.add(match[1]);
+    }
+    return [...targets].map((target) => ({ source: "make", invocation: `make ${target}` }));
+}
+export function extractMixAliases(signals) {
+    const mixExs = signals.mixExs;
+    if (!mixExs)
+        return [];
+    // Cuerpo de la función aliases (defp aliases do ... end). Si no existe con esa
+    // forma, no se emite nada — omitir antes que inventar.
+    const fnMatch = mixExs.match(/defp?\s+aliases\s*(?:\(\))?\s*do([\s\S]*?)\n\s*end/);
+    if (!fnMatch)
+        return [];
+    const body = fnMatch[1];
+    const names = new Set();
+    // Claves del keyword list cuyo valor empieza por lista o string: `setup: [...]`,
+    // `"ecto.setup": [...]`. Un alias con valor función (&fun/1) se omite.
+    for (const match of body.matchAll(/(?:"([^"]+)"|([a-z_][a-zA-Z0-9_.]*)):\s*(?=[["'])/g)) {
+        names.add(match[1] ?? match[2]);
+    }
+    return [...names].map((alias) => ({ source: "mix", invocation: `mix ${alias}` }));
+}
+export function extractToxEnvs(signals) {
+    const toxIni = signals.toxIni;
+    if (!toxIni)
+        return [];
+    const match = toxIni.match(/^[ \t]*env_?list\s*=\s*(.+(?:\n[ \t]+\S.*)*)/m);
+    if (!match)
+        return [];
+    const envs = match[1]
+        .split(/[,\s]+/)
+        .map((env) => env.trim())
+        // Los envs con factores generadores (py3{10,11}) se omiten en vez de expandirlos.
+        // El split por comas los parte en trozos ("py3{10", "11}"), así que basta con
+        // descartar cualquier trozo que contenga una llave.
+        .filter((env) => env !== "" && !env.startsWith("#") && !/[{}]/.test(env));
+    return [...new Set(envs)].map((env) => ({ source: "tox", invocation: `tox -e ${env}` }));
+}
+export function extractComposerCommands(signals) {
+    const scripts = signals.composerJson?.scripts ?? {};
+    const entries = [];
+    for (const [name, raw] of Object.entries(scripts)) {
+        const parts = Array.isArray(raw)
+            ? raw.filter((p) => typeof p === "string")
+            : typeof raw === "string"
+                ? [raw]
+                : [];
+        if (parts.length === 0)
+            continue;
+        entries.push({ source: "composer", invocation: `composer ${name}`, detail: parts.join(" && ") });
+    }
+    return entries;
+}
+const WELL_KNOWN_NAMES = new Set([
+    "test", "tests", "build", "lint", "fmt", "format", "check", "dev", "start",
+    "typecheck", "ci", "coverage", "e2e", "unit", "docs", "clean", "install",
+    "setup", "release", "watch", "fix", "all",
+]);
+const MAX_COMMANDS_PER_SOURCE = 15;
+function invocationName(entry) {
+    const parts = entry.invocation.split(" ");
+    return parts[parts.length - 1];
+}
+export function filterCommands(entries) {
+    const kept = [];
+    const omitted = [];
+    const sources = [...new Set(entries.map((e) => e.source))];
+    for (const source of sources) {
+        const group = entries.filter((e) => e.source === source);
+        const wellKnown = group.filter((e) => WELL_KNOWN_NAMES.has(invocationName(e)));
+        const rest = group.filter((e) => !WELL_KNOWN_NAMES.has(invocationName(e)));
+        const keptGroup = new Set([...wellKnown, ...rest].slice(0, MAX_COMMANDS_PER_SOURCE));
+        // Se emite en el orden original del manifiesto, no con los conocidos primero.
+        kept.push(...group.filter((e) => keptGroup.has(e)));
+        const omittedCount = group.length - keptGroup.size;
+        if (omittedCount > 0)
+            omitted.push({ source, count: omittedCount });
+    }
+    return { kept, omitted };
+}
+const MAX_CI_COMMANDS = 30;
+// Líneas de un script multilínea que son control de flujo del shell, no comandos:
+// `if [[ ... ]]; then`, `else`, `fi`, `for x in ...; do`, `done`, `case`/`esac`...
+const SHELL_CONTROL_FLOW = /^(?:if|elif|else|fi|then|do|done|for|while|until|case|esac)\b|^(?:fi|then|else|done|esac)$/;
+function isShellControlFlow(line) {
+    return SHELL_CONTROL_FLOW.test(line);
+}
+export function extractCiCommands(signals) {
+    const seen = new Map(); // comando -> workflow de origen
+    for (const workflow of signals.githubWorkflows ?? []) {
+        let doc;
+        try {
+            doc = parse(workflow.content);
+        }
+        catch {
+            continue; // YAML inválido: omitir antes que inventar
+        }
+        if (!doc || typeof doc !== "object")
+            continue;
+        const jobs = doc.jobs;
+        if (!jobs || typeof jobs !== "object")
+            continue;
+        const workflowName = workflow.path.split("/").pop() ?? workflow.path;
+        for (const job of Object.values(jobs)) {
+            if (!job || typeof job !== "object")
+                continue;
+            const steps = job.steps;
+            if (!Array.isArray(steps))
+                continue;
+            for (const step of steps) {
+                if (!step || typeof step !== "object")
+                    continue;
+                const run = step.run;
+                if (typeof run !== "string")
+                    continue;
+                for (const rawLine of run.split(/\r?\n/)) {
+                    const line = rawLine.trim();
+                    if (line === "" || line.startsWith("#") || isShellControlFlow(line))
+                        continue;
+                    if (!seen.has(line))
+                        seen.set(line, workflowName);
+                }
+            }
+        }
+    }
+    const all = [...seen.entries()].map(([command, workflow]) => ({ command, workflow }));
+    return {
+        commands: all.slice(0, MAX_CI_COMMANDS),
+        omittedCount: Math.max(0, all.length - MAX_CI_COMMANDS),
+    };
+}
+const MAX_DIRS = 20;
+export function extractStructure(signals, lang) {
+    const dirNotes = UI[lang].dirNotes;
+    const dirs = new Set();
+    for (const file of signals.files) {
+        const normalized = file.split(path.sep).join("/");
+        const slash = normalized.indexOf("/");
+        if (slash > 0)
+            dirs.add(normalized.slice(0, slash));
+    }
+    return [...dirs]
+        .sort()
+        .slice(0, MAX_DIRS)
+        .map((dir) => {
+        const note = dirNotes[dir.toLowerCase()];
+        return note ? { dir: `${dir}/`, note } : { dir: `${dir}/` };
+    });
+}
+export function buildRepoFacts(signals, lang) {
+    const allCommands = [
+        ...extractNpmCommands(signals),
+        ...extractComposerCommands(signals),
+        ...extractMakeTargets(signals),
+        ...extractMixAliases(signals),
+        ...extractToxEnvs(signals),
+    ];
+    const { kept, omitted } = filterCommands(allCommands);
+    const { commands: ciCommands, omittedCount: omittedCiCount } = extractCiCommands(signals);
+    return {
+        commands: kept,
+        omittedCommands: omitted,
+        structure: extractStructure(signals, lang),
+        ciCommands,
+        omittedCiCount,
+    };
+}

package/dist/core/scanner.js

@@ -28,11 +28,16 @@ function walk(rootPath) {
     recurse(rootPath, 0);
     return results;
 }
+// Windows editors (Notepad, PowerShell's Set-Content, some IDE defaults) save UTF-8
+// with a leading BOM, which JSON.parse rejects and line-anchored regexes trip over.
+function stripBom(content) {
+    return content.charCodeAt(0) === 0xfeff ? content.slice(1) : content;
+}
 function readJsonIfExists(filePath) {
     if (!fs.existsSync(filePath))
         return undefined;
     try {
-        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return JSON.parse(stripBom(fs.readFileSync(filePath, "utf-8")));
     }
     catch {
         return undefined;
@@ -42,7 +47,7 @@ function readTextIfExists(filePath) {
     if (!fs.existsSync(filePath))
         return undefined;
     try {
-        return fs.readFileSync(filePath, "utf-8");
+        return stripBom(fs.readFileSync(filePath, "utf-8"));
     }
     catch {
         return undefined;
@@ -121,6 +126,7 @@ export function scanRepo(rootPath) {
         ? {
             require: rawComposerJson.require ?? {},
             requireDev: rawComposerJson["require-dev"] ?? {},
+            scripts: rawComposerJson.scripts ?? {},
         }
         : undefined;
     const pyprojectCandidate = findFirstPreferringRealProjectDirs(files, "pyproject.toml");
@@ -157,11 +163,21 @@ export function scanRepo(rootPath) {
     // packages/*. Aggregate all of them so the actual framework/test runner is found.
     const pubspecYamlPaths = findAllByNames(files, ["pubspec.yaml"]);
     const cmakeListsPath = findFirst(files, "CMakeLists.txt");
-    const makefilePath = findFirst(files, "Makefile") ?? findFirst(files, "makefile");
+    // Un Makefile que solo existe bajo docs/, tools/, etc. es tooling auxiliar (p. ej. el
+    // Makefile de Sphinx en docs/ de Flask): sus targets no se pueden ejecutar desde la
+    // raíz y no describen el proyecto. Mismo criterio que los manifiestos Python.
+    const makefilePath = findFirstPreferringRealProjectDirs(files, "Makefile") ??
+        findFirstPreferringRealProjectDirs(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");
+    const toxIniPath = findFirst(files, "tox.ini");
+    const workflowPaths = files.filter((f) => {
+        const normalized = f.split(path.sep).join("/");
+        return (normalized.startsWith(".github/workflows/") &&
+            (normalized.endsWith(".yml") || normalized.endsWith(".yaml")));
+    });
     return {
         rootPath,
         files,
@@ -191,5 +207,12 @@ export function scanRepo(rootPath) {
         buildSbt: buildSbtPath ? readTextIfExists(path.join(rootPath, buildSbtPath)) : undefined,
         rDescription: rDescriptionPath ? readTextIfExists(path.join(rootPath, rDescriptionPath)) : undefined,
         renvLock: renvLockPath ? readTextIfExists(path.join(rootPath, renvLockPath)) : undefined,
+        toxIni: toxIniPath ? readTextIfExists(path.join(rootPath, toxIniPath)) : undefined,
+        githubWorkflows: workflowPaths
+            .map((p) => ({
+            path: p.split(path.sep).join("/"),
+            content: readTextIfExists(path.join(rootPath, p)),
+        }))
+            .filter((w) => w.content !== undefined),
     };
 }

package/dist/core/templates.d.ts

@@ -1,11 +1,13 @@
-import type { DetectionResult, PromptTemplate, RuleSet } from "./types.js";
+import { type Lang } from "./i18n.js";
+import type { DetectionResult, PromptTemplate, RepoFacts, RuleSet } from "./types.js";
 export interface RenderEntry {
     detection: DetectionResult;
     ruleSet: RuleSet;
 }
-export declare function renderClaudeMd(entries: RenderEntry[]): string;
-export declare function renderAgentsMd(entries: RenderEntry[]): string;
-export declare function renderCopilotInstructions(entries: RenderEntry[]): string;
+export declare function renderRepoFacts(facts: RepoFacts, lang: Lang): string;
+export declare function renderClaudeMd(entries: RenderEntry[], facts: RepoFacts | undefined, lang: Lang): string;
+export declare function renderAgentsMd(entries: RenderEntry[], facts: RepoFacts | undefined, lang: Lang): string;
+export declare function renderCopilotInstructions(entries: RenderEntry[], facts: RepoFacts | undefined, lang: Lang): string;
 export declare function renderPromptFiles(packId: string, templates: PromptTemplate[]): {
     path: string;
     content: string;

package/dist/core/templates.js

@@ -1,4 +1,6 @@
-function renderSection(entries) {
+import { UI } from "./i18n.js";
+function renderSection(entries, lang) {
+    const ui = UI[lang];
     return entries
         .map(({ detection, ruleSet }) => {
         const conventions = ruleSet.conventions.map((c) => `- ${c}`).join("\n");
@@ -8,41 +10,64 @@ function renderSection(entries) {
             "",
             ruleSet.summary,
             "",
-            "### Convenciones",
+            `### ${ui.sections.conventions}`,
             conventions,
             "",
-            "### Arquitectura",
+            `### ${ui.sections.architecture}`,
             architecture,
         ].join("\n");
     })
         .join("\n\n");
 }
-export function renderClaudeMd(entries) {
-    return [
-        "# CLAUDE.md",
-        "",
-        "Generado por agent-rules-init a partir de lo detectado en este repo.",
-        "",
-        renderSection(entries),
-    ].join("\n");
+const SOURCE_FILES = {
+    npm: "package.json",
+    composer: "composer.json",
+    make: "Makefile",
+    mix: "mix.exs",
+    tox: "tox.ini",
+};
+export function renderRepoFacts(facts, lang) {
+    const ui = UI[lang];
+    const sections = [];
+    if (facts.commands.length > 0) {
+        const lines = facts.commands.map((c) => c.detail && c.detail !== c.invocation
+            ? `- \`${c.invocation}\` → \`${c.detail}\` (${SOURCE_FILES[c.source]})`
+            : `- \`${c.invocation}\` (${SOURCE_FILES[c.source]})`);
+        for (const o of facts.omittedCommands)
+            lines.push(`- ${ui.andMore(o.count, SOURCE_FILES[o.source])}`);
+        sections.push([`## ${ui.sections.commands}`, "", ...lines].join("\n"));
+    }
+    if (facts.structure.length > 0) {
+        const lines = facts.structure.map((d) => (d.note ? `- \`${d.dir}\` — ${d.note}` : `- \`${d.dir}\``));
+        sections.push([`## ${ui.sections.structure}`, "", ...lines].join("\n"));
+    }
+    if (facts.ciCommands.length > 0) {
+        const lines = facts.ciCommands.map((c) => `- \`${c.command}\` (${c.workflow})`);
+        if (facts.omittedCiCount > 0)
+            lines.push(`- ${ui.andMore(facts.omittedCiCount)}`);
+        sections.push([`## ${ui.sections.ci}`, "", ...lines].join("\n"));
+    }
+    return sections.join("\n\n");
 }
-export function renderAgentsMd(entries) {
+function renderDocument(title, entries, facts, lang) {
+    const factsBlock = facts ? renderRepoFacts(facts, lang) : "";
     return [
-        "# AGENTS.md",
+        title,
         "",
-        "Generado por agent-rules-init a partir de lo detectado en este repo.",
+        UI[lang].generatedHeader,
         "",
-        renderSection(entries),
+        renderSection(entries, lang),
+        ...(factsBlock ? ["", factsBlock] : []),
     ].join("\n");
 }
-export function renderCopilotInstructions(entries) {
-    return [
-        "# Copilot Instructions",
-        "",
-        "Generado por agent-rules-init a partir de lo detectado en este repo.",
-        "",
-        renderSection(entries),
-    ].join("\n");
+export function renderClaudeMd(entries, facts, lang) {
+    return renderDocument("# CLAUDE.md", entries, facts, lang);
+}
+export function renderAgentsMd(entries, facts, lang) {
+    return renderDocument("# AGENTS.md", entries, facts, lang);
+}
+export function renderCopilotInstructions(entries, facts, lang) {
+    return renderDocument("# Copilot Instructions", entries, facts, lang);
 }
 export function renderPromptFiles(packId, templates) {
     return templates.flatMap((template) => [

package/dist/core/types.d.ts

@@ -1,3 +1,4 @@
+import type { Lang } from "./i18n.js";
 export interface PackageJsonManifest {
     name?: string;
     dependencies: Record<string, string>;
@@ -8,6 +9,7 @@ export interface PackageJsonManifest {
 export interface ComposerJsonManifest {
     require: Record<string, string>;
     requireDev: Record<string, string>;
+    scripts?: Record<string, unknown>;
 }
 export interface RepoSignals {
     rootPath: string;
@@ -33,6 +35,11 @@ export interface RepoSignals {
     buildSbt?: string;
     rDescription?: string;
     renvLock?: string;
+    toxIni?: string;
+    githubWorkflows?: {
+        path: string;
+        content: string;
+    }[];
 }
 export type Confidence = "high" | "low";
 export interface DetectionField<T> {
@@ -59,9 +66,33 @@ export interface PromptTemplate {
     title: string;
     body: string;
 }
+export type CommandSource = "npm" | "composer" | "make" | "mix" | "tox";
+export interface CommandEntry {
+    source: CommandSource;
+    invocation: string;
+    detail?: string;
+}
+export interface DirEntry {
+    dir: string;
+    note?: string;
+}
+export interface CiCommand {
+    command: string;
+    workflow: string;
+}
+export interface RepoFacts {
+    commands: CommandEntry[];
+    omittedCommands: {
+        source: CommandSource;
+        count: number;
+    }[];
+    structure: DirEntry[];
+    ciCommands: CiCommand[];
+    omittedCiCount: number;
+}
 export interface Pack {
     id: string;
     detect(signals: RepoSignals): DetectionResult | null;
-    rules(detection: DetectionResult): RuleSet;
-    promptTemplates(detection: DetectionResult): PromptTemplate[];
+    rules(detection: DetectionResult, lang: Lang): RuleSet;
+    promptTemplates(detection: DetectionResult, lang: Lang): PromptTemplate[];
 }

package/dist/core/writer.d.ts

@@ -4,7 +4,7 @@ export interface GeneratedFile {
 }
 export interface WriteResult {
     path: string;
-    status: "written" | "error";
+    status: "written" | "skipped" | "error";
     error?: string;
 }
 export declare function writeGeneratedFiles(rootPath: string, files: GeneratedFile[]): WriteResult[];

package/dist/core/writer.js

@@ -4,8 +4,10 @@ export function writeGeneratedFiles(rootPath, files) {
     return files.map(({ path: relativePath, content }) => {
         const absolutePath = path.join(rootPath, relativePath);
         try {
+            // An already-existing file is the expected outcome on a re-run (the tool's
+            // no-overwrite guarantee), not a failure — report it as skipped, exit 0.
             if (fs.existsSync(absolutePath)) {
-                return { path: relativePath, status: "error", error: "file already exists" };
+                return { path: relativePath, status: "skipped" };
             }
             fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
             fs.writeFileSync(absolutePath, content);

package/dist/packs/cpp.js

@@ -1,3 +1,4 @@
+import { refactorBody, reviewBody, runTestsConvention, summarySentence, testingBody, unknownFrameworkLabel, unknownRunnerLabel, } 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 : unknownFrameworkLabel(lang);
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner.value : unknownRunnerLabel(lang);
     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, unknownFrameworkLabel, unknownRunnerLabel, } 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 : unknownFrameworkLabel(lang);
+    const runner = detection.testRunner?.value !== "unknown" ? detection.testRunner.value : unknownRunnerLabel(lang);
     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 };