agent-rules-init 0.1.3 → 0.2.0

package/dist/packs/js-ts.js

@@ -0,0 +1,86 @@
+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" };
+    return { packId: "js-ts", language: "TypeScript/JavaScript", framework, testRunner, linter, packageManager };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    const testRunner = detection.testRunner?.value ?? "unknown";
+    return {
+        summary: `Proyecto JavaScript/TypeScript${framework !== "none" ? ` con ${framework}` : ""}.`,
+        conventions: [
+            "Usa TypeScript estricto; evita `any` salvo justificación explícita.",
+            `Ejecuta los tests con ${testRunner === "unknown" ? "el test runner del proyecto" : testRunner} antes de dar por terminada una tarea.`,
+            "Sigue el estilo de módulos ES existente (import/export), no mezcles con require().",
+        ],
+        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,62 @@
+function detect(signals) {
+    const source = signals.buildGradle;
+    if (!source)
+        return null;
+    if (!/kotlin\(|org\.jetbrains\.kotlin/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,68 @@
+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;
+}
+function detect(signals) {
+    const source = signals.pyprojectToml ?? signals.requirementsTxt ?? signals.environmentYml;
+    if (!source)
+        return null;
+    const framework = findIn(source, FRAMEWORKS) ?? { value: "none", confidence: "low" };
+    const testRunner = findIn(source, 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;

package/dist/packs/rust.js

@@ -0,0 +1,61 @@
+const FRAMEWORKS = [
+    ["actix-web", "actix-web"],
+    ["axum", "axum"],
+    ["rocket", "rocket"],
+];
+function detect(signals) {
+    const source = signals.cargoToml;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    let framework = { value: "none", confidence: "low" };
+    for (const [needle, label] of FRAMEWORKS) {
+        if (lower.includes(needle)) {
+            framework = { value: label, confidence: "high" };
+            break;
+        }
+    }
+    return {
+        packId: "rust",
+        language: "Rust",
+        framework,
+        testRunner: { value: "cargo test", confidence: "high" },
+        packageManager: { value: "cargo", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Rust${framework !== "none" ? ` con ${framework}` : ""} (cargo).`,
+        conventions: [
+            "Sigue el formato estándar de `rustfmt`; corre `cargo clippy` para detectar problemas idiomáticos.",
+            "Ejecuta los tests con `cargo test` antes de terminar una tarea.",
+            "Evita `unwrap()`/`expect()` en código de producción salvo que la invariante esté justificada.",
+        ],
+        architectureNotes: [
+            "Mantén los módulos con una responsabilidad clara; usa `mod.rs` o archivos de módulo con nombre explícito según lo que ya use el repo.",
+            "Declara toda dependencia nueva en Cargo.toml y mantén Cargo.lock sincronizado.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (Rust)",
+            body: `Revisa el diff actual buscando bugs, usos innecesarios de \`unwrap()\`/\`clone()\` y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (Rust)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable. Respeta el sistema de ownership existente.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Rust)",
+            body: `Escribe tests con \`cargo test\` para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
+        },
+    ];
+}
+export const rustPack = { id: "rust", detect, rules, promptTemplates };

package/dist/packs/scala.d.ts

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

package/dist/packs/scala.js

@@ -0,0 +1,72 @@
+const FRAMEWORKS = [
+    ["playframework", "play"],
+    ["akka-http", "akka"],
+    ["akka.actor", "akka"],
+];
+const TEST_RUNNERS = [
+    ["scalatest", "scalatest"],
+    ["munit", "munit"],
+];
+function detect(signals) {
+    const source = signals.buildSbt;
+    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;
+        }
+    }
+    return {
+        packId: "scala",
+        language: "Scala",
+        framework,
+        testRunner,
+        packageManager: { value: "sbt", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Scala${framework !== "none" ? ` con ${framework}` : ""} (sbt).`,
+        conventions: [
+            "Sigue la guía de estilo oficial de Scala; ejecuta `scalafmt` si el proyecto ya lo usa.",
+            `Ejecuta los tests con \`sbt test\` antes de terminar una tarea.`,
+            "Prefiere estructuras inmutables y funciones puras cuando el proyecto ya siga ese estilo.",
+        ],
+        architectureNotes: [
+            "Mantén los módulos con una responsabilidad clara; usa `case class` para modelos de datos.",
+            "Declara toda dependencia nueva en `build.sbt`.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (Scala)",
+            body: `Revisa el diff actual buscando bugs, usos innecesarios de mutabilidad y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (Scala)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Scala)",
+            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 scalaPack = { id: "scala", detect, rules, promptTemplates };

package/dist/packs/swift.d.ts

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

package/dist/packs/swift.js

@@ -0,0 +1,52 @@
+function detect(signals) {
+    const source = signals.packageSwift;
+    if (!source)
+        return null;
+    const lower = source.toLowerCase();
+    const framework = lower.includes("vapor")
+        ? { value: "vapor", confidence: "high" }
+        : { value: "none", confidence: "low" };
+    return {
+        packId: "swift",
+        language: "Swift",
+        framework,
+        testRunner: { value: "swift test", confidence: "high" },
+        packageManager: { value: "swift package manager", confidence: "high" },
+    };
+}
+function rules(detection) {
+    const framework = detection.framework?.value ?? "none";
+    return {
+        summary: `Proyecto Swift${framework !== "none" ? ` con ${framework}` : ""} (Swift Package Manager).`,
+        conventions: [
+            "Sigue la guía de estilo de la API de Swift (swift.org/documentation/api-design-guidelines).",
+            "Ejecuta los tests con `swift test` antes de terminar una tarea.",
+            "Declara toda dependencia nueva en Package.swift, nunca la añadas solo en Xcode.",
+        ],
+        architectureNotes: [
+            "Prefiere `struct` sobre `class` salvo que se necesite semántica de referencia.",
+            "Evita forzar el desenvuelto de opcionales (`!`) fuera de contextos donde la invariante esté garantizada.",
+        ],
+    };
+}
+function promptTemplates(detection) {
+    const framework = detection.framework?.value ?? "el framework del proyecto";
+    return [
+        {
+            id: "review",
+            title: "Code Review (Swift)",
+            body: `Revisa el diff actual buscando bugs, desenvueltos forzados de opcionales y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`,
+        },
+        {
+            id: "refactor",
+            title: "Refactor (Swift)",
+            body: `Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable.`,
+        },
+        {
+            id: "testing",
+            title: "Testing (Swift)",
+            body: `Escribe tests con \`swift test\` para el código señalado. Cubre el camino feliz y al menos un caso límite.`,
+        },
+    ];
+}
+export const swiftPack = { id: "swift", detect, rules, promptTemplates };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "agent-rules-init",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Generates CLAUDE.md, AGENTS.md, copilot-instructions.md and prompt files from what your repo actually is.",
   "license": "MIT",
   "type": "module",
   "main": "dist/cli.js",
   "types": "dist/cli.d.ts",
   "bin": {
-    "agent-rules-init": "dist/cli.js"
+    "agent-rules-init": "dist/bin.js"
   },
   "files": [
     "dist"
@@ -39,12 +39,7 @@
     "lint": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@clack/prompts": "^0.9.1",
-    "agent-rules-pack-java": "0.1.1",
-    "agent-rules-pack-js-ts": "0.1.1",
-    "agent-rules-pack-php": "0.1.1",
-    "agent-rules-pack-python": "0.1.1",
-    "agent-rules-pack-types": "0.1.1"
+    "@clack/prompts": "^0.9.1"
   },
   "devDependencies": {
     "typescript": "^5.6.0",

package/dist/core/greeting.d.ts

@@ -1 +0,0 @@
-export declare function renderAssistantGreeting(assistantName: string): string;