@orxataguy/tyr 1.0.32 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/lib/AIContextManager.ts

@@ -16,6 +16,7 @@ const CONTEXT_FILENAMES = [
     'CLAUDE.md',
     'AGENTS.md',
     'CONTEXT.md',
+    'README.md',
     '.cursorrules',
     path.join('.github', 'copilot-instructions.md'),
 ];
@@ -26,6 +27,16 @@ const SNAPSHOT_TREE_MAX_DEPTH = getEnvInt('SNAPSHOT_TREE_MAX_DEPTH', 5);
 const SNAPSHOT_TREE_MAX_ENTRIES_PER_DIR = getEnvInt('SNAPSHOT_TREE_MAX_ENTRIES_PER_DIR', 250);
 const SNAPSHOT_SECTION_MAX_CHARS = getEnvInt('SNAPSHOT_SECTION_MAX_CHARS', 40000);
 
+// How far findContextFiles() looks for guideline files OUTSIDE the exact target directory: upward
+// into ancestor directories (toward the repo root — a monorepo root AGENTS.md still applies to a
+// package inside it) and downward into subdirectories (a nested package may document itself).
+// Both are bounded so a huge repo doesn't turn every command into a full filesystem crawl.
+const CONTEXT_SEARCH_UPWARD_LEVELS = getEnvInt('CONTEXT_SEARCH_UPWARD_LEVELS', 4);
+const CONTEXT_SEARCH_DOWNWARD_LEVELS = getEnvInt('CONTEXT_SEARCH_DOWNWARD_LEVELS', 3);
+// Cap on how many context files are actually used, once found — closest to `dir` wins. Keeps a
+// monorepo with many nested AGENTS.md files from flooding the prompt with everything it can reach.
+const MAX_CONTEXT_FILES = getEnvInt('MAX_CONTEXT_FILES', 6);
+
 const DEFAULT_IGNORED_DIRS = new Set<string>([
     'node_modules', '.git', '.hg', '.svn',
     '.turbo', '.next', '.nuxt', '.cache', '.parcel-cache',
@@ -315,15 +326,85 @@ export class AIContextManager {
 
     /**
      * @method findContextFiles
-     * @description Busca los archivos de directrices conocidos directamente dentro del directorio
-     * del proyecto.
-     * @param {string} dir - Ruta absoluta a la raíz del proyecto.
-     * @returns {string[]} Rutas absolutas de los archivos de directrices que existen.
+     * @description Busca los archivos de directrices conocidos (README.md, CLAUDE.md, AGENTS.md,
+     * CONTEXT.md, .cursorrules, copilot-instructions.md) no solo dentro de `dir`, sino tanto hacia
+     * fuera (directorios ancestros, hasta CONTEXT_SEARCH_UPWARD_LEVELS niveles — un AGENTS.md en la
+     * raíz de un monorepo sigue aplicando a un paquete dentro de él) como hacia dentro (subcarpetas,
+     * hasta CONTEXT_SEARCH_DOWNWARD_LEVELS niveles — un paquete anidado puede documentarse a sí
+     * mismo). La "relevancia" se determina de forma determinista, sin llamar a la IA (esto se
+     * ejecuta antes de cada comando, así que tiene que ser barato):
+     *   - Hacia fuera: se detiene en cuanto se cruza la raíz del repo (una carpeta .git), además del
+     *     tope de niveles — más allá de eso nunca es relevante.
+     *   - Hacia dentro: NO se desciende más allá del primer directorio que tenga su propio
+     *     package.json/composer.json (un límite de paquete independiente) salvo para recoger el
+     *     archivo de contexto que esté justo en ese límite; lo que hay más adentro pertenece a ese
+     *     otro paquete, no a `dir`.
+     *   - Si aun así se encuentran más de MAX_CONTEXT_FILES candidatos, ganan los más cercanos a `dir`.
+     * @param {string} dir - Ruta absoluta a la raíz del proyecto (o subcarpeta) desde la que buscar.
+     * @returns {Promise<string[]>} Rutas absolutas de los archivos de directrices relevantes, del más al menos cercano.
      */
-    public findContextFiles(dir: string): string[] {
-        return CONTEXT_FILENAMES
-            .map(name => path.join(dir, name))
-            .filter(fullPath => this.fs.exists(fullPath));
+    public async findContextFiles(dir: string): Promise<string[]> {
+        const found = new Map<string, number>();
+
+        const record = (fullPath: string, distance: number) => {
+            if (!this.fs.exists(fullPath)) return;
+            const previous = found.get(fullPath);
+            if (previous === undefined || distance < previous) found.set(fullPath, distance);
+        };
+
+        // Here (distance 0).
+        for (const name of CONTEXT_FILENAMES) record(path.join(dir, name), 0);
+
+        // Outward: ancestor directories, stopping at the repo root once reached.
+        let upDir = dir;
+        for (let level = 1; level <= CONTEXT_SEARCH_UPWARD_LEVELS; level++) {
+            const parent = path.dirname(upDir);
+            if (parent === upDir) break; // filesystem root
+            upDir = parent;
+            for (const name of CONTEXT_FILENAMES) record(path.join(upDir, name), level);
+            if (this.fs.exists(path.join(upDir, '.git'))) break;
+        }
+
+        // Inward: subdirectories, pruned at package boundaries.
+        await this.walkDownForContextFiles(dir, 1, false, record);
+
+        return [...found.entries()]
+            .sort((a, b) => a[1] - b[1])
+            .slice(0, MAX_CONTEXT_FILES)
+            .map(([fullPath]) => fullPath);
+    }
+
+    /** Recursive helper for the inward half of findContextFiles(). `crossedPackageBoundary` starts
+     *  false and flips to true once we step into a directory with its own manifest — from that
+     *  point on we keep recursing (so deeper package boundaries are still detected and stopped at
+     *  in turn) but stop *recording* candidates, since anything past that boundary belongs to a
+     *  separately versioned sub-package rather than `dir`. */
+    private async walkDownForContextFiles(
+        currentDir: string,
+        level: number,
+        crossedPackageBoundary: boolean,
+        record: (fullPath: string, distance: number) => void
+    ): Promise<void> {
+        if (level > CONTEXT_SEARCH_DOWNWARD_LEVELS) return;
+
+        let entries;
+        try {
+            entries = await this.fs.readdir(currentDir, { withFileTypes: true });
+        } catch {
+            return;
+        }
+
+        for (const entry of entries) {
+            if (!entry.isDirectory() || DEFAULT_IGNORED_DIRS.has(entry.name)) continue;
+            const childDir = path.join(currentDir, entry.name);
+
+            if (!crossedPackageBoundary) {
+                for (const name of CONTEXT_FILENAMES) record(path.join(childDir, name), level);
+            }
+
+            const childHasOwnManifest = [...MANIFEST_FILENAMES].some(name => this.fs.exists(path.join(childDir, name)));
+            await this.walkDownForContextFiles(childDir, level + 1, crossedPackageBoundary || childHasOwnManifest, record);
+        }
     }
 
     private async readAndValidate(filePath: string): Promise<string | null> {
@@ -483,7 +564,7 @@ export class AIContextManager {
      * @returns {Promise<GuidelinesBlock[]>}
      */
     public async readGuidelines(dir: string): Promise<GuidelinesBlock[]> {
-        let files = this.findContextFiles(dir);
+        let files = await this.findContextFiles(dir);
 
         if (files.length === 0) {
             const generated = await this.generateContextFile(dir);
@@ -493,7 +574,10 @@ export class AIContextManager {
         const blocks: GuidelinesBlock[] = [];
         for (const file of files) {
             const content = await this.readAndValidate(file);
-            if (content) blocks.push({ fileName: path.basename(file), content });
+            // Relative to `dir` rather than just the basename: with the search now reaching
+            // outward/inward, two blocks can share a filename (e.g. an AGENTS.md here AND one two
+            // levels up) — the path disambiguates which is which for whoever reads getGuidelinesText().
+            if (content) blocks.push({ fileName: path.relative(dir, file) || path.basename(file), content });
         }
 
         if (blocks.length === 0) {

package/src/lib/AIVendorManager.ts

@@ -132,14 +132,14 @@ type ModelTier = 'cheap' | 'balanced' | 'flagship';
 
 const MODEL_TIERS: Record<AIVendor, Record<ModelTier, string>> = {
     anthropic: { cheap: 'claude-haiku-4-5', balanced: 'claude-sonnet-5', flagship: 'claude-opus-4-1' },
-    openai: { cheap: 'gpt-4o-mini', balanced: 'gpt-4o', flagship: 'gpt-4o' },
+    openai: { cheap: 'gpt-4o-mini', balanced: 'gpt-4o-mini', flagship: 'gpt-4o' },
     gemini: { cheap: 'gemini-2.5-flash', balanced: 'gemini-2.5-pro', flagship: 'gemini-2.5-pro' },
 };
 
-const MODEL_TIER_ENV: Record<ModelTier, string> = {
-    cheap: 'AI_MODEL_CHEAP',
-    balanced: 'AI_MODEL_BALANCED',
-    flagship: 'AI_MODEL_FLAGSHIP',
+const MODEL_TIER_ENV: Record<AIVendor, Record<ModelTier, string>> = {
+    anthropic: { cheap: 'ANTHROPIC_AI_MODEL_CHEAP', balanced: 'ANTHROPIC_AI_MODEL_BALANCED', flagship: 'ANTHROPIC_AI_MODEL_FLAGSHIP' },
+    openai: { cheap: 'OPENAI_AI_MODEL_CHEAP', balanced: 'OPENAI_AI_MODEL_BALANCED', flagship: 'OPENAI_AI_MODEL_FLAGSHIP' },
+    gemini: { cheap: 'GEMINI_AI_MODEL_CHEAP', balanced: 'GEMINI_AI_MODEL_BALANCED', flagship: 'GEMINI_AI_MODEL_FLAGSHIP' },
 };
 
 /** budget_tokens sent to Anthropic's `thinking` param per effort level. 'none' disables thinking. */
@@ -260,7 +260,7 @@ export class AIVendorManager {
             throw new TyrError(`Unknown task priority: '${priority}'`, null, `Use one of: ${PRIORITY_LADDER.join(', ')}`);
         }
 
-        const tierModel = getEnvString(MODEL_TIER_ENV[route.tier]) ?? MODEL_TIERS[vendor][route.tier];
+        const tierModel = getEnvString(MODEL_TIER_ENV[vendor][route.tier]) ?? MODEL_TIERS[vendor][route.tier];
 
         return {
             vendor,