agent-rules-init 0.2.1 → 0.3.0

package/dist/cli.d.ts

@@ -1,10 +1,28 @@
 import { type WriteResult } from "./core/writer.js";
+import { type Lang } from "./core/i18n.js";
 import { type PromptFn } from "./core/prompt-engine.js";
 import { type ExecFn } from "./core/llm-bridge.js";
 export interface RunCliOptions {
     promptFn?: PromptFn;
     execFn?: ExecFn;
     skipLlm?: boolean;
+    lang?: Lang;
 }
 export declare function runCli(rootPath: string, options?: RunCliOptions): Promise<WriteResult[]>;
+export type CliAction = {
+    kind: "run";
+    lang?: Lang;
+} | {
+    kind: "help";
+} | {
+    kind: "version";
+} | {
+    kind: "invalid-lang";
+    value: string;
+} | {
+    kind: "unknown";
+    flag: string;
+};
+export declare function resolveCliAction(argv: string[]): CliAction;
+export declare function getVersion(): string;
 export declare function main(): Promise<void>;

package/dist/cli.js

@@ -1,8 +1,11 @@
+import { createRequire } from "node:module";
 import * as clack from "@clack/prompts";
 import { scanRepo } from "./core/scanner.js";
 import { writeGeneratedFiles } from "./core/writer.js";
-import { renderClaudeMd, renderAgentsMd, renderCopilotInstructions, renderPromptFiles, } from "./core/templates.js";
-import { collectLowConfidenceQuestions, askQuestions, applyAnswers, defaultPromptFn, hasInteractiveTty, } from "./core/prompt-engine.js";
+import { renderClaudeMd, renderAgentsMd, renderCopilotInstructions, renderPromptFiles, renderRepoFacts, } from "./core/templates.js";
+import { buildRepoFacts } from "./core/repo-facts.js";
+import { UI, detectLang } from "./core/i18n.js";
+import { collectLowConfidenceQuestions, askQuestions, applyAnswers, makeDefaultPromptFn, hasInteractiveTty, } from "./core/prompt-engine.js";
 import { detectAvailableAssistants, polishWithAssistant, defaultExecFn } from "./core/llm-bridge.js";
 import { jsTsPack } from "./packs/js-ts.js";
 import { pythonPack } from "./packs/python.js";
