agent-rules-init 0.3.0 → 0.4.0

package/dist/core/config.js

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse } from "yaml";
+const CONFIG_FILENAMES = [".agent-rules-init.yml", ".agent-rules-init.yaml"];
+const ROOT_KEYS = new Set(["lang", "exclude", "projects", "noAi"]);
+const PROJECT_KEYS = ["framework", "testRunner", "linter", "packageManager"];
+const PROJECT_KEY_SET = new Set(PROJECT_KEYS);
+export class ConfigError extends Error {
+    configPath;
+    constructor(message, configPath, options) {
+        super(message, options);
+        this.name = "ConfigError";
+        this.configPath = configPath;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unknownKeyWarnings(value, allowed, location) {
+    return Object.keys(value)
+        .filter((key) => !allowed.has(key))
+        .map((key) => `Unknown configuration key \"${location}${key}\"; it was ignored.`);
+}
+function optionalNonEmptyString(value, location, warnings) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        warnings.push(`Configuration key \"${location}\" must be a non-empty string; it was ignored.`);
+        return undefined;
+    }
+    return value.trim();
+}
+function validateProjects(value, warnings) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        warnings.push('Configuration key "projects" must be an object keyed by project path; it was ignored.');
+        return undefined;
+    }
+    const projects = {};
+    for (const [projectPath, rawProject] of Object.entries(value)) {
+        if (projectPath.trim().length === 0) {
+            warnings.push("A project path must not be empty; that project was ignored.");
+            continue;
+        }
+        if (!isRecord(rawProject)) {
+            warnings.push(`Configuration key \"projects.${projectPath}\" must be an object; it was ignored.`);
+            continue;
+        }
+        warnings.push(...unknownKeyWarnings(rawProject, PROJECT_KEY_SET, `projects.${projectPath}.`));
+        const project = {};
+        for (const key of PROJECT_KEYS) {
+            const parsed = optionalNonEmptyString(rawProject[key], `projects.${projectPath}.${key}`, warnings);
+            if (parsed !== undefined)
+                project[key] = parsed;
+        }
+        projects[projectPath] = project;
+    }
+    return projects;
+}
+function validateConfig(value, configPath, warnings) {
+    // An empty YAML document is equivalent to an empty configuration.
+    if (value === null || value === undefined)
+        return {};
+    if (!isRecord(value)) {
+        throw new ConfigError(`Invalid configuration in ${configPath}: the YAML root must be an object.`, configPath);
+    }
+    warnings.push(...unknownKeyWarnings(value, ROOT_KEYS, ""));
+    const config = {};
+    if (value.lang !== undefined) {
+        if (value.lang === "es" || value.lang === "en")
+            config.lang = value.lang;
+        else
+            warnings.push('Configuration key "lang" must be "es" or "en"; it was ignored.');
+    }
+    if (value.exclude !== undefined) {
+        if (!Array.isArray(value.exclude)) {
+            warnings.push('Configuration key "exclude" must be an array of strings; it was ignored.');
+        }
+        else {
+            const exclude = value.exclude.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+            if (exclude.length !== value.exclude.length) {
+                warnings.push('Configuration key "exclude" contains non-string or empty entries; they were ignored.');
+            }
+            config.exclude = exclude.map((entry) => entry.trim());
+        }
+    }
+    const projects = validateProjects(value.projects, warnings);
+    if (projects !== undefined)
+        config.projects = projects;
+    if (value.noAi !== undefined) {
+        if (typeof value.noAi === "boolean")
+            config.noAi = value.noAi;
+        else
+            warnings.push('Configuration key "noAi" must be a boolean; it was ignored.');
+    }
+    return config;
+}
+/** Loads and validates the optional repository-local agent-rules configuration. */
+export function loadConfig(rootPath) {
+    const found = CONFIG_FILENAMES.map((filename) => path.resolve(rootPath, filename)).filter((candidate) => fs.existsSync(candidate));
+    if (found.length === 0)
+        return { config: {}, warnings: [] };
+    const sourcePath = found[0];
+    const warnings = [];
+    if (found.length > 1) {
+        warnings.push(`Both ${CONFIG_FILENAMES.join(" and ")} exist; ${path.basename(sourcePath)} takes precedence.`);
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(sourcePath, "utf8");
+    }
+    catch (error) {
+        throw new ConfigError(`Cannot read configuration file ${sourcePath}.`, sourcePath, { cause: error });
+    }
+    let parsed;
+    try {
+        parsed = parse(raw);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? ` ${error.message}` : "";
+        throw new ConfigError(`Invalid YAML in ${sourcePath}.${detail}`, sourcePath, { cause: error });
+    }
+    return { config: validateConfig(parsed, sourcePath, warnings), sourcePath, warnings };
+}

