agent-rules-init 0.2.0 → 0.2.1

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

@@ -56,8 +56,43 @@ function shallowest(matches) {
 function findFirst(files, fileName) {
     return shallowest(files.filter((f) => path.basename(f) === fileName));
 }
-function findFirstByExtension(files, extension) {
-    return shallowest(files.filter((f) => f.toLowerCase().endsWith(extension)));
+// 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));
@@ -75,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");
@@ -87,9 +123,10 @@ export function scanRepo(rootPath) {
             requireDev: rawComposerJson["require-dev"] ?? {},
         }
         : undefined;
-    const pyprojectCandidate = findFirst(files, "pyproject.toml");
-    const requirementsCandidate = findFirst(files, "requirements.txt");
-    const environmentYmlCandidate = findFirst(files, "environment.yml") ?? findFirst(files, "environment.yaml");
+    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.
@@ -101,14 +138,24 @@ export function scanRepo(rootPath) {
     const pyprojectPath = primaryPythonManifest === pyprojectCandidate ? pyprojectCandidate : undefined;
     const requirementsPath = primaryPythonManifest === requirementsCandidate ? requirementsCandidate : undefined;
     const environmentYmlPath = primaryPythonManifest === environmentYmlCandidate ? environmentYmlCandidate : undefined;
-    const pomPath = findFirst(files, "pom.xml");
-    const buildGradlePath = findFirst(files, "build.gradle") ?? findFirst(files, "build.gradle.kts");
+    // 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");
-    const csprojPath = findFirstByExtension(files, ".csproj");
+    // .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");
-    const pubspecYamlPath = findFirst(files, "pubspec.yaml");
+    // 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");
@@ -129,15 +176,15 @@ export function scanRepo(rootPath) {
         environmentYml: environmentYmlPath
             ? readTextIfExists(path.join(rootPath, environmentYmlPath))
             : undefined,
-        pomXml: pomPath ? readTextIfExists(path.join(rootPath, pomPath)) : undefined,
-        buildGradle: buildGradlePath ? readTextIfExists(path.join(rootPath, buildGradlePath)) : 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: csprojPath ? readTextIfExists(path.join(rootPath, csprojPath)) : undefined,
+        csproj: readAllConcatenated(rootPath, csprojPaths),
         packageSwift: packageSwiftPath ? readTextIfExists(path.join(rootPath, packageSwiftPath)) : undefined,
-        pubspecYaml: pubspecYamlPath ? readTextIfExists(path.join(rootPath, pubspecYamlPath)) : 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,

package/dist/core/types.d.ts

@@ -3,6 +3,7 @@ export interface PackageJsonManifest {
     dependencies: Record<string, string>;
     devDependencies: Record<string, string>;
     scripts: Record<string, string>;
+    moduleType: "module" | "commonjs";
 }
 export interface ComposerJsonManifest {
     require: Record<string, string>;
@@ -45,6 +46,8 @@ export interface DetectionResult {
     packageManager?: DetectionField<string>;
     testRunner?: DetectionField<string>;
     linter?: DetectionField<string>;
+    usesTypeScript?: boolean;
+    moduleFormat?: "module" | "commonjs";
 }
 export interface RuleSet {
     summary: string;

package/dist/packs/cpp.js

@@ -8,8 +8,22 @@ const TEST_RUNNERS = [
     ["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) {
-    const source = signals.cmakeLists ?? signals.makefile;
+    // 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();

package/dist/packs/elixir.js

@@ -3,7 +3,11 @@ function detect(signals) {
     if (!source)
         return null;
     const lower = source.toLowerCase();
-    const framework = lower.includes(":phoenix")
+    // 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 {

package/dist/packs/go.js

@@ -4,11 +4,23 @@ const FRAMEWORKS = [
     ["gofiber/fiber", "fiber"],
     ["go-chi/chi", "chi"],
 ];
+// The `module` line of go.mod is the project's own import path, not a dependency —
+// searching the whole file would false-positive on a framework whose own repo module
+// path happens to match a known framework name (e.g. gofiber/fiber's own go.mod
+// declares `module github.com/gofiber/fiber/v3`). Scope the search to `require` entries.
+function extractGoRequireSection(goMod) {
+    const sections = [];
+    for (const m of goMod.matchAll(/require\s*\(([\s\S]*?)\)/g))
+        sections.push(m[1]);
+    for (const m of goMod.matchAll(/^require\s+(?!\()(.+)$/gm))
+        sections.push(m[1]);
+    return sections.length > 0 ? sections.join("\n") : goMod;
+}
 function detect(signals) {
     const source = signals.goMod;
     if (!source)
         return null;
-    const lower = source.toLowerCase();
+    const lower = extractGoRequireSection(source).toLowerCase();
     let framework = { value: "none", confidence: "low" };
     for (const [needle, label] of FRAMEWORKS) {
         if (lower.includes(needle)) {

package/dist/packs/java.js

@@ -4,7 +4,11 @@ function detect(signals) {
         return null;
     // A Gradle build that applies the Kotlin plugin is a Kotlin project, not Java —
     // defer entirely to the Kotlin pack instead of also reporting a spurious Java match.
-    if (/kotlin\(|org\.jetbrains\.kotlin/i.test(source))
+    // Modern Gradle projects often declare plugins via version catalogs
+    // (`alias(libs.plugins.kotlin.android)`) rather than the literal `kotlin("jvm")` or
+    // `org.jetbrains.kotlin` plugin id, so a plain word-boundary check on "kotlin" is
+    // more robust than trying to match every DSL style.
+    if (/\bkotlin\b/i.test(source))
         return null;
     const framework = /spring/i.test(source)
         ? { value: "spring", confidence: "high" }

package/dist/packs/js-ts.js

@@ -45,18 +45,33 @@ function detect(signals) {
             : signals.hasFile("package-lock.json")
                 ? { value: "npm", confidence: "high" }
                 : { value: "npm", confidence: "low" };
-    return { packId: "js-ts", language: "TypeScript/JavaScript", framework, testRunner, linter, packageManager };
+    const usesTypeScript = Boolean(allDeps.typescript) || signals.hasFile("tsconfig.json");
+    const moduleFormat = signals.packageJson.moduleType;
+    return {
+        packId: "js-ts",
+        language: usesTypeScript ? "TypeScript" : "JavaScript",
+        framework,
+        testRunner,
+        linter,
+        packageManager,
+        usesTypeScript,
+        moduleFormat,
+    };
 }
 function rules(detection) {
     const framework = detection.framework?.value ?? "none";
     const testRunner = detection.testRunner?.value ?? "unknown";
+    const conventions = [];
+    if (detection.usesTypeScript) {
+        conventions.push("Usa TypeScript estricto; evita `any` salvo justificación explícita.");
+    }
+    conventions.push(`Ejecuta los tests con ${testRunner === "unknown" ? "el test runner del proyecto" : testRunner} antes de dar por terminada una tarea.`);
+    conventions.push(detection.moduleFormat === "module"
+        ? "Sigue el estilo de módulos ES existente (import/export), no mezcles con require()."
+        : "Sigue el estilo CommonJS existente (require()/module.exports), no mezcles con import/export.");
     return {
-        summary: `Proyecto 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().",
-        ],
+        summary: `Proyecto ${detection.usesTypeScript ? "TypeScript" : "JavaScript"}${framework !== "none" ? ` con ${framework}` : ""}.`,
+        conventions,
         architectureNotes: [
             "Mantén los componentes/módulos pequeños y con una responsabilidad clara.",
             "Coloca los tests junto al código que prueban o en un directorio `test/` espejo, según lo que ya use el repo.",

package/dist/packs/kotlin.js

@@ -2,7 +2,10 @@ function detect(signals) {
     const source = signals.buildGradle;
     if (!source)
         return null;
-    if (!/kotlin\(|org\.jetbrains\.kotlin/i.test(source))
+    // 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" }

package/dist/packs/python.js

@@ -15,12 +15,32 @@ function findIn(haystack, table) {
     }
     return undefined;
 }
+// Searching the whole pyproject.toml text (project name, URLs, script entry points, etc.)
+// produces false positives — e.g. Flask's own pyproject.toml has `name = "flask"`, which
+// isn't a dependency at all. Scope the search to the actual dependency declarations.
+function extractPyprojectDependencySections(pyproject) {
+    const sections = [];
+    const mainDeps = pyproject.match(/(?:^|\n)dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (mainDeps)
+        sections.push(mainDeps[1]);
+    const optionalDeps = pyproject.match(/\[project\.optional-dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (optionalDeps)
+        sections.push(optionalDeps[1]);
+    const dependencyGroups = pyproject.match(/\[dependency-groups\]([\s\S]*?)(?:\n\[|$)/);
+    if (dependencyGroups)
+        sections.push(dependencyGroups[1]);
+    const poetryDepsBlocks = pyproject.match(/\[tool\.poetry(?:\.group\.\w+)?\.dependencies\]([\s\S]*?)(?:\n\[|$)/g);
+    if (poetryDepsBlocks)
+        sections.push(...poetryDepsBlocks);
+    return sections.length > 0 ? sections.join("\n") : pyproject;
+}
 function detect(signals) {
     const source = signals.pyprojectToml ?? signals.requirementsTxt ?? signals.environmentYml;
     if (!source)
         return null;
-    const framework = findIn(source, FRAMEWORKS) ?? { value: "none", confidence: "low" };
-    const testRunner = findIn(source, TEST_RUNNERS) ?? { value: "unknown", confidence: "low" };
+    const searchText = signals.pyprojectToml ? extractPyprojectDependencySections(signals.pyprojectToml) : source;
+    const framework = findIn(searchText, FRAMEWORKS) ?? { value: "none", confidence: "low" };
+    const testRunner = findIn(searchText, TEST_RUNNERS) ?? { value: "unknown", confidence: "low" };
     const packageManager = signals.environmentYml
         ? { value: "conda", confidence: "high" }
         : signals.hasFile("poetry.lock")

package/dist/packs/scala.js

@@ -2,10 +2,12 @@ const FRAMEWORKS = [
     ["playframework", "play"],
     ["akka-http", "akka"],
     ["akka.actor", "akka"],
+    ["scalatra", "scalatra"],
 ];
 const TEST_RUNNERS = [
     ["scalatest", "scalatest"],
     ["munit", "munit"],
+    ["specs2", "specs2"],
 ];
 function detect(signals) {
     const source = signals.buildSbt;

package/dist/packs/swift.js

@@ -2,6 +2,12 @@ function detect(signals) {
     const source = signals.packageSwift;
     if (!source)
         return null;
+    // A Package.swift alone doesn't guarantee a Swift project: some C/C++ libraries (e.g.
+    // nlohmann/json) ship one purely so Swift Package Manager users can link the library,
+    // with zero actual Swift source. Require at least one other .swift file to be present.
+    const hasSwiftSource = signals.files.some((f) => f.toLowerCase().endsWith(".swift") && !f.endsWith("Package.swift"));
+    if (!hasSwiftSource)
+        return null;
     const lower = source.toLowerCase();
     const framework = lower.includes("vapor")
         ? { value: "vapor", confidence: "high" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-rules-init",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Generates CLAUDE.md, AGENTS.md, copilot-instructions.md and prompt files from what your repo actually is.",
   "license": "MIT",
   "type": "module",