agent-rules-init 0.1.3 → 0.2.1

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/llm-bridge.d.ts

@@ -3,7 +3,7 @@ export interface ExecResult {
     stdout: string;
     exitCode: number;
 }
-export type ExecFn = (command: string, args: string[]) => Promise<ExecResult>;
+export type ExecFn = (command: string, args: string[], stdin?: string) => Promise<ExecResult>;
 export declare const defaultExecFn: ExecFn;
 export declare function detectAvailableAssistants(execFn?: ExecFn): Promise<AssistantId[]>;
 export declare function polishWithAssistant(assistant: AssistantId, content: string, execFn?: ExecFn): Promise<string>;

package/dist/core/llm-bridge.js

@@ -3,11 +3,8 @@ const VERSION_ARGS = {
     claude: ["--version"],
     codex: ["--version"],
 };
-export const defaultExecFn = (command, args) => new Promise((resolve, reject) => {
+export const defaultExecFn = (command, args, stdin) => new Promise((resolve, reject) => {
     // shell:true is only needed on Windows, to resolve npm-installed .cmd/.ps1 shims.
-    // On POSIX, spawn(command, args) execs the binary directly with argv, so passing
-    // large generated content as an argument (see polishWithAssistant) can never be
-    // reinterpreted by a shell there.
     const child = spawn(command, args, { shell: process.platform === "win32" });
     let stdout = "";
     child.stdout?.on("data", (chunk) => (stdout += chunk.toString()));
@@ -18,6 +15,11 @@ export const defaultExecFn = (command, args) => new Promise((resolve, reject) =>
         else
             reject(new Error(`${command} exited with code ${exitCode}`));
     });
+    // Content always goes through stdin, never as a CLI argument: on Windows, spawn's
+    // shell:true routes the command through cmd.exe, which cannot reliably carry a
+    // multi-line, multi-KB argument (embedded newlines truncate/corrupt it). Piping
+    // via stdin has no such limit and needs no shell-quoting at all.
+    child.stdin?.end(stdin ?? "");
 });
 export async function detectAvailableAssistants(execFn = defaultExecFn) {
     const candidates = ["claude", "codex"];
@@ -33,9 +35,9 @@ export async function detectAvailableAssistants(execFn = defaultExecFn) {
     return results.filter((id) => id !== null);
 }
 export async function polishWithAssistant(assistant, content, execFn = defaultExecFn) {
-    const prompt = `Pule la redacción del siguiente documento de instrucciones para un agente de IA, sin cambiar su significado ni estructura:\n\n${content}`;
+    const prompt = `Pule la redacción del siguiente documento de instrucciones para un agente de IA, sin cambiar su significado ni estructura. Devuelve únicamente el documento pulido, sin comentarios ni explicaciones adicionales:\n\n${content}`;
     try {
-        const result = await execFn(assistant, ["-p", prompt]);
+        const result = await execFn(assistant, ["-p"], prompt);
         return result.stdout.trim() || content;
     }
     catch (err) {

package/dist/core/scanner.js

@@ -48,11 +48,54 @@ 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));
+}
+// Directories that routinely carry their own throwaway Python tooling manifest (a
+// mkdocs/sphinx docs build, a one-off script, a benchmark harness) in projects whose
+// primary language is something else entirely (e.g. nlohmann/json, a C++ library, ships
+// docs/mkdocs/requirements.txt). Prefer a candidate outside these dirs when one exists.
+const NON_PROJECT_DIRS = new Set([
+    "docs",
+    "doc",
+    "tools",
+    "tool",
+    "scripts",
+    "script",
+    "examples",
+    "example",
+    "benchmark",
+    "benchmarks",
+]);
+function isUnderNonProjectDir(relativePath) {
+    const segments = relativePath.split(path.sep).slice(0, -1);
+    return segments.some((segment) => NON_PROJECT_DIRS.has(segment.toLowerCase()));
+}
+function findFirstPreferringRealProjectDirs(files, fileName) {
+    const matches = files.filter((f) => path.basename(f) === fileName && !isUnderNonProjectDir(f));
+    return shallowest(matches);
+}
+function findAllByExtension(files, extension) {
+    return files.filter((f) => f.toLowerCase().endsWith(extension));
+}
+function findAllByNames(files, names) {
+    return files.filter((f) => names.includes(path.basename(f)));
+}
+function readAllConcatenated(rootPath, relativePaths) {
+    if (relativePaths.length === 0)
+        return undefined;
+    const contents = relativePaths
+        .map((p) => readTextIfExists(path.join(rootPath, p)))
+        .filter((content) => content !== undefined);
+    return contents.length > 0 ? contents.join("\n") : undefined;
+}
+function pickShallowest(paths) {
+    return shallowest(paths.filter((p) => p !== undefined));
 }
 export function scanRepo(rootPath) {
     const files = walk(rootPath);
@@ -67,6 +110,7 @@ export function scanRepo(rootPath) {
             dependencies: rawPackageJson.dependencies ?? {},
             devDependencies: rawPackageJson.devDependencies ?? {},
             scripts: rawPackageJson.scripts ?? {},
+            moduleType: rawPackageJson.type === "module" ? "module" : "commonjs",
         }
         : undefined;
     const composerJsonPath = findFirst(files, "composer.json");
@@ -79,10 +123,45 @@ export function scanRepo(rootPath) {
             requireDev: rawComposerJson["require-dev"] ?? {},
         }
         : undefined;
-    const pyprojectPath = findFirst(files, "pyproject.toml");
-    const requirementsPath = findFirst(files, "requirements.txt");
-    const pomPath = findFirst(files, "pom.xml");
-    const buildGradlePath = findFirst(files, "build.gradle") ?? findFirst(files, "build.gradle.kts");
+    const pyprojectCandidate = findFirstPreferringRealProjectDirs(files, "pyproject.toml");
+    const requirementsCandidate = findFirstPreferringRealProjectDirs(files, "requirements.txt");
+    const environmentYmlCandidate = findFirstPreferringRealProjectDirs(files, "environment.yml") ??
+        findFirstPreferringRealProjectDirs(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;
+    // Multi-module Maven/Gradle projects (parent + child modules) each have their own
+    // pom.xml/build.gradle, and the module that actually declares the framework/Kotlin
+    // plugin/test runner isn't necessarily the shallowest one. Aggregate all of them.
+    const pomPaths = findAllByNames(files, ["pom.xml"]);
+    const buildGradlePaths = findAllByNames(files, ["build.gradle", "build.gradle.kts"]);
+    const gemfilePath = findFirst(files, "Gemfile");
+    const goModPath = findFirst(files, "go.mod");
+    const cargoTomlPath = findFirst(files, "Cargo.toml");
+    // .NET solutions routinely split into several .csproj files (domain/infra/web/tests);
+    // picking just the "shallowest" one is close to arbitrary and often lands on a plain
+    // class library that has neither the web framework nor the test runner reference.
+    // Concatenate all of them so detection can find those references wherever they live.
+    const csprojPaths = findAllByExtension(files, ".csproj");
+    const packageSwiftPath = findFirst(files, "Package.swift");
+    // Melos/pub workspaces have a root pubspec.yaml that's just workspace glue (no
+    // `flutter`/`flutter_test` dependency) plus one real pubspec.yaml per package under
+    // 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");
+    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 +173,23 @@ export function scanRepo(rootPath) {
         requirementsTxt: requirementsPath
             ? readTextIfExists(path.join(rootPath, requirementsPath))
             : undefined,
-        pomXml: pomPath ? readTextIfExists(path.join(rootPath, pomPath)) : undefined,
-        buildGradle: buildGradlePath ? readTextIfExists(path.join(rootPath, buildGradlePath)) : undefined,
+        environmentYml: environmentYmlPath
+            ? readTextIfExists(path.join(rootPath, environmentYmlPath))
+            : undefined,
+        pomXml: readAllConcatenated(rootPath, pomPaths),
+        buildGradle: readAllConcatenated(rootPath, buildGradlePaths),
         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: readAllConcatenated(rootPath, csprojPaths),
+        packageSwift: packageSwiftPath ? readTextIfExists(path.join(rootPath, packageSwiftPath)) : undefined,
+        pubspecYaml: readAllConcatenated(rootPath, pubspecYamlPaths),
+        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,67 @@
-export * from "agent-rules-pack-types";
+export interface PackageJsonManifest {
+    name?: string;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    moduleType: "module" | "commonjs";
+}
+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>;
+    usesTypeScript?: boolean;
+    moduleFormat?: "module" | "commonjs";
+}
+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,84 @@
+const FRAMEWORKS = [
+    ["find_package(qt", "qt"],
+    ["find_package(boost", "boost"],
+    ["find_package(sdl2", "sdl2"],
+];
+const TEST_RUNNERS = [
+    ["gtest", "gtest"],
+    ["catch2", "catch2"],
+    ["doctest", "doctest"],
+];
+const CPP_COMPILER_TOKENS = ["$(cc)", "$(cxx)", "gcc", "g++", "clang"];
+// Source-file extensions need a stricter boundary check than a plain substring:
+// Go module paths hosted on the ".cc" ccTLD (e.g. "mvdan.cc/gofumpt") also contain
+// ".cc", but it's followed by "/", never by whitespace/quote/paren/end-of-line the
+// way a real compiled source file reference in a Makefile would be.
+const CPP_SOURCE_EXTENSION = /\.(cpp|cxx|cc)(?=[\s:"')]|$)/im;
+function looksLikeCppMakefile(makefile) {
+    const lower = makefile.toLowerCase();
+    return CPP_COMPILER_TOKENS.some((needle) => lower.includes(needle)) || CPP_SOURCE_EXTENSION.test(makefile) || /\.o:/.test(makefile);
+}
+function detect(signals) {
+    // A bare Makefile isn't C/C++-specific — plenty of Python/JS/etc. projects ship
+    // one as a generic task runner (or a Sphinx docs Makefile, like Flask's docs/Makefile).
+    // Only trust it once it actually references a C/C++ compiler or source file.
+    const makefileSource = signals.makefile && looksLikeCppMakefile(signals.makefile) ? signals.makefile : undefined;
+    const source = signals.cmakeLists ?? makefileSource;
+    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,56 @@
+function detect(signals) {
+    const source = signals.mixExs;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    // A plain `.includes(":phoenix")` also matches sibling hex packages like `:phoenix_pubsub`
+    // or `:phoenix_html` (substring prefix), and Phoenix's own mix.exs (`app: :phoenix`) —
+    // neither means the project actually depends on the `phoenix` package. Match the
+    // `{:phoenix, ...}` dependency-tuple syntax instead, which only the real dependency uses.
+    const framework = /\{\s*:phoenix\s*,/.test(lower)
+        ? { 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;