@@ -37,87 +40,138 @@ const ALL_PACKS = [
     rPack,
 ];
 export async function runCli(rootPath, options = {}) {
-    const promptFn = options.promptFn ?? defaultPromptFn;
     const execFn = options.execFn ?? defaultExecFn;
+    const lang = options.lang ?? detectLang();
+    const promptFn = options.promptFn ?? makeDefaultPromptFn(lang);
+    const ui = UI[lang];
     const signals = scanRepo(rootPath);
     const rawDetections = ALL_PACKS.map((pack) => pack.detect(signals)).filter((d) => d !== null);
-    const questions = collectLowConfidenceQuestions(rawDetections);
+    const questions = collectLowConfidenceQuestions(rawDetections, lang);
     const answers = await askQuestions(questions, promptFn);
     const detections = applyAnswers(rawDetections, answers);
+    const facts = buildRepoFacts(signals, lang);
     const entries = detections.map((detection) => {
         const pack = ALL_PACKS.find((p) => p.id === detection.packId);
-        return { detection, ruleSet: pack.rules(detection) };
+        return { detection, ruleSet: pack.rules(detection, lang) };
     });
     const files = [];
     if (entries.length > 0) {
-        files.push({ path: "CLAUDE.generated.md", content: renderClaudeMd(entries) });
-        files.push({ path: "AGENTS.generated.md", content: renderAgentsMd(entries) });
+        files.push({ path: "CLAUDE.generated.md", content: renderClaudeMd(entries, facts, lang) });
+        files.push({ path: "AGENTS.generated.md", content: renderAgentsMd(entries, facts, lang) });
         files.push({
             path: ".github/copilot-instructions.generated.md",
-            content: renderCopilotInstructions(entries),
+            content: renderCopilotInstructions(entries, facts, lang),
         });
         for (const detection of detections) {
             const pack = ALL_PACKS.find((p) => p.id === detection.packId);
-            for (const file of renderPromptFiles(detection.packId, pack.promptTemplates(detection))) {
+            for (const file of renderPromptFiles(detection.packId, pack.promptTemplates(detection, lang))) {
                 files.push(file);
             }
         }
     }
     else {
+        const factsBlock = renderRepoFacts(facts, lang);
         files.push({
             path: "CLAUDE.generated.md",
-            content: "# CLAUDE.md\n\nNo se detectó ningún stack conocido. Completa este archivo manualmente.\n",
+            content: `# CLAUDE.md\n\n${ui.noStackFallback}\n` + (factsBlock ? `\n${factsBlock}\n` : ""),
         });
     }
     if (!options.skipLlm && hasInteractiveTty()) {
         const assistants = await detectAvailableAssistants(execFn);
         if (assistants.length > 0) {
             const chosenAssistant = assistants[0];
-            clack.log.info(`${chosenAssistant} detectado — puede ayudar a pulir la redacción final.`);
-            const usePolish = await clack.confirm({
-                message: `Se detectó ${chosenAssistant}. ¿Quieres que pula la redacción final?`,
-            });
+            clack.log.info(ui.polishDetected(chosenAssistant));
+            const usePolish = await clack.confirm({ message: ui.polishConfirm(chosenAssistant) });
             if (usePolish === true) {
                 for (const file of files) {
-                    file.content = await polishWithAssistant(chosenAssistant, file.content, execFn);
+                    file.content = await polishWithAssistant(chosenAssistant, file.content, execFn, lang);
                 }
             }
         }
     }
     return writeGeneratedFiles(rootPath, files);
 }
+function isLang(value) {
+    return value === "es" || value === "en";
+}
+export function resolveCliAction(argv) {
+    let lang;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h")
+            return { kind: "help" };
+        if (arg === "--version" || arg === "-v")
+            return { kind: "version" };
+        if (arg === "--lang" || arg.startsWith("--lang=")) {
+            const value = arg.startsWith("--lang=") ? arg.slice("--lang=".length) : argv[++i] ?? "";
+            if (!isLang(value))
+                return { kind: "invalid-lang", value };
+            lang = value;
+            continue;
+        }
+        return { kind: "unknown", flag: arg };
+    }
+    return lang ? { kind: "run", lang } : { kind: "run" };
+}
+export function getVersion() {
+    // Works both from src/ (tests) and dist/ (published bin): ../package.json
+    // resolves to packages/cli/package.json in either layout.
+    const pkg = createRequire(import.meta.url)("../package.json");
+    return pkg.version;
+}
 export async function main() {
+    const action = resolveCliAction(process.argv.slice(2));
+    const lang = action.kind === "run" && action.lang ? action.lang : detectLang();
+    const ui = UI[lang];
+    if (action.kind === "help") {
+        console.log(ui.usage);
+        return;
+    }
+    if (action.kind === "version") {
+        console.log(getVersion());
+        return;
+    }
+    if (action.kind === "unknown") {
+        console.error(`${ui.unknownOption(action.flag)}\n\n${ui.usage}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (action.kind === "invalid-lang") {
+        console.error(`${ui.invalidLang(action.value)}\n\n${ui.usage}`);
+        process.exitCode = 1;
+        return;
+    }
     clack.intro("agent-rules-init");
     if (!hasInteractiveTty()) {
-        console.warn("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.");
+        console.warn(ui.noTtyWarning);
     }
     try {
-        const results = await runCli(process.cwd());
+        const results = await runCli(process.cwd(), { lang });
         const written = results.filter((r) => r.status === "written");
         const failures = results.filter((r) => r.status === "error");
         for (const result of results) {
             if (result.status === "written") {
                 clack.log.success(result.path);
             }
+            else if (result.status === "skipped") {
+                clack.log.info(ui.fileSkipped(result.path));
+            }
             else {
                 clack.log.warn(`${result.path}: ${result.error}`);
             }
         }
         if (written.length > 0) {
-            clack.outro("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.");
+            clack.outro(ui.outroWritten);
         }
         else {
-            clack.outro("No se generó ningún archivo nuevo.");
+            clack.outro(ui.outroNothing);
         }
         if (failures.length > 0) {
             process.exitCode = 1;
         }
     }
     catch (err) {
-        clack.log.error(`Fallo inesperado: ${err.message}`);
+        clack.log.error(ui.unexpectedError(err.message));
         process.exitCode = 1;
     }
 }

package/dist/core/i18n.d.ts

@@ -0,0 +1,44 @@
+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 declare function unknownRunnerLabel(lang: Lang): string;
+export declare function unknownFrameworkLabel(lang: Lang): string;
+export interface UiTexts {
+    generatedHeader: string;
+    sections: {
+        commands: string;
+        structure: string;
+        ci: string;
+        conventions: string;
+        architecture: 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;
+    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;
+    fileSkipped: (path: string) => string;
+    outroWritten: string;
+    outroNothing: string;
+    unexpectedError: (message: string) => string;
+    cancelled: string;
+    dirNotes: Record<string, string>;
+}
+export declare const UI: Record<Lang, UiTexts>;

package/dist/core/i18n.js

@@ -0,0 +1,176 @@
+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) {
+    return lang === "es"
+        ? `Ejecuta los tests con ${cmd} antes de terminar una tarea.`
+        : `Run the tests with ${cmd} 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}` : "";
+    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.`;
+}
+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) {
+    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";
+}
+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",
+        },
+        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.`,
+        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}`,
+        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",
+        },
+    },
+    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",
+        },
+        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.`,
+        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}`,
+        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",
+        },
+    },
+};

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

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

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,13 @@ 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;
     }
 }

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[];

