@agentbrain/mcp-server 1.4.67 → 1.4.74

package/dist/tools/load-context.js

@@ -1,9 +1,9 @@
 // MCP tool: load_context - load context docs at session start
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
-import { loadAIConfig, generateContext, getCachedDoc, getGitHash, loadCache, getPendingDoomForMCP, ensureGitignore, installPostCommitHook, isGitRepository, createAgentFilesShared, } from '@agentbrain/core';
+import { loadAIConfig, generateContext, getGitHash, loadCache, getPendingDoomForMCP, ensureGitignore, installPostCommitHook, isGitRepository, createAgentFilesShared, generateContextFiles, } from '@agentbrain/core';
 /**
  * Expand path: handles ~, relative paths, etc.
  */
@@ -13,118 +13,483 @@ function expandPath(path) {
     }
     return resolve(path);
 }
+/**
+ * Order context files: specific order for known files, alphabetical for others, errors.md last
+ */
+function orderContextFiles(files) {
+    const order = [
+        'context.md',
+        'branch-context.md',
+        'agent-hints.md',
+        'run-commands.md',
+        'schema.md',
+        'dependencies.md',
+        'dependency-map.md',
+        'patterns.md',
+        'decisions.md',
+        'inventory.md',
+        'testing.md',
+        'environment.md',
+    ];
+    const ordered = [];
+    const remaining = [];
+    let errorsFile = null;
+    for (const file of files) {
+        if (file === 'errors.md') {
+            errorsFile = file;
+        }
+        else if (order.includes(file)) {
+            ordered.push(file);
+        }
+        else {
+            remaining.push(file);
+        }
+    }
+    // Sort known files by order array
+    ordered.sort((a, b) => order.indexOf(a) - order.indexOf(b));
+    // Sort remaining alphabetically
+    remaining.sort();
+    // Combine: ordered + remaining + errors.md
+    const result = [...ordered, ...remaining];
+    if (errorsFile) {
+        result.push(errorsFile);
+    }
+    return result;
+}
+/**
+ * Get description for a context file
+ */
+function getFileDescription(filename) {
+    const descriptions = {
+        'context.md': 'architecture overview',
+        'schema.md': 'database models',
+        'patterns.md': 'coding conventions',
+        'dependencies.md': 'package versions',
+        'dependency-map.md': 'module relationships',
+        'testing.md': 'test patterns',
+        'decisions.md': 'tech stack decisions',
+        'errors.md': 'known issues and solutions',
+        'branch-context.md': 'current branch and recent commits',
+        'inventory.md': 'components and utilities',
+        'environment.md': 'environment variables',
+        'run-commands.md': 'available commands',
+        'agent-hints.md': 'entry points and stack',
+    };
+    return descriptions[filename] || 'additional context';
+}
+/**
+ * Build a slim summary from context.md, run-commands.md, and agent-hints.md
+ * Extracts key sections without full content. Keep under 60 lines total.
+ */
+function buildSlimSummary(contextContent, availableFiles, runCommandsContent, agentHintsContent) {
+    const lines = contextContent.split('\n');
+    let projectName = 'Project';
+    let techStack = [];
+    let structure = [];
+    let modules = [];
+    // Extract project name (first # heading)
+    for (const line of lines) {
+        if (line.startsWith('# ') && !projectName) {
+            projectName = line.replace('# ', '').trim();
+            break;
+        }
+    }
+    // Extract tech stack (look for "Tech Stack", "Stack", or "Technologies" section)
+    let inTechStack = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^##\s+(Tech Stack|Stack|Technologies|Technology)/i.test(line)) {
+            inTechStack = true;
+            continue;
+        }
+        if (inTechStack) {
+            if (line.startsWith('##'))
+                break; // Next section
+            if (line.trim().startsWith('-') || line.trim().startsWith('*')) {
+                const item = line.replace(/^[\s\-\*]+/, '').split(':')[0].trim();
+                if (item && techStack.length < 6) {
+                    // Reduced from 8 to keep summary compact
+                    techStack.push(item);
+                }
+            }
+        }
+    }
+    // Extract entry points from agent-hints.md if available
+    const entryPoints = [];
+    if (agentHintsContent) {
+        const hintLines = agentHintsContent.split('\n');
+        let inEntryPoints = false;
+        for (const line of hintLines) {
+            if (line.includes('## Entry Points')) {
+                inEntryPoints = true;
+                continue;
+            }
+            if (inEntryPoints) {
+                if (line.startsWith('##'))
+                    break;
+                if (line.trim().startsWith('-')) {
+                    const entry = line.replace(/^[\s\-\*]+/, '').trim();
+                    if (entry && !entry.startsWith('*') && entryPoints.length < 3) {
+                        entryPoints.push(entry);
+                    }
+                }
+            }
+        }
+    }
+    // Extract run commands from run-commands.md if available
+    const runCommands = [];
+    if (runCommandsContent) {
+        const cmdLines = runCommandsContent.split('\n');
+        let currentCategory = '';
+        for (const line of cmdLines) {
+            if (line.startsWith('### ')) {
+                currentCategory = line.replace('### ', '').trim();
+                runCommands.push({ category: currentCategory, commands: [] });
+            }
+            else if (line.trim().startsWith('-') && currentCategory) {
+                const cmd = line.replace(/^[\s\-\*]+/, '').trim();
+                if (cmd) {
+                    const lastCategory = runCommands[runCommands.length - 1];
+                    if (lastCategory && lastCategory.commands.length < 3) {
+                        // Max 3 per category to keep compact
+                        lastCategory.commands.push(cmd);
+                    }
+                }
+            }
+        }
+    }
+    // Build slim summary (keep under 60 lines)
+    let summary = `# ${projectName} - Context Summary\n\n`;
+    // Entry points (compact, high-value)
+    if (entryPoints.length > 0) {
+        summary += `## Entry Points\n${entryPoints.join(', ')}\n\n`;
+    }
+    // Tech stack
+    if (techStack.length > 0) {
+        summary += `## Tech Stack\n${techStack.join(', ')}\n\n`;
+    }
+    // Run commands (compact format)
+    if (runCommands.length > 0) {
+        summary += `## Run Commands\n`;
+        for (const { category, commands } of runCommands.slice(0, 3)) {
+            // Max 3 categories
+            if (commands.length > 0) {
+                summary += `**${category}**: ${commands.slice(0, 2).join(', ')}\n`; // Max 2 per category
+            }
+        }
+        summary += '\n';
+    }
+    // Available files (compact)
+    summary += `## Available Context Files\n`;
+    const importantFiles = availableFiles.filter((f) => ['context.md', 'patterns.md', 'decisions.md', 'schema.md'].includes(f));
+    const otherFiles = availableFiles.filter((f) => !importantFiles.includes(f));
+    for (const file of importantFiles) {
+        summary += `- .agentbrain/${file} — ${getFileDescription(file)}\n`;
+    }
+    if (otherFiles.length > 0) {
+        summary += `... and ${otherFiles.length} more files\n`;
+    }
+    summary += `\n## How to Load More\n`;
+    summary += `- Full context: load_context({ full: true })\n`;
+    summary += `- Specific file: load_context({ files: ['schema.md'] })\n`;
+    summary += `- Generate new context: generate_context({ focus: "area name" })\n`;
+    return summary;
+}
+/**
+ * Bootstrap a repository with auto-generated context files
+ * Uses AST parser to generate factual files in ~1 second
+ * Agent only needs to write 3 interpretive files
+ */
+async function bootstrapRepo(repoPath) {
+    const contextDir = join(repoPath, '.agentbrain');
+    // 1. Create .agentbrain/ directory
+    if (!existsSync(contextDir)) {
+        await mkdir(contextDir, { recursive: true });
+    }
+    // 2. Auto-generate factual context files using parser (fast, ~1 second)
+    const generatedFiles = await generateContextFiles(repoPath);
+    // 3. Save generated files to .agentbrain/
+    for (const file of generatedFiles) {
+        await writeFile(join(contextDir, file.name), file.content, 'utf-8');
+    }
+    // 4. Get current git hash and write cache.json
+    const gitHash = await getGitHash(repoPath);
+    const docs = {};
+    for (const file of generatedFiles) {
+        const baseName = file.name.replace('.md', '');
+        docs[baseName] = {
+            type: baseName,
+            content: file.content,
+            savedAt: new Date().toISOString(),
+        };
+    }
+    const cachePath = join(contextDir, 'cache.json');
+    const cache = {
+        gitHash,
+        docs,
+        savedAt: new Date().toISOString(),
+    };
+    await writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+    // Write setup-source marker
+    const setupSourcePath = join(contextDir, 'setup-source.json');
+    await writeFile(setupSourcePath, JSON.stringify({ source: 'mcp-bootstrap', setupAt: new Date().toISOString() }, null, 2), 'utf-8');
+    // 5. Update .gitignore
+    try {
+        await ensureGitignore(repoPath);
+    }
+    catch (err) {
+        console.error('[bootstrap] .gitignore update failed:', err);
+    }
+    // 6. Install git hook if this is a git repository
+    if (isGitRepository(repoPath)) {
+        try {
+            await installPostCommitHook(repoPath);
+        }
+        catch (err) {
+            console.error('[bootstrap] Git hook installation failed:', err);
+        }
+    }
+    // 7. Update AGENTS.md with file list
+    const fileNames = generatedFiles.map((f) => f.name);
+    try {
+        await createAgentFilesShared(repoPath, fileNames);
+    }
+    catch (err) {
+        console.error('[bootstrap] AGENTS.md update failed:', err);
+    }
+    // 8. Return instruction for agent to write the 3 interpretive files only
+    const fileList = generatedFiles.map((f) => `✓ .agentbrain/${f.name}`).join('\n');
+    return `AgentBrain has auto-generated ${generatedFiles.length} context files from your codebase in ~2 seconds:
+
+${fileList}
+
+These cover ~80% of what you need to work effectively in this codebase.
+
+Now generate 3 short interpretive files. Call save_context() when done.
+
+IMPORTANT: Keep each file SHORT and focused on NON-OBVIOUS information only. The factual files already exist. Don't repeat what's already in schema.md, dependencies.md, etc.
+
+---
+
+1. context.md (target: 20-30 lines)
+   Only include:
+   - What this product does (2 sentences max)
+   - Key modules list (name + 1 line purpose each)
+   - 1-2 non-obvious data flows
+   Skip: tech stack (in dependencies.md), file structure (in inventory.md)
+
+2. patterns.md (target: 20-40 lines)
+   Only include:
+   - Key utilities to ALWAYS use (not reinvent)
+   - 3-5 anti-patterns specific to this codebase
+   - Error handling approach
+   - 1-2 non-obvious conventions
+   Skip: standard framework patterns, obvious conventions
+
+3. decisions.md (target: 10-20 lines)
+   Only include:
+   - What must NOT be changed (compliance, legacy)
+   - Why key non-obvious libraries were chosen
+   - 1-2 architectural choices that surprise devs
+   Skip: obvious choices, anything self-evident from the code
+
+Total target: under 80 lines across all 3 files.
+Short, opinionated, non-obvious = high signal.
+Long, comprehensive, obvious = noise.`;
+}
 export async function loadContext(input) {
-    const { repo_path, force_refresh = false } = input;
+    const { repo_path, force_refresh = false, full = false, files: requestedFiles } = input;
     // Expand path to handle ~, relative paths, etc.
     const expandedPath = expandPath(repo_path);
     const contextDir = join(expandedPath, '.agentbrain');
+    // Bootstrap if .agentbrain/ doesn't exist
+    if (!existsSync(contextDir)) {
+        const bootstrapMessage = await bootstrapRepo(expandedPath);
+        return {
+            content: bootstrapMessage,
+            fromCache: false,
+            tokensUsed: 0,
+            doom_warning: null,
+        };
+    }
     // Get current git hash for staleness check
     const currentGitHash = await getGitHash(expandedPath);
-    // Try to load from disk first
-    const contextPath = join(contextDir, 'context.md');
-    const depMapPath = join(contextDir, 'dependency-map.md');
-    const patternsPath = join(contextDir, 'patterns.md');
-    const allExist = existsSync(contextPath) && existsSync(depMapPath) && existsSync(patternsPath);
-    if (!force_refresh && allExist) {
-        // Load from disk
-        const context = await readFile(contextPath, 'utf-8');
-        const depMap = await readFile(depMapPath, 'utf-8');
-        const patterns = await readFile(patternsPath, 'utf-8');
-        const combined = `# Repository Context\n\n${context}\n\n---\n\n# Dependency Map\n\n${depMap}\n\n---\n\n# Patterns\n\n${patterns}`;
-        // Post-processing: If cache.json or setup-source.json is missing, agent wrote files directly
-        const cachePath = join(contextDir, 'cache.json');
-        const setupSourcePath = join(contextDir, 'setup-source.json');
-        const cacheExists = existsSync(cachePath);
-        const setupSourceExists = existsSync(setupSourcePath);
-        if (!cacheExists || !setupSourceExists) {
-            // Agent wrote files directly — run post-processing
-            try {
-                // Write cache.json
-                if (!cacheExists) {
-                    const cache = {
-                        gitHash: currentGitHash,
-                        docs: {
-                            context: {
-                                type: 'context',
-                                content: context,
-                                savedAt: new Date().toISOString(),
-                            },
-                            'dependency-map': {
-                                type: 'dependency-map',
-                                content: depMap,
-                                savedAt: new Date().toISOString(),
-                            },
-                            patterns: {
-                                type: 'patterns',
-                                content: patterns,
+    // Try to load from disk first - read ALL .md files
+    if (!force_refresh && existsSync(contextDir)) {
+        try {
+            const allFiles = await readdir(contextDir);
+            const mdFiles = allFiles.filter((f) => f.endsWith('.md'));
+            if (mdFiles.length > 0) {
+                // Order files properly
+                const orderedFiles = orderContextFiles(mdFiles);
+                // Determine which files to load based on mode
+                let filesToLoad = orderedFiles;
+                if (requestedFiles && requestedFiles.length > 0) {
+                    // Load only requested files
+                    filesToLoad = orderedFiles.filter((f) => requestedFiles.includes(f));
+                }
+                else if (!full) {
+                    // Slim mode: load context.md, run-commands.md, and agent-hints.md for summary
+                    filesToLoad = orderedFiles.filter((f) => ['context.md', 'run-commands.md', 'agent-hints.md'].includes(f));
+                }
+                // Load files
+                const fileContents = [];
+                for (const file of filesToLoad) {
+                    const filePath = join(contextDir, file);
+                    const content = await readFile(filePath, 'utf-8');
+                    const title = file.replace('.md', '').replace(/-/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                    fileContents.push({ name: file, content: `# ${title}\n\n${content}` });
+                }
+                // Build output based on mode
+                let combined;
+                if (!full && !requestedFiles) {
+                    // Slim mode: build summary from context.md, run-commands.md, and agent-hints.md
+                    const contextContent = fileContents.find((f) => f.name === 'context.md');
+                    const runCommandsContent = fileContents.find((f) => f.name === 'run-commands.md');
+                    const agentHintsContent = fileContents.find((f) => f.name === 'agent-hints.md');
+                    if (contextContent) {
+                        combined = buildSlimSummary(contextContent.content, orderedFiles, runCommandsContent?.content, agentHintsContent?.content);
+                    }
+                    else {
+                        // Fallback if context.md doesn't exist
+                        combined = buildSlimSummary('# Project\n\n', orderedFiles, runCommandsContent?.content, agentHintsContent?.content);
+                    }
+                }
+                else {
+                    // Full mode or specific files: concatenate all loaded files
+                    combined = fileContents.map((f) => f.content).join('\n\n---\n\n');
+                }
+                // Post-processing: If cache.json or setup-source.json is missing, agent wrote files directly
+                const cachePath = join(contextDir, 'cache.json');
+                const setupSourcePath = join(contextDir, 'setup-source.json');
+                const cacheExists = existsSync(cachePath);
+                const setupSourceExists = existsSync(setupSourcePath);
+                if (!cacheExists || !setupSourceExists) {
+                    // Agent wrote files directly — run post-processing
+                    try {
+                        // Write cache.json with ALL files
+                        if (!cacheExists) {
+                            const docs = {};
+                            for (const file of orderedFiles) {
+                                const filePath = join(contextDir, file);
+                                const content = await readFile(filePath, 'utf-8');
+                                const baseName = file.replace('.md', '');
+                                docs[baseName] = {
+                                    type: baseName,
+                                    content,
+                                    savedAt: new Date().toISOString(),
+                                };
+                            }
+                            const cache = {
+                                gitHash: currentGitHash,
+                                docs,
                                 savedAt: new Date().toISOString(),
-                            },
-                        },
-                        savedAt: new Date().toISOString(),
-                    };
-                    await writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+                            };
+                            await writeFile(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+                        }
+                        // Write setup-source.json
+                        if (!setupSourceExists) {
+                            await writeFile(setupSourcePath, JSON.stringify({ source: 'mcp', setupAt: new Date().toISOString() }, null, 2), 'utf-8');
+                        }
+                        // Update .gitignore
+                        await ensureGitignore(expandedPath);
+                        // Install git hook if this is a git repository
+                        if (isGitRepository(expandedPath)) {
+                            await installPostCommitHook(expandedPath);
+                        }
+                        // Create agent files with ALL context files
+                        await createAgentFilesShared(expandedPath, orderedFiles);
+                        // Silent success - only log errors
+                    }
+                    catch (err) {
+                        console.error('[load_context] Post-processing failed:', err);
+                    }
                 }
-                // Write setup-source.json
-                if (!setupSourceExists) {
-                    await writeFile(setupSourcePath, JSON.stringify({ source: 'mcp', setupAt: new Date().toISOString() }, null, 2), 'utf-8');
+                // Check if cached git hash matches current HEAD
+                const cache = await loadCache(expandedPath);
+                const isStale = cache && cache.gitHash !== currentGitHash;
+                // Check for doom loop warnings
+                const doomWarning = await getPendingDoomForMCP(expandedPath);
+                const footer = '\n\n---\n_AgentBrain context loaded. Check doom_warning field for any detected issues._';
+                return {
+                    content: combined + footer,
+                    fromCache: true,
+                    tokensUsed: 0,
+                    ...(isStale && {
+                        stale: true,
+                        cached_sha: cache.gitHash,
+                        current_sha: currentGitHash,
+                        message: 'Context may be outdated. Run agentbrain init to refresh.',
+                    }),
+                    doom_warning: doomWarning,
+                };
+            }
+        }
+        catch (err) {
+            // If there's an error reading files, fall through to cache check
+            console.error('[load_context] Error reading .agentbrain files:', err);
+        }
+    }
+    // Check cache validity - load from cache.json if available
+    const cache = await loadCache(expandedPath);
+    if (!force_refresh && cache && cache.docs) {
+        // Extract all doc names and order them
+        const docNames = Object.keys(cache.docs).map((name) => `${name}.md`);
+        const orderedDocs = orderContextFiles(docNames);
+        // Determine which docs to load based on mode
+        let docsToLoad = orderedDocs;
+        if (requestedFiles && requestedFiles.length > 0) {
+            // Load only requested files
+            docsToLoad = orderedDocs.filter((f) => requestedFiles.includes(f));
+        }
+        else if (!full) {
+            // Slim mode: only load context for summary
+            docsToLoad = orderedDocs.filter((f) => f === 'context.md');
+        }
+        // Build content from cache
+        const fileContents = [];
+        for (const docFile of docsToLoad) {
+            const docName = docFile.replace('.md', '');
+            const doc = cache.docs[docName];
+            if (doc) {
+                const title = docName.replace(/-/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+                fileContents.push(`# ${title}\n\n${doc.content}`);
+            }
+        }
+        if (fileContents.length > 0) {
+            // Build output based on mode
+            let combined;
+            if (!full && !requestedFiles) {
+                // Slim mode: build summary
+                const contextContent = fileContents.find((c) => c.startsWith('# Context'));
+                if (contextContent) {
+                    combined = buildSlimSummary(contextContent, orderedDocs);
                 }
-                // Update .gitignore
-                await ensureGitignore(expandedPath);
-                // Install git hook if this is a git repository
-                if (isGitRepository(expandedPath)) {
-                    await installPostCommitHook(expandedPath);
+                else {
+                    combined = buildSlimSummary('# Project\n\n', orderedDocs);
                 }
-                // Create agent files
-                await createAgentFilesShared(expandedPath);
-                console.error('[load_context] Post-processing completed for manually-written files');
             }
-            catch (err) {
-                console.error('[load_context] Post-processing failed:', err);
+            else {
+                // Full mode or specific files
+                combined = fileContents.join('\n\n---\n\n');
             }
+            const isStale = cache.gitHash !== currentGitHash;
+            // Check for doom loop warnings
+            const doomWarning = await getPendingDoomForMCP(expandedPath);
+            const footer = '\n\n---\n_AgentBrain context loaded. Check doom_warning field for any detected issues._';
+            return {
+                content: combined + footer,
+                fromCache: true,
+                tokensUsed: 0,
+                ...(isStale && {
+                    stale: true,
+                    cached_sha: cache.gitHash,
+                    current_sha: currentGitHash,
+                    message: 'Context may be outdated. Run agentbrain init to refresh.',
+                }),
+                doom_warning: doomWarning,
+            };
         }
-        // Check if cached git hash matches current HEAD
-        const cache = await loadCache(expandedPath);
-        const isStale = cache && cache.gitHash !== currentGitHash;
-        // Check for doom loop warnings
-        const doomWarning = await getPendingDoomForMCP(expandedPath);
-        const footer = '\n\n---\n_AgentBrain context loaded. Check doom_warning field for any detected issues._';
-        return {
-            content: combined + footer,
-            fromCache: true,
-            tokensUsed: 0,
-            ...(isStale && {
-                stale: true,
-                cached_sha: cache.gitHash,
-                current_sha: currentGitHash,
-                message: 'Context may be outdated. Run agentbrain init to refresh.',
-            }),
-            doom_warning: doomWarning,
-        };
-    }
-    // Check cache validity (using currentGitHash from above)
-    const cachedContext = await getCachedDoc(expandedPath, currentGitHash, 'context');
-    const cachedDepMap = await getCachedDoc(expandedPath, currentGitHash, 'dependency-map');
-    const cachedPatterns = await getCachedDoc(expandedPath, currentGitHash, 'patterns');
-    if (!force_refresh && cachedContext && cachedDepMap && cachedPatterns) {
-        const combined = `# Repository Context\n\n${cachedContext.content}\n\n---\n\n# Dependency Map\n\n${cachedDepMap.content}\n\n---\n\n# Patterns\n\n${cachedPatterns.content}`;
-        // Check if cached git hash matches current HEAD
-        const cache = await loadCache(expandedPath);
-        const isStale = cache && cache.gitHash !== currentGitHash;
-        // Check for doom loop warnings
-        const doomWarning = await getPendingDoomForMCP(expandedPath);
-        const footer = '\n\n---\n_AgentBrain context loaded. Check doom_warning field for any detected issues._';
-        return {
-            content: combined + footer,
-            fromCache: true,
-            tokensUsed: 0,
-            ...(isStale && {
-                stale: true,
-                cached_sha: cache.gitHash,
-                current_sha: currentGitHash,
-                message: 'Context may be outdated. Run agentbrain init to refresh.',
-            }),
-            doom_warning: doomWarning,
-        };
     }
     // Need to generate - no API key path returns bootstrap message
     let aiConfig = null;
@@ -167,7 +532,13 @@ Call: setup_repo({ repo_path: '${expandedPath}' })`,
 }
 export const loadContextSchema = {
     name: 'load_context',
-    description: 'Load codebase context. If first time setup, automatically scans repo and returns file tree + key files with friendly instructions. Agent then generates context documents. No API key needed.',
+    description: 'Load codebase context.\n\n' +
+        'Default: Returns slim summary showing available context files. Fast, low token usage (~100 lines).\n\n' +
+        'Options:\n' +
+        '  full: true → load all context files (large, 1000+ lines)\n' +
+        '  files: ["schema.md"] → load specific files only\n' +
+        '  force_refresh: true → regenerate context\n\n' +
+        'If first time setup, automatically scans repo and returns setup instructions.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -179,6 +550,17 @@ export const loadContextSchema = {
                 type: 'boolean',
                 description: 'Force regeneration even if cache is valid (default: false)',
             },
+            full: {
+                type: 'boolean',
+                description: 'Load all context files instead of slim summary (default: false)',
+            },
+            files: {
+                type: 'array',
+                description: 'Load specific files only (e.g., ["schema.md", "patterns.md"])',
+                items: {
+                    type: 'string',
+                },
+            },
         },
         required: ['repo_path'],
     },