package/dist/core/i18n.d.ts

@@ -1,12 +1,10 @@
 export type Lang = "es" | "en";
 export declare function detectLang(): Lang;
 export declare function summarySentence(lang: Lang, language: string, framework?: string, parenthetical?: string): string;
-export declare function runTestsConvention(lang: Lang, cmd: string): string;
-export declare function reviewBody(lang: Lang, focus: string, framework: string): string;
+export declare function runTestsConvention(lang: Lang, cmd?: string): string;
+export declare function reviewBody(lang: Lang, focus: string, framework?: string): string;
 export declare function refactorBody(lang: Lang, extra?: string): string;
-export declare function testingBody(lang: Lang, runner: string): string;
-export declare function unknownRunnerLabel(lang: Lang): string;
-export declare function unknownFrameworkLabel(lang: Lang): string;
+export declare function testingBody(lang: Lang, runner?: string): string;
 export interface UiTexts {
     generatedHeader: string;
     sections: {
@@ -15,6 +13,7 @@ export interface UiTexts {
         ci: string;
         conventions: string;
         architecture: string;
+        canonical: string;
     };
     andMore: (count: number, file?: string) => string;
     noStackFallback: string;
@@ -26,6 +25,7 @@ export interface UiTexts {
         packageManager: string;
     };
     usage: string;
+    automationUsage: string;
     unknownOption: (flag: string) => string;
     invalidLang: (value: string) => string;
     noTtyWarning: string;
@@ -34,11 +34,14 @@ export interface UiTexts {
     polishConfirm: (assistant: string) => string;
     polishFailed: (assistant: string, error: string) => string;
     polishPrompt: (content: string) => string;
+    polishBatchPrompt: (filesJson: string) => string;
     fileSkipped: (path: string) => string;
     outroWritten: string;
     outroNothing: string;
     unexpectedError: (message: string) => string;
     cancelled: string;
     dirNotes: Record<string, string>;
+    testDirNote: string;
+    entrypointNote: string;
 }
 export declare const UI: Record<Lang, UiTexts>;

package/dist/core/i18n.js

@@ -14,16 +14,26 @@ export function summarySentence(lang, language, framework, parenthetical) {
     return `${language} project${framework ? ` using ${framework}` : ""}${paren}.`;
 }
 export function runTestsConvention(lang, cmd) {
+    if (cmd) {
+        return lang === "es"
+            ? `Ejecuta los tests con ${cmd} antes de terminar una tarea.`
+            : `Run the tests with ${cmd} before finishing a task.`;
+    }
     return lang === "es"
-        ? `Ejecuta los tests con ${cmd} antes de terminar una tarea.`
-        : `Run the tests with ${cmd} before finishing a task.`;
+        ? "Ejecuta la suite de tests del repositorio antes de terminar una tarea."
+        : "Run the repository's test suite before finishing a task.";
 }
 export function reviewBody(lang, focus, framework) {
     // Con focus vacío la frase colapsa a "bugs y desviaciones" sin coma colgante.
     const focusPart = focus ? `, ${focus}` : "";
+    if (framework) {
+        return lang === "es"
+            ? `Revisa el diff actual buscando bugs${focusPart} y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`
+            : `Review the current diff looking for bugs${focusPart} and deviations from ${framework} conventions. Point out only concrete issues with file and line.`;
+    }
     return lang === "es"
-        ? `Revisa el diff actual buscando bugs${focusPart} y desviaciones de las convenciones de ${framework}. Señala solo problemas concretos con línea de archivo.`
-        : `Review the current diff looking for bugs${focusPart} and deviations from ${framework} conventions. Point out only concrete issues with file and line.`;
+        ? `Revisa el diff actual buscando bugs${focusPart}. Señala solo problemas concretos con línea de archivo.`
+        : `Review the current diff looking for bugs${focusPart}. Point out only concrete issues with file and line.`;
 }
 export function refactorBody(lang, extra) {
     const base = lang === "es"
@@ -32,15 +42,14 @@ export function refactorBody(lang, extra) {
     return extra ? `${base} ${extra}` : base;
 }
 export function testingBody(lang, runner) {
+    if (runner) {
+        return lang === "es"
+            ? `Escribe tests con ${runner} para el código señalado. Cubre el camino feliz y al menos un caso límite.`
+            : `Write tests with ${runner} for the highlighted code. Cover the happy path and at least one edge case.`;
+    }
     return lang === "es"
-        ? `Escribe tests con ${runner} para el código señalado. Cubre el camino feliz y al menos un caso límite.`
-        : `Write tests with ${runner} for the highlighted code. Cover the happy path and at least one edge case.`;
-}
-export function unknownRunnerLabel(lang) {
-    return lang === "es" ? "el test runner del proyecto" : "the project's test runner";
-}
-export function unknownFrameworkLabel(lang) {
-    return lang === "es" ? "el framework del proyecto" : "the project's framework";
+        ? "Escribe tests para el código señalado. Cubre el camino feliz y al menos un caso límite."
+        : "Write tests for the highlighted code. Cover the happy path and at least one edge case.";
 }
 export const UI = {
     es: {
@@ -51,6 +60,7 @@ export const UI = {
             ci: "Lo que ejecuta CI (GitHub Actions)",
             conventions: "Convenciones",
             architecture: "Arquitectura",
+            canonical: "Comandos canónicos",
         },
         andMore: (count, file) => (file ? `…y ${count} más en ${file}` : `…y ${count} más`),
         noStackFallback: "No se detectó ningún stack conocido. Completa este archivo manualmente.",
@@ -61,16 +71,21 @@ export const UI = {
             linter: "el linter",
             packageManager: "el gestor de paquetes",
         },
-        usage: `agent-rules-init — genera CLAUDE.md, AGENTS.md, copilot-instructions y prompts de review/refactor/testing a partir del stack detectado en tu repo.
-
-Uso:
-  npx agent-rules-init            escanea el directorio actual y genera los archivos *.generated.*
-  npx agent-rules-init --lang es  fuerza el idioma del contenido (es|en); por defecto se detecta del sistema
-  npx agent-rules-init --help     muestra esta ayuda
-  npx agent-rules-init --version  muestra la versión
-
-Los archivos se crean siempre con sufijo .generated y nunca sobrescriben nada existente:
+        usage: `agent-rules-init — genera CLAUDE.md, AGENTS.md, copilot-instructions y prompts de review/refactor/testing a partir del stack detectado en tu repo.
+
+Uso:
+  npx agent-rules-init            escanea el directorio actual y genera los archivos *.generated.*
+  npx agent-rules-init --lang es  fuerza el idioma del contenido (es|en); por defecto se detecta del sistema
+  npx agent-rules-init --help     muestra esta ayuda
+  npx agent-rules-init --version  muestra la versión
+
+Los archivos se crean siempre con sufijo .generated y nunca sobrescriben nada existente:
 revisa su contenido y quita el sufijo para activarlos.`,
+        automationUsage: `Automatización:
+  --dry-run         renderiza y muestra archivos sin escribir
+  --check           termina con error si faltan archivos generados; nunca escribe
+  --json            emite un único resultado JSON legible por máquinas
+  --non-interactive omite preguntas y el pulido con IA`,
         unknownOption: (flag) => `Opción no reconocida: ${flag}`,
         invalidLang: (value) => `Valor de --lang no válido: "${value}" (usa "es" o "en").`,
         noTtyWarning: "No se detectó una terminal interactiva (esto pasa a veces en Git Bash en Windows). " +
@@ -80,6 +95,9 @@ revisa su contenido y quita el sufijo para activarlos.`,
         polishConfirm: (assistant) => `Se detectó ${assistant}. ¿Quieres que pula la redacción final?`,
         polishFailed: (assistant, error) => `No se pudo pulir el contenido con ${assistant}, se mantiene el original: ${error}`,
         polishPrompt: (content) => `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}`,
+        polishBatchPrompt: (filesJson) => "Pule la redacción de estos archivos de instrucciones sin cambiar su significado, estructura, rutas ni formato Markdown. " +
+            "Devuelve únicamente un array JSON válido con exactamente los mismos objetos path/content y en el mismo orden, sin bloque de código ni comentarios. " +
+            `Entrada JSON:\n${filesJson}`,
         fileSkipped: (path) => `${path}: ya existía, se conserva sin cambios.`,
         outroWritten: "Revisa los archivos *.generated.* y, cuando estés conforme, quita el sufijo " +
             '".generated" (ej. "CLAUDE.generated.md" → "CLAUDE.md") para activarlos — ' +
@@ -107,6 +125,8 @@ revisa su contenido y quita el sufijo para activarlos.`,
             assets: "activos",
             config: "configuración",
         },
+        testDirNote: "tests",
+        entrypointNote: "punto de entrada",
     },
     en: {
         generatedHeader: "Generated by agent-rules-init from what was detected in this repo.",
@@ -116,6 +136,7 @@ revisa su contenido y quita el sufijo para activarlos.`,
             ci: "What CI runs (GitHub Actions)",
             conventions: "Conventions",
             architecture: "Architecture",
+            canonical: "Canonical commands",
         },
         andMore: (count, file) => (file ? `…and ${count} more in ${file}` : `…and ${count} more`),
         noStackFallback: "No known stack was detected. Fill in this file manually.",
@@ -126,16 +147,21 @@ revisa su contenido y quita el sufijo para activarlos.`,
             linter: "the linter",
             packageManager: "the package manager",
         },
-        usage: `agent-rules-init — generates CLAUDE.md, AGENTS.md, copilot-instructions and review/refactor/testing prompts from the stack detected in your repo.
-
-Usage:
-  npx agent-rules-init            scan the current directory and generate the *.generated.* files
-  npx agent-rules-init --lang en  force the content language (es|en); defaults to the system locale
-  npx agent-rules-init --help     show this help
-  npx agent-rules-init --version  show the version
-
-Files are always created with the .generated suffix and never overwrite anything:
+        usage: `agent-rules-init — generates CLAUDE.md, AGENTS.md, copilot-instructions and review/refactor/testing prompts from the stack detected in your repo.
+
+Usage:
+  npx agent-rules-init            scan the current directory and generate the *.generated.* files
+  npx agent-rules-init --lang en  force the content language (es|en); defaults to the system locale
+  npx agent-rules-init --help     show this help
+  npx agent-rules-init --version  show the version
+
+Files are always created with the .generated suffix and never overwrite anything:
 review their content and drop the suffix to activate them.`,
+        automationUsage: `Automation:
+  --dry-run         render and print files without writing
+  --check           exit non-zero if generated files are missing; never write
+  --json            emit a single machine-readable JSON result
+  --non-interactive skip questions and AI polishing`,
         unknownOption: (flag) => `Unknown option: ${flag}`,
         invalidLang: (value) => `Invalid --lang value: "${value}" (use "es" or "en").`,
         noTtyWarning: "No interactive terminal detected (this sometimes happens in Git Bash on Windows). " +
@@ -145,6 +171,9 @@ review their content and drop the suffix to activate them.`,
         polishConfirm: (assistant) => `${assistant} was detected. Do you want it to polish the final wording?`,
         polishFailed: (assistant, error) => `Couldn't polish the content with ${assistant}, keeping the original: ${error}`,
         polishPrompt: (content) => `Polish the wording of the following instructions document for an AI agent, without changing its meaning or structure. Return only the polished document, with no extra comments or explanations:\n\n${content}`,
+        polishBatchPrompt: (filesJson) => "Polish the wording of these instruction files without changing their meaning, structure, paths, or Markdown format. " +
+            "Return only a valid JSON array with exactly the same path/content objects in the same order, without a code fence or commentary. " +
+            `Input JSON:\n${filesJson}`,
         fileSkipped: (path) => `${path}: already existed, left unchanged.`,
         outroWritten: "Review the *.generated.* files and, once you are happy with them, drop the " +
             '".generated" suffix (e.g. "CLAUDE.generated.md" → "CLAUDE.md") to activate them — ' +
@@ -172,5 +201,7 @@ review their content and drop the suffix to activate them.`,
             assets: "assets",
             config: "configuration",
         },
+        testDirNote: "tests",
+        entrypointNote: "entry point",
     },
 };

package/dist/core/llm-bridge.d.ts

@@ -1,4 +1,5 @@
 import { type Lang } from "./i18n.js";
+import type { GeneratedFile } from "./writer.js";
 export type AssistantId = "claude" | "codex";
 export interface ExecResult {
     stdout: string;
@@ -8,3 +9,5 @@ export type ExecFn = (command: string, args: string[], stdin?: string) => Promis
 export declare const defaultExecFn: ExecFn;
 export declare function detectAvailableAssistants(execFn?: ExecFn): Promise<AssistantId[]>;
 export declare function polishWithAssistant(assistant: AssistantId, content: string, execFn?: ExecFn, lang?: Lang): Promise<string>;
+/** Polishes typical runs in one assistant process, splitting only very large outputs. */
+export declare function polishFilesWithAssistant(assistant: AssistantId, files: GeneratedFile[], execFn?: ExecFn, lang?: Lang): Promise<GeneratedFile[]>;

package/dist/core/llm-bridge.js

@@ -45,3 +45,55 @@ export async function polishWithAssistant(assistant, content, execFn = defaultEx
         return content;
     }
 }
+const MAX_POLISH_BATCH_CHARS = 60_000;
+function makeBatches(files) {
+    const batches = [];
+    let current = [];
+    let currentSize = 2;
+    for (const file of files) {
+        const size = JSON.stringify(file).length + 1;
+        if (current.length > 0 && currentSize + size > MAX_POLISH_BATCH_CHARS) {
+            batches.push(current);
+            current = [];
+            currentSize = 2;
+        }
+        current.push(file);
+        currentSize += size;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+function parsePolishedBatch(stdout, originals) {
+    const trimmed = stdout.trim();
+    const withoutFence = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1] ?? trimmed;
+    const parsed = JSON.parse(withoutFence);
+    if (!Array.isArray(parsed) || parsed.length !== originals.length) {
+        throw new Error("assistant returned a different number of files");
+    }
+    return parsed.map((value, index) => {
+        if (!value || typeof value !== "object")
+            throw new Error("assistant returned an invalid file entry");
+        const entry = value;
+        if (entry.path !== originals[index].path || typeof entry.content !== "string") {
+            throw new Error("assistant changed a path or returned invalid content");
+        }
+        return { path: originals[index].path, content: entry.content };
+    });
+}
+/** Polishes typical runs in one assistant process, splitting only very large outputs. */
+export async function polishFilesWithAssistant(assistant, files, execFn = defaultExecFn, lang = "es") {
+    const polished = [];
+    for (const batch of makeBatches(files)) {
+        try {
+            const input = UI[lang].polishBatchPrompt(JSON.stringify(batch));
+            const result = await execFn(assistant, ["-p"], input);
+            polished.push(...parsePolishedBatch(result.stdout, batch));
+        }
+        catch (err) {
+            console.warn(UI[lang].polishFailed(assistant, err.message));
+            polished.push(...batch);
+        }
+    }
+    return polished;
+}

package/dist/core/project-unit-output.d.ts

@@ -0,0 +1,13 @@
+import type { Lang } from "./i18n.js";
+import type { ProjectUnit } from "./project-units.js";
+export interface ProjectOverrides {
+    framework?: string;
+    testRunner?: string;
+    linter?: string;
+    packageManager?: string;
+}
+/** Generates the path-scoped AGENTS file for one JS/TS package. */
+export declare function renderProjectUnitAgents(unit: ProjectUnit, lang: Lang, overrides?: ProjectOverrides): {
+    path: string;
+    content: string;
+} | null;

package/dist/core/project-unit-output.js

@@ -0,0 +1,25 @@
+import { buildRepoFacts } from "./repo-facts.js";
+import { renderAgentsMd } from "./templates.js";
+import { jsTsPack } from "../packs/js-ts.js";
+function applyOverrides(detection, overrides) {
+    const updated = { ...detection };
+    for (const field of ["framework", "testRunner", "linter", "packageManager"]) {
+        const value = overrides[field];
+        if (value)
+            updated[field] = { value, confidence: "high" };
+    }
+    return updated;
+}
+/** Generates the path-scoped AGENTS file for one JS/TS package. */
+export function renderProjectUnitAgents(unit, lang, overrides = {}) {
+    const rawDetection = jsTsPack.detect(unit.signals);
+    if (!rawDetection)
+        return null;
+    const detection = applyOverrides(rawDetection, overrides);
+    const facts = buildRepoFacts(unit.signals, lang);
+    const ruleSet = jsTsPack.rules(detection, lang, { facts, signals: unit.signals });
+    return {
+        path: `${unit.path}/AGENTS.generated.md`,
+        content: renderAgentsMd([{ detection, ruleSet }], facts, lang),
+    };
+}

package/dist/core/project-units.d.ts

@@ -0,0 +1,16 @@
+import type { RepoSignals } from "./types.js";
+export interface ProjectUnit {
+    /** POSIX path relative to the repository root. */
+    path: string;
+    signals: RepoSignals;
+}
+export declare function isProjectExcluded(projectPath: string, patterns: readonly string[]): boolean;
+/** Removes excluded JS packages before repo-wide aggregation and scoped rendering. */
+export declare function applyProjectExcludes(signals: RepoSignals, patterns: readonly string[]): RepoSignals;
+/**
+ * Creates an isolated RepoSignals view for every nested JS/TS package.
+ *
+ * Files and presence checks become relative to the package, so packs can run without
+ * learning workspace-specific rules and cannot accidentally use a sibling's stack.
+ */
+export declare function buildPackageUnits(signals: RepoSignals): ProjectUnit[];

package/dist/core/project-units.js

@@ -0,0 +1,95 @@
+import path from "node:path";
+function normalize(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+}
+function matchesPattern(projectPath, rawPattern) {
+    const value = normalize(projectPath);
+    const pattern = normalize(rawPattern);
+    if (!pattern)
+        return false;
+    if (pattern.endsWith("/**") && value === pattern.slice(0, -3))
+        return true;
+    const marker = "\u0000";
+    const regex = pattern
+        .replace(/\*\*/g, marker)
+        .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, "[^/]*")
+        .replace(new RegExp(marker, "g"), ".*");
+    return new RegExp(`^${regex}$`).test(value);
+}
+export function isProjectExcluded(projectPath, patterns) {
+    return patterns.some((pattern) => matchesPattern(projectPath, pattern));
+}
+/** Removes excluded JS packages before repo-wide aggregation and scoped rendering. */
+export function applyProjectExcludes(signals, patterns) {
+    if (patterns.length === 0 || !signals.packageJsons?.length)
+        return signals;
+    const packageJsons = signals.packageJsons.filter((manifest) => {
+        const packageDir = path.posix.dirname(manifest.path);
+        return packageDir === "." || !isProjectExcluded(packageDir, patterns);
+    });
+    const excludedDirs = (signals.packageJsons ?? [])
+        .map((manifest) => path.posix.dirname(manifest.path))
+        .filter((dir) => dir !== "." && isProjectExcluded(dir, patterns));
+    const isExcludedPath = (relativePath) => {
+        const normalized = normalize(relativePath);
+        return excludedDirs.some((dir) => normalized === dir || normalized.startsWith(`${dir}/`));
+    };
+    const primary = packageJsons[0];
+    const packageJson = primary
+        ? {
+            name: primary.name,
+            main: primary.main,
+            dependencies: Object.assign({}, ...packageJsons.map((manifest) => manifest.dependencies)),
+            devDependencies: Object.assign({}, ...packageJsons.map((manifest) => manifest.devDependencies)),
+            scripts: primary.scripts,
+            moduleType: primary.moduleType,
+            packageManager: primary.packageManager,
+        }
+        : undefined;
+    return {
+        ...signals,
+        files: signals.files.filter((file) => !isExcludedPath(file)),
+        hasFile: (relativePath) => !isExcludedPath(relativePath) && signals.hasFile(relativePath),
+        hasDir: (relativeDir) => !isExcludedPath(relativeDir) && signals.hasDir(relativeDir),
+        packageJson,
+        packageJsons,
+    };
+}
+function withoutLocation(manifest) {
+    const { path: _path, ...packageJson } = manifest;
+    return packageJson;
+}
+/**
+ * Creates an isolated RepoSignals view for every nested JS/TS package.
+ *
+ * Files and presence checks become relative to the package, so packs can run without
+ * learning workspace-specific rules and cannot accidentally use a sibling's stack.
+ */
+export function buildPackageUnits(signals) {
+    return (signals.packageJsons ?? [])
+        .filter((manifest) => manifest.path !== "package.json")
+        .map((manifest) => {
+        const unitPath = path.posix.dirname(manifest.path);
+        const prefix = `${unitPath}/`;
+        const unitFiles = signals.files
+            .map((file) => file.split(path.sep).join("/"))
+            .filter((file) => file.startsWith(prefix))
+            .map((file) => file.slice(prefix.length));
+        const packageJson = withoutLocation(manifest);
+        return {
+            path: unitPath,
+            signals: {
+                rootPath: path.join(signals.rootPath, ...unitPath.split("/")),
+                files: unitFiles,
+                hasFile: (relativePath) => signals.hasFile(`${prefix}${relativePath}`),
+                hasDir: (relativeDir) => signals.hasDir(`${prefix}${relativeDir}`),
+                packageJson,
+                packageJsons: [{ ...packageJson, path: "package.json" }],
+                guidanceFiles: (signals.guidanceFiles ?? [])
+                    .filter((file) => file.path.startsWith(prefix))
+                    .map((file) => ({ ...file, path: file.path.slice(prefix.length) })),
+            },
+        };
+    });
+}

package/dist/core/repo-facts.d.ts

@@ -1,6 +1,8 @@
 import { type Lang } from "./i18n.js";
-import type { CiCommand, CommandEntry, CommandSource, DirEntry, RepoFacts, RepoSignals } from "./types.js";
-export declare function extractNpmCommands(signals: RepoSignals): CommandEntry[];
+import type { CiCommand, ArchitectureFact, CommandEntry, CommandSource, ConventionFact, DirEntry, RepoFacts, RepoSignals } from "./types.js";
+export declare function extractJsPackageCommands(signals: RepoSignals): CommandEntry[];
+/** @deprecated Conservado como alias de API; también devuelve comandos pnpm/Yarn/Bun. */
+export declare const extractNpmCommands: typeof extractJsPackageCommands;
 export declare function extractMakeTargets(signals: RepoSignals): CommandEntry[];
 export declare function extractMixAliases(signals: RepoSignals): CommandEntry[];
 export declare function extractToxEnvs(signals: RepoSignals): CommandEntry[];
@@ -17,4 +19,12 @@ export declare function extractCiCommands(signals: RepoSignals): {
     omittedCount: number;
 };
 export declare function extractStructure(signals: RepoSignals, lang: Lang): DirEntry[];
+export declare function detectTestDirs(files: string[]): string[];
+export declare function detectEntrypoints(signals: RepoSignals): RepoFacts["entrypoints"];
+export declare function extractArchitectureFacts(signals: RepoSignals, lang: Lang, testDirs?: string[], entrypoints?: {
+    label: string;
+    target: string;
+    source: string;
+}[]): ArchitectureFact[];
+export declare function extractConventionFacts(signals: RepoSignals, lang: Lang): ConventionFact[];
 export declare function buildRepoFacts(signals: RepoSignals, lang: Lang): RepoFacts;