agent-rules-init 0.2.1 → 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

@@ -0,0 +1,47 @@
+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 refactorBody(lang: Lang, extra?: string): string;
+export declare function testingBody(lang: Lang, runner?: string): string;
+export interface UiTexts {
+    generatedHeader: string;
+    sections: {
+        commands: string;
+        structure: string;
+        ci: string;
+        conventions: string;
+        architecture: string;
+        canonical: string;
+    };
+    andMore: (count: number, file?: string) => string;
+    noStackFallback: string;
+    question: (fieldLabel: string, language: string) => string;
+    fieldLabels: {
+        framework: string;
+        testRunner: string;
+        linter: string;
+        packageManager: string;
+    };
+    usage: string;
+    automationUsage: string;
+    unknownOption: (flag: string) => string;
+    invalidLang: (value: string) => string;
+    noTtyWarning: string;
+    skippedQuestion: (message: string) => string;
+    polishDetected: (assistant: string) => string;
+    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

@@ -0,0 +1,207 @@
+export function detectLang() {
+    try {
+        const locale = Intl.DateTimeFormat().resolvedOptions().locale ?? "";
+        return locale.toLowerCase().startsWith("es") ? "es" : "en";
+    }
+    catch {
+        return "en";
+    }
+}
+export function summarySentence(lang, language, framework, parenthetical) {
+    const paren = parenthetical ? ` (${parenthetical})` : "";
+    if (lang === "es")
+        return `Proyecto ${language}${framework ? ` con ${framework}` : ""}${paren}.`;
+    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 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}. 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"
+        ? "Propón refactors que reduzcan duplicación y mejoren la legibilidad sin cambiar comportamiento observable."
+        : "Propose refactors that reduce duplication and improve readability without changing observable behavior.";
+    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 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: {
+        generatedHeader: "Generado por agent-rules-init a partir de lo detectado en este repo.",
+        sections: {
+            commands: "Comandos del repo",
+            structure: "Estructura",
+            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.",
+        question: (fieldLabel, language) => `No se pudo determinar ${fieldLabel} para ${language}. ¿Cuál usáis?`,
+        fieldLabels: {
+            framework: "el framework",
+            testRunner: "el test runner",
+            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:
+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). " +
+            "Continuando sin preguntas ni oferta de pulido con IA; se usarán los valores detectados.",
+        skippedQuestion: (message) => `No se detectó una terminal interactiva; se omite la pregunta "${message}" y se usa el valor detectado.`,
+        polishDetected: (assistant) => `${assistant} detectado — puede ayudar a pulir la redacción final.`,
+        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 — ' +
+            "tu asistente de IA solo lee el nombre final, no el generado.",
+        outroNothing: "No se generó ningún archivo nuevo.",
+        unexpectedError: (message) => `Fallo inesperado: ${message}`,
+        cancelled: "Operación cancelada.",
+        dirNotes: {
+            src: "código fuente",
+            lib: "código fuente",
+            tests: "tests",
+            test: "tests",
+            spec: "tests",
+            __tests__: "tests",
+            docs: "documentación",
+            doc: "documentación",
+            examples: "ejemplos",
+            scripts: "scripts auxiliares",
+            tools: "herramientas auxiliares",
+            migrations: "migraciones de base de datos",
+            benchmarks: "benchmarks",
+            ".github": "workflows y configuración de GitHub",
+            public: "activos públicos",
+            static: "activos estáticos",
+            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.",
+        sections: {
+            commands: "Repo commands",
+            structure: "Structure",
+            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.",
+        question: (fieldLabel, language) => `Couldn't determine ${fieldLabel} for ${language}. Which one do you use?`,
+        fieldLabels: {
+            framework: "the framework",
+            testRunner: "the test runner",
+            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:
+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). " +
+            "Continuing without questions or the AI-polish offer; detected values will be used.",
+        skippedQuestion: (message) => `No interactive terminal detected; skipping the question "${message}" and using the detected value.`,
+        polishDetected: (assistant) => `${assistant} detected — it can help polish the final wording.`,
+        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 — ' +
+            "your AI assistant only reads the final name, not the generated one.",
+        outroNothing: "No new files were generated.",
+        unexpectedError: (message) => `Unexpected failure: ${message}`,
+        cancelled: "Operation cancelled.",
+        dirNotes: {
+            src: "source code",
+            lib: "source code",
+            tests: "tests",
+            test: "tests",
+            spec: "tests",
+            __tests__: "tests",
+            docs: "documentation",
+            doc: "documentation",
+            examples: "examples",
+            scripts: "helper scripts",
+            tools: "helper tooling",
+            migrations: "database migrations",
+            benchmarks: "benchmarks",
+            ".github": "GitHub workflows and configuration",
+            public: "public assets",
+            static: "static assets",
+            assets: "assets",
+            config: "configuration",
+        },
+        testDirNote: "tests",
+        entrypointNote: "entry point",
+    },
+};

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

@@ -1,3 +1,5 @@
+import { type Lang } from "./i18n.js";
+import type { GeneratedFile } from "./writer.js";
 export type AssistantId = "claude" | "codex";
 export interface ExecResult {
     stdout: string;
@@ -6,4 +8,6 @@ export interface 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>;
+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

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { UI } from "./i18n.js";
 const VERSION_ARGS = {
     claude: ["--version"],
     codex: ["--version"],
@@ -34,14 +35,65 @@ 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. Devuelve únicamente el documento pulido, sin comentarios ni explicaciones adicionales:\n\n${content}`;
+export async function polishWithAssistant(assistant, content, execFn = defaultExecFn, lang = "es") {
     try {
-        const result = await execFn(assistant, ["-p"], prompt);
+        const result = await execFn(assistant, ["-p"], UI[lang].polishPrompt(content));
         return result.stdout.trim() || content;
     }
     catch (err) {
-        console.warn(`No se pudo pulir el contenido con ${assistant}, se mantiene el original: ${err.message}`);
+        console.warn(UI[lang].polishFailed(assistant, err.message));
         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/prompt-engine.d.ts

@@ -1,3 +1,4 @@
+import { type Lang } from "./i18n.js";
 import type { DetectionResult } from "./types.js";
 export type QuestionField = "framework" | "testRunner" | "linter" | "packageManager";
 export interface Question {
@@ -5,9 +6,10 @@ export interface Question {
     field: QuestionField;
     message: string;
 }
-export declare function collectLowConfidenceQuestions(detections: DetectionResult[]): Question[];
+export declare function collectLowConfidenceQuestions(detections: DetectionResult[], lang: Lang): Question[];
 export type PromptFn = (message: string) => Promise<string>;
 export declare function hasInteractiveTty(): boolean;
+export declare function makeDefaultPromptFn(lang: Lang): PromptFn;
 export declare const defaultPromptFn: PromptFn;
 export declare function askQuestions(questions: Question[], promptFn?: PromptFn): Promise<Record<string, string>>;
 export declare function applyAnswers(detections: DetectionResult[], answers: Record<string, string>): DetectionResult[];