package/dist/core/prompt-engine.js

@@ -1,6 +1,8 @@
 import * as clack from "@clack/prompts";
+import { UI, detectLang } from "./i18n.js";
 const FIELDS = ["framework", "testRunner", "linter", "packageManager"];
-export function collectLowConfidenceQuestions(detections) {
+export function collectLowConfidenceQuestions(detections, lang) {
+    const ui = UI[lang];
     const questions = [];
     for (const detection of detections) {
         for (const field of FIELDS) {
@@ -9,7 +11,7 @@ export function collectLowConfidenceQuestions(detections) {
                 questions.push({
                     packId: detection.packId,
                     field,
-                    message: `No se pudo determinar el ${field} para ${detection.language}. ¿Cuál usáis?`,
+                    message: ui.question(ui.fieldLabels[field], detection.language),
                 });
             }
         }
@@ -19,18 +21,21 @@ export function collectLowConfidenceQuestions(detections) {
 export function hasInteractiveTty() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
-export const defaultPromptFn = async (message) => {
-    if (!hasInteractiveTty()) {
-        console.warn(`No se detectó una terminal interactiva; se omite la pregunta "${message}" y se usa el valor detectado.`);
-        return "";
-    }
-    const answer = await clack.text({ message });
-    if (clack.isCancel(answer)) {
-        clack.cancel("Operación cancelada.");
-        process.exit(1);
-    }
-    return answer;
-};
+export function makeDefaultPromptFn(lang) {
+    return async (message) => {
+        if (!hasInteractiveTty()) {
+            console.warn(UI[lang].skippedQuestion(message));
+            return "";
+        }
+        const answer = await clack.text({ message });
+        if (clack.isCancel(answer)) {
+            clack.cancel(UI[lang].cancelled);
+            process.exit(1);
+        }
+        return answer;
+    };
+}
+export const defaultPromptFn = (message) => makeDefaultPromptFn(detectLang())(message);
 export async function askQuestions(questions, promptFn = defaultPromptFn) {
     const answers = {};
     for (const question of questions) {

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

@@ -0,0 +1,20 @@
+import { type Lang } from "./i18n.js";
+import type { CiCommand, CommandEntry, CommandSource, DirEntry, RepoFacts, RepoSignals } from "./types.js";
+export declare function extractNpmCommands(signals: RepoSignals): CommandEntry[];
+export declare function extractMakeTargets(signals: RepoSignals): CommandEntry[];
+export declare function extractMixAliases(signals: RepoSignals): CommandEntry[];
+export declare function extractToxEnvs(signals: RepoSignals): CommandEntry[];
+export declare function extractComposerCommands(signals: RepoSignals): CommandEntry[];
+export declare function filterCommands(entries: CommandEntry[]): {
+    kept: CommandEntry[];
+    omitted: {
+        source: CommandSource;
+        count: number;
+    }[];
+};
+export declare function extractCiCommands(signals: RepoSignals): {
+    commands: CiCommand[];
+    omittedCount: number;
+};
+export declare function extractStructure(signals: RepoSignals, lang: Lang): DirEntry[];
+export declare function buildRepoFacts(signals: RepoSignals, lang: Lang): RepoFacts;