ted-mosby 1.0.0 → 1.1.1

package/dist/wiki-agent.js

@@ -1,4 +1,5 @@
 import { query, tool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
+import Anthropic from '@anthropic-ai/sdk';
 import { z } from 'zod';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -8,6 +9,8 @@ import { PermissionManager } from './permissions.js';
 import { MCPConfigManager } from './mcp-config.js';
 import { RAGSystem } from './rag/index.js';
 import { WIKI_SYSTEM_PROMPT } from './prompts/wiki-system.js';
+// Store generation options for use in tool server
+let currentGenerationOptions = null;
 export class ArchitecturalWikiAgent {
     config;
     permissionManager;
@@ -33,6 +36,8 @@ export class ArchitecturalWikiAgent {
      * Generate wiki documentation for a repository
      */
     async *generateWiki(options) {
+        // Store options for tool server to access
+        currentGenerationOptions = options;
         // Phase 1: Clone or access repository
         yield { type: 'phase', message: 'Preparing repository', progress: 0 };
         this.repoPath = await this.prepareRepository(options.repoUrl, options.accessToken);
@@ -45,7 +50,8 @@ export class ArchitecturalWikiAgent {
         yield { type: 'phase', message: 'Indexing codebase for semantic search', progress: 10 };
         this.ragSystem = new RAGSystem({
             storePath: path.join(this.outputDir, '.ted-mosby-cache'),
-            repoPath: this.repoPath
+            repoPath: this.repoPath,
+            maxChunks: options.maxChunks // Limit chunks for large codebases
         });
         await this.ragSystem.indexRepository();
         yield { type: 'step', message: `Indexed ${this.ragSystem.getDocumentCount()} code chunks` };
@@ -56,7 +62,18 @@ export class ArchitecturalWikiAgent {
         const agentOptions = this.buildAgentOptions(options);
         const prompt = this.buildGenerationPrompt(options);
         // Stream agent execution using simple string prompt
+        // Track if we've yielded the complete event (wiki is done even if subprocess exits uncleanly)
+        let wikiComplete = false;
         try {
+            if (options.verbose) {
+                console.log('[Debug] Starting agent with options:', JSON.stringify({
+                    model: agentOptions.model,
+                    cwd: agentOptions.cwd,
+                    maxTurns: agentOptions.maxTurns,
+                    allowedTools: agentOptions.allowedTools?.length,
+                    ragChunks: this.ragSystem?.getDocumentCount()
+                }, null, 2));
+            }
             const queryResult = query({
                 prompt,
                 options: agentOptions
@@ -65,27 +82,903 @@ export class ArchitecturalWikiAgent {
                 // Capture session ID
                 if (message.type === 'system' && message.subtype === 'init') {
                     this.sessionId = message.session_id;
+                    if (options.verbose) {
+                        console.log('[Debug] Agent initialized, session:', this.sessionId);
+                    }
                 }
                 // Log errors from the agent
                 if (message.type === 'system' && message.subtype === 'error') {
-                    console.error('Agent error:', message.error || message);
+                    console.error('Agent error:', JSON.stringify(message, null, 2));
+                }
+                // Log tool calls in verbose mode
+                if (options.verbose && message.type === 'assistant' && message.tool_use) {
+                    const tools = message.tool_use;
+                    console.log('[Debug] Tool calls:', tools.map((t) => t.name).join(', '));
+                }
+                // Check if agent has finished its work (result message indicates completion)
+                if (message.type === 'result' && message.subtype === 'success') {
+                    wikiComplete = true;
                 }
                 yield message;
             }
             yield { type: 'complete', message: 'Wiki generation complete', progress: 100 };
         }
         catch (err) {
-            // Capture stderr if available
+            // If wiki was already complete when the error occurred, treat as success
+            // This handles the case where the subprocess exits during cleanup
+            if (wikiComplete) {
+                if (options.verbose) {
+                    console.log('[Debug] Wiki generation completed successfully (subprocess cleanup error ignored)');
+                }
+                yield { type: 'complete', message: 'Wiki generation complete', progress: 100 };
+                return; // Don't throw - wiki is done
+            }
+            // Enhanced error capture for actual failures
             console.error('Query error details:', err.message);
+            // Log full error object for debugging
+            if (options.verbose) {
+                console.error('[Debug] Full error:', JSON.stringify(err, Object.getOwnPropertyNames(err), 2));
+            }
             if (err.stderr) {
                 console.error('Stderr:', err.stderr);
             }
+            if (err.stdout) {
+                console.error('Stdout:', err.stdout);
+            }
             if (err.cause) {
                 console.error('Cause:', err.cause);
             }
+            if (err.code) {
+                console.error('Exit code:', err.code);
+            }
+            if (err.signal) {
+                console.error('Signal:', err.signal);
+            }
+            // Check for common issues
+            if (err.message?.includes('exit')) {
+                console.error('\nPossible causes:');
+                console.error('  1. MCP server failed to start (check npx is available)');
+                console.error('  2. Out of memory (try with smaller codebase or increase Node memory)');
+                console.error('  3. API rate limit exceeded');
+                console.error('\nTry running with --verbose for more details.');
+                console.error('\nTip: For large codebases, try --max-chunks 5000 to limit index size.');
+            }
+            throw err;
+        }
+    }
+    /**
+     * Generate wiki in batched mode for very large codebases.
+     * Processes the codebase in sequential batches to avoid memory issues.
+     */
+    async *generateWikiBatched(options) {
+        const batchSize = options.batchSize || 3000; // Default 3000 chunks per batch
+        // Store options for tool server to access
+        currentGenerationOptions = options;
+        // Phase 1: Clone or access repository
+        yield { type: 'phase', message: 'Preparing repository', progress: 0 };
+        this.repoPath = await this.prepareRepository(options.repoUrl, options.accessToken);
+        this.outputDir = path.resolve(options.outputDir);
+        // Ensure output directory exists
+        if (!fs.existsSync(this.outputDir)) {
+            fs.mkdirSync(this.outputDir, { recursive: true });
+        }
+        // Phase 2: Discover codebase size
+        yield { type: 'phase', message: 'Analyzing codebase size', progress: 5 };
+        const tempRag = new RAGSystem({
+            storePath: path.join(this.outputDir, '.ted-mosby-cache'),
+            repoPath: this.repoPath
+        });
+        const discovery = await tempRag.discoverChunkCount();
+        const totalBatches = Math.ceil(discovery.chunks / batchSize);
+        yield {
+            type: 'step',
+            message: `Found ${discovery.files} files, ${discovery.chunks} chunks → ${totalBatches} batch(es) of ${batchSize}`
+        };
+        // Phase 3: Process batches sequentially
+        for (let batchNum = 0; batchNum < totalBatches; batchNum++) {
+            const batchProgress = 10 + (batchNum / totalBatches) * 60; // 10-70% for batches
+            yield {
+                type: 'phase',
+                message: `Processing batch ${batchNum + 1}/${totalBatches}`,
+                progress: batchProgress
+            };
+            // Create fresh RAG system for this batch (memory isolation)
+            this.ragSystem = new RAGSystem({
+                storePath: path.join(this.outputDir, '.ted-mosby-cache'),
+                repoPath: this.repoPath
+            });
+            // Index this batch
+            const batchInfo = await this.ragSystem.indexBatch(batchNum, batchSize);
+            if (batchInfo.chunksInBatch === 0) {
+                yield { type: 'step', message: `Batch ${batchNum + 1} empty, skipping` };
+                continue;
+            }
+            yield {
+                type: 'step',
+                message: `Batch ${batchNum + 1}: indexed chunks ${batchInfo.batchStart + 1}-${batchInfo.batchEnd}`
+            };
+        }
+        // Phase 4: Finalize the index
+        // For batched mode, we load metadata only (embeddings were generated per batch but not persisted to FAISS)
+        // This uses keyword search which is slower but doesn't require re-generating all embeddings
+        yield { type: 'phase', message: 'Finalizing search index', progress: 70 };
+        this.ragSystem = new RAGSystem({
+            storePath: path.join(this.outputDir, '.ted-mosby-cache'),
+            repoPath: this.repoPath
+        });
+        // Load the accumulated metadata - keyword search will be used since no FAISS index exists
+        await this.ragSystem.loadMetadataOnly();
+        const searchMode = this.ragSystem['index'] ? 'vector search' : 'keyword search';
+        yield { type: 'step', message: `Final index: ${this.ragSystem.getDocumentCount()} chunks loaded (${searchMode})` };
+        // Recreate tool server with finalized RAG system
+        this.customServer = this.createCustomToolServer();
+        // Phase 5: Run agent to generate wiki (single session now that index is ready)
+        yield { type: 'phase', message: 'Generating architectural documentation', progress: 75 };
+        const agentOptions = this.buildAgentOptions(options);
+        const prompt = this.buildGenerationPrompt(options);
+        let wikiComplete = false;
+        let messageCount = 0;
+        try {
+            console.log('[Batched] Starting agent with', this.ragSystem.getDocumentCount(), 'chunks indexed');
+            console.log('[Batched] RAG system status:', {
+                documentCount: this.ragSystem.getDocumentCount(),
+                hasIndex: this.ragSystem['index'] !== null,
+                metadataSize: this.ragSystem['metadata'].size
+            });
+            console.log('[Batched] Agent options:', JSON.stringify({
+                model: agentOptions.model,
+                maxTurns: agentOptions.maxTurns,
+                mcpServers: Object.keys(agentOptions.mcpServers || {}),
+                allowedTools: agentOptions.allowedTools?.length,
+                cwd: agentOptions.cwd,
+                permissionMode: agentOptions.permissionMode
+            }, null, 2));
+            console.log('[Batched] Prompt length:', prompt.length, 'chars');
+            console.log('[Batched] System prompt length:', WIKI_SYSTEM_PROMPT.length, 'chars');
+            const queryResult = query({
+                prompt,
+                options: agentOptions
+            });
+            for await (const message of queryResult) {
+                messageCount++;
+                // Log every message type for debugging
+                const subtype = message.subtype || 'none';
+                console.log(`[Batched] Message ${messageCount}: type=${message.type}, subtype=${subtype}`);
+                if (message.type === 'system' && subtype === 'init') {
+                    this.sessionId = message.session_id;
+                    console.log('[Batched] Agent session started:', this.sessionId);
+                }
+                // Log assistant messages with content preview
+                if (message.type === 'assistant') {
+                    const content = message.message?.content || [];
+                    const textParts = content.filter((c) => c.type === 'text');
+                    const toolUses = content.filter((c) => c.type === 'tool_use');
+                    if (textParts.length > 0) {
+                        const textPreview = textParts[0].text?.slice(0, 200) || '';
+                        console.log('[Batched] Assistant text:', textPreview + (textPreview.length >= 200 ? '...' : ''));
+                    }
+                    if (toolUses.length > 0) {
+                        console.log('[Batched] Tool calls:', toolUses.map((t) => t.name).join(', '));
+                    }
+                    if (content.length === 0) {
+                        console.log('[Batched] Assistant message with empty content');
+                    }
+                }
+                // Log user/tool results
+                if (message.type === 'user') {
+                    const content = message.message?.content || [];
+                    const toolResults = content.filter((c) => c.type === 'tool_result');
+                    if (toolResults.length > 0) {
+                        console.log('[Batched] Tool results:', toolResults.map((t) => `${t.tool_use_id}: ${t.is_error ? 'ERROR' : 'ok'}`).join(', '));
+                    }
+                }
+                // Log system errors
+                if (message.type === 'system' && subtype === 'error') {
+                    console.error('[Batched] Agent error:', JSON.stringify(message, null, 2));
+                }
+                // Log result messages
+                if (message.type === 'result') {
+                    console.log('[Batched] Result:', subtype, JSON.stringify(message).slice(0, 500));
+                    if (subtype === 'success') {
+                        wikiComplete = true;
+                        console.log('[Batched] Agent completed successfully after', messageCount, 'messages');
+                    }
+                }
+                yield message;
+            }
+            if (!wikiComplete) {
+                console.log('[Batched] Warning: Agent finished without success signal after', messageCount, 'messages');
+            }
+            yield { type: 'complete', message: 'Wiki generation complete', progress: 100 };
+        }
+        catch (err) {
+            console.log('[Batched] Agent error after', messageCount, 'messages:', err.message);
+            console.log('[Batched] Error details:', {
+                name: err.name,
+                code: err.code,
+                signal: err.signal,
+                stderr: err.stderr?.slice?.(0, 500),
+                stdout: err.stdout?.slice?.(0, 500)
+            });
+            if (wikiComplete) {
+                console.log('[Batched] Wiki was already complete, treating as success');
+                yield { type: 'complete', message: 'Wiki generation complete', progress: 100 };
+                return;
+            }
+            console.error('Query error:', err.message);
+            if (err.message?.includes('exit')) {
+                console.error('\nThe agent subprocess exited unexpectedly.');
+                console.error('Tips:');
+                console.error('  1. Try running with --verbose for more details');
+                console.error('  2. Try reducing --batch-size (e.g., --batch-size 2000)');
+                console.error('  3. Check if the wiki has partial content in', this.outputDir);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Run only the agent part using an existing cached index.
+     * Useful for debugging agent behavior without re-indexing.
+     */
+    async *generateWikiAgentOnly(options) {
+        currentGenerationOptions = options;
+        // Setup paths
+        yield { type: 'phase', message: 'Loading existing index', progress: 0 };
+        this.repoPath = await this.prepareRepository(options.repoUrl, options.accessToken);
+        this.outputDir = path.resolve(options.outputDir);
+        const cachePath = path.join(this.outputDir, '.ted-mosby-cache');
+        const metadataPath = path.join(cachePath, 'metadata.json');
+        if (!fs.existsSync(metadataPath)) {
+            throw new Error(`No cached index found at ${cachePath}. Run without --skip-index first to build the index.`);
+        }
+        // Ensure output directory exists
+        if (!fs.existsSync(this.outputDir)) {
+            fs.mkdirSync(this.outputDir, { recursive: true });
+        }
+        // Load existing RAG index
+        this.ragSystem = new RAGSystem({
+            storePath: cachePath,
+            repoPath: this.repoPath
+        });
+        await this.ragSystem.loadMetadataOnly();
+        const searchMode = this.ragSystem['index'] ? 'vector search' : 'keyword search';
+        yield {
+            type: 'step',
+            message: `Loaded ${this.ragSystem.getDocumentCount()} chunks (${searchMode})`
+        };
+        // Recreate tool server with RAG system
+        this.customServer = this.createCustomToolServer();
+        // Run the agent
+        yield { type: 'phase', message: 'Running agent (debug mode)', progress: 50 };
+        const agentOptions = this.buildAgentOptions(options);
+        const prompt = this.buildGenerationPrompt(options);
+        // Enhanced debug output
+        console.log('\n' + '='.repeat(60));
+        console.log('[AgentOnly] DEBUG MODE - Detailed Agent Execution');
+        console.log('='.repeat(60));
+        console.log('[AgentOnly] Repository:', this.repoPath);
+        console.log('[AgentOnly] Output:', this.outputDir);
+        console.log('[AgentOnly] Chunks loaded:', this.ragSystem.getDocumentCount());
+        console.log('[AgentOnly] Search mode:', searchMode);
+        console.log('[AgentOnly] Model:', agentOptions.model);
+        console.log('[AgentOnly] Max turns:', agentOptions.maxTurns);
+        console.log('[AgentOnly] Permission mode:', agentOptions.permissionMode);
+        console.log('[AgentOnly] CWD:', agentOptions.cwd);
+        console.log('[AgentOnly] MCP servers:', Object.keys(agentOptions.mcpServers || {}));
+        console.log('[AgentOnly] Allowed tools count:', agentOptions.allowedTools?.length);
+        console.log('[AgentOnly] Allowed tools:', agentOptions.allowedTools);
+        console.log('[AgentOnly] System prompt length:', WIKI_SYSTEM_PROMPT.length, 'chars');
+        console.log('[AgentOnly] User prompt length:', prompt.length, 'chars');
+        console.log('[AgentOnly] User prompt preview:', prompt.slice(0, 500));
+        console.log('='.repeat(60) + '\n');
+        let wikiComplete = false;
+        let messageCount = 0;
+        let toolCallCount = 0;
+        try {
+            console.log('[AgentOnly] Calling query()...');
+            const queryResult = query({
+                prompt,
+                options: agentOptions
+            });
+            console.log('[AgentOnly] Got queryResult, starting iteration...');
+            for await (const message of queryResult) {
+                messageCount++;
+                const subtype = message.subtype || 'none';
+                const timestamp = new Date().toISOString().split('T')[1];
+                console.log(`\n[AgentOnly] === Message ${messageCount} ===`);
+                console.log(`[AgentOnly] Time: ${timestamp}`);
+                console.log(`[AgentOnly] Type: ${message.type}`);
+                console.log(`[AgentOnly] Subtype: ${subtype}`);
+                // System messages
+                if (message.type === 'system') {
+                    if (subtype === 'init') {
+                        this.sessionId = message.session_id;
+                        console.log(`[AgentOnly] Session ID: ${this.sessionId}`);
+                        console.log(`[AgentOnly] Tools available: ${message.tools?.length || 'unknown'}`);
+                    }
+                    else if (subtype === 'error') {
+                        console.error('[AgentOnly] SYSTEM ERROR:');
+                        console.error(JSON.stringify(message, null, 2));
+                    }
+                    else {
+                        console.log(`[AgentOnly] System message:`, JSON.stringify(message, null, 2).slice(0, 500));
+                    }
+                }
+                // Assistant messages
+                if (message.type === 'assistant') {
+                    const content = message.message?.content || [];
+                    console.log(`[AgentOnly] Content blocks: ${content.length}`);
+                    for (const block of content) {
+                        if (block.type === 'text') {
+                            console.log(`[AgentOnly] TEXT (${block.text?.length || 0} chars):`);
+                            console.log(block.text?.slice(0, 300) + (block.text?.length > 300 ? '...' : ''));
+                        }
+                        else if (block.type === 'tool_use') {
+                            toolCallCount++;
+                            console.log(`[AgentOnly] TOOL_USE #${toolCallCount}:`);
+                            console.log(`  Name: ${block.name}`);
+                            console.log(`  ID: ${block.id}`);
+                            console.log(`  Input: ${JSON.stringify(block.input).slice(0, 200)}`);
+                        }
+                        else {
+                            console.log(`[AgentOnly] Block type: ${block.type}`);
+                        }
+                    }
+                    if (content.length === 0) {
+                        console.log('[AgentOnly] WARNING: Assistant message with no content!');
+                        console.log('[AgentOnly] Full message:', JSON.stringify(message, null, 2));
+                    }
+                }
+                // User messages (tool results)
+                if (message.type === 'user') {
+                    const content = message.message?.content || [];
+                    const toolResults = content.filter((c) => c.type === 'tool_result');
+                    console.log(`[AgentOnly] Tool results: ${toolResults.length}`);
+                    for (const tr of toolResults) {
+                        const resultPreview = typeof tr.content === 'string'
+                            ? tr.content.slice(0, 200)
+                            : JSON.stringify(tr.content).slice(0, 200);
+                        console.log(`  ${tr.tool_use_id}: ${tr.is_error ? 'ERROR' : 'ok'} - ${resultPreview}`);
+                    }
+                }
+                // Result messages
+                if (message.type === 'result') {
+                    console.log(`[AgentOnly] RESULT: ${subtype}`);
+                    console.log(`[AgentOnly] Full result:`, JSON.stringify(message, null, 2).slice(0, 1000));
+                    if (subtype === 'success') {
+                        wikiComplete = true;
+                    }
+                }
+                yield message;
+            }
+            console.log('\n' + '='.repeat(60));
+            console.log('[AgentOnly] AGENT FINISHED');
+            console.log(`[AgentOnly] Total messages: ${messageCount}`);
+            console.log(`[AgentOnly] Total tool calls: ${toolCallCount}`);
+            console.log(`[AgentOnly] Wiki complete: ${wikiComplete}`);
+            console.log('='.repeat(60) + '\n');
+            if (!wikiComplete) {
+                console.log('[AgentOnly] WARNING: Agent finished without success signal!');
+            }
+            if (toolCallCount === 0) {
+                console.log('[AgentOnly] WARNING: No tool calls were made! The agent may not have access to tools.');
+            }
+            yield { type: 'complete', message: 'Agent-only run complete', progress: 100 };
+        }
+        catch (err) {
+            console.log('\n' + '='.repeat(60));
+            console.log('[AgentOnly] AGENT ERROR');
+            console.log(`[AgentOnly] Messages before error: ${messageCount}`);
+            console.log(`[AgentOnly] Tool calls before error: ${toolCallCount}`);
+            console.log('[AgentOnly] Error:', err.message);
+            console.log('[AgentOnly] Error name:', err.name);
+            console.log('[AgentOnly] Error code:', err.code);
+            console.log('[AgentOnly] Error signal:', err.signal);
+            if (err.stderr)
+                console.log('[AgentOnly] Stderr:', err.stderr.slice(0, 1000));
+            if (err.stdout)
+                console.log('[AgentOnly] Stdout:', err.stdout.slice(0, 1000));
+            if (err.stack)
+                console.log('[AgentOnly] Stack:', err.stack);
+            console.log('='.repeat(60) + '\n');
+            if (wikiComplete) {
+                console.log('[AgentOnly] Wiki was complete before error, treating as success');
+                yield { type: 'complete', message: 'Agent-only run complete (with cleanup error)', progress: 100 };
+                return;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Generate wiki using Anthropic API directly (bypasses Claude Code billing check).
+     * This method handles tool calls manually and uses your ANTHROPIC_API_KEY credits.
+     */
+    async *generateWikiDirectApi(options) {
+        currentGenerationOptions = options;
+        // Phase 1: Prepare repository
+        yield { type: 'phase', message: 'Preparing repository', progress: 0 };
+        this.repoPath = await this.prepareRepository(options.repoUrl, options.accessToken);
+        this.outputDir = path.resolve(options.outputDir);
+        if (!fs.existsSync(this.outputDir)) {
+            fs.mkdirSync(this.outputDir, { recursive: true });
+        }
+        // Phase 2: Index codebase (or load existing)
+        const cachePath = path.join(this.outputDir, '.ted-mosby-cache');
+        const metadataPath = path.join(cachePath, 'metadata.json');
+        if (options.skipIndex && fs.existsSync(metadataPath)) {
+            yield { type: 'phase', message: 'Loading existing index', progress: 10 };
+            this.ragSystem = new RAGSystem({
+                storePath: cachePath,
+                repoPath: this.repoPath
+            });
+            await this.ragSystem.loadMetadataOnly();
+        }
+        else {
+            yield { type: 'phase', message: 'Indexing codebase', progress: 10 };
+            this.ragSystem = new RAGSystem({
+                storePath: cachePath,
+                repoPath: this.repoPath,
+                maxChunks: options.maxChunks
+            });
+            await this.ragSystem.indexRepository();
+        }
+        const searchMode = this.ragSystem['index'] ? 'vector search' : 'keyword search';
+        yield { type: 'step', message: `Loaded ${this.ragSystem.getDocumentCount()} chunks (${searchMode})` };
+        // Phase 3: Run direct API agent
+        yield { type: 'phase', message: 'Generating wiki (Direct API mode)', progress: 20 };
+        const client = new Anthropic();
+        const model = options.model || 'claude-sonnet-4-20250514';
+        const maxTurns = options.maxTurns || 200;
+        const prompt = this.buildGenerationPrompt(options);
+        // Define tools for the API
+        const tools = this.buildDirectApiTools();
+        console.log('\n' + '='.repeat(60));
+        console.log('[DirectAPI] Starting direct API mode');
+        console.log('[DirectAPI] Model:', model);
+        console.log('[DirectAPI] Max turns:', maxTurns);
+        console.log('[DirectAPI] Tools:', tools.length);
+        console.log('[DirectAPI] Repository:', this.repoPath);
+        console.log('[DirectAPI] Output:', this.outputDir);
+        console.log('[DirectAPI] Chunks:', this.ragSystem.getDocumentCount());
+        console.log('='.repeat(60) + '\n');
+        // Build initial messages
+        const messages = [
+            { role: 'user', content: prompt }
+        ];
+        let turnCount = 0;
+        let totalToolCalls = 0;
+        let done = false;
+        try {
+            while (!done && turnCount < maxTurns) {
+                turnCount++;
+                const progress = 20 + Math.min(70, (turnCount / maxTurns) * 70);
+                yield { type: 'step', message: `Turn ${turnCount}/${maxTurns}`, progress };
+                if (options.verbose) {
+                    console.log(`\n[DirectAPI] === Turn ${turnCount} ===`);
+                }
+                // Call the API
+                const response = await client.messages.create({
+                    model,
+                    max_tokens: 8192,
+                    system: WIKI_SYSTEM_PROMPT,
+                    tools,
+                    messages
+                });
+                if (options.verbose) {
+                    console.log(`[DirectAPI] Stop reason: ${response.stop_reason}`);
+                    console.log(`[DirectAPI] Usage: input=${response.usage.input_tokens}, output=${response.usage.output_tokens}`);
+                }
+                // Process response content
+                const assistantContent = [];
+                const toolResults = [];
+                for (const block of response.content) {
+                    assistantContent.push(block);
+                    if (block.type === 'text') {
+                        if (options.verbose) {
+                            console.log(`[DirectAPI] Text: ${block.text.slice(0, 200)}${block.text.length > 200 ? '...' : ''}`);
+                        }
+                        yield { type: 'assistant', content: block.text };
+                    }
+                    else if (block.type === 'tool_use') {
+                        totalToolCalls++;
+                        if (options.verbose) {
+                            console.log(`[DirectAPI] Tool call #${totalToolCalls}: ${block.name}`);
+                            console.log(`[DirectAPI] Input: ${JSON.stringify(block.input).slice(0, 200)}`);
+                        }
+                        // Execute the tool
+                        const result = await this.executeDirectApiTool(block.name, block.input);
+                        if (options.verbose) {
+                            console.log(`[DirectAPI] Result: ${result.slice(0, 200)}${result.length > 200 ? '...' : ''}`);
+                        }
+                        toolResults.push({
+                            type: 'tool_result',
+                            tool_use_id: block.id,
+                            content: result
+                        });
+                    }
+                }
+                // Add assistant message
+                messages.push({ role: 'assistant', content: assistantContent });
+                // If there were tool uses, add results and continue
+                if (toolResults.length > 0) {
+                    messages.push({ role: 'user', content: toolResults });
+                }
+                // Check if we're done
+                if (response.stop_reason === 'end_turn' && toolResults.length === 0) {
+                    done = true;
+                    console.log(`[DirectAPI] Agent finished naturally after ${turnCount} turns`);
+                }
+                else if (response.stop_reason === 'max_tokens') {
+                    console.log(`[DirectAPI] Warning: Hit max_tokens, continuing...`);
+                }
+            }
+            if (!done && turnCount >= maxTurns) {
+                console.log(`[DirectAPI] Warning: Reached max turns (${maxTurns})`);
+                yield { type: 'error', message: `Reached maximum turns (${maxTurns})` };
+            }
+            console.log('\n' + '='.repeat(60));
+            console.log('[DirectAPI] Initial generation complete');
+            console.log(`[DirectAPI] Total turns: ${turnCount}`);
+            console.log(`[DirectAPI] Total tool calls: ${totalToolCalls}`);
+            console.log('='.repeat(60) + '\n');
+            // Phase 4: Verification loop - keep generating until all links are valid
+            yield { type: 'phase', message: 'Verifying wiki completeness', progress: 90 };
+            let verificationAttempts = 0;
+            const maxVerificationAttempts = 5; // Prevent infinite loops
+            while (verificationAttempts < maxVerificationAttempts) {
+                verificationAttempts++;
+                const verification = await this.verifyWikiCompleteness(this.outputDir);
+                console.log(`[DirectAPI] Verification #${verificationAttempts}: ${verification.totalPages} pages, ${verification.brokenLinks.length} broken links`);
+                if (verification.isComplete) {
+                    console.log('[DirectAPI] Wiki is complete! All links are valid.');
+                    break;
+                }
+                yield {
+                    type: 'step',
+                    message: `Found ${verification.brokenLinks.length} broken links, generating missing pages...`,
+                    progress: 90 + verificationAttempts
+                };
+                // Get unique missing pages
+                const missingPages = [...new Set(verification.brokenLinks.map(l => l.target))];
+                console.log(`[DirectAPI] Missing pages: ${missingPages.join(', ')}`);
+                // Generate missing pages
+                const continuationPrompt = `Continue generating wiki pages. The following pages are referenced but do not exist:
+
+${missingPages.map(p => `- ${p}`).join('\n')}
+
+For EACH missing page:
+1. Use search_codebase to find relevant code for that topic
+2. Use read_file to read the specific source files
+3. Use write_wiki_page to create the page with proper source traceability
+
+Remember: Every architectural concept MUST include file:line references to the source code.
+Create all ${missingPages.length} missing pages now.`;
+                // Reset for continuation
+                const continuationMessages = [
+                    { role: 'user', content: continuationPrompt }
+                ];
+                let continuationTurns = 0;
+                const maxContinuationTurns = Math.min(50, maxTurns - turnCount); // Don't exceed remaining turns
+                while (continuationTurns < maxContinuationTurns) {
+                    continuationTurns++;
+                    turnCount++;
+                    const response = await client.messages.create({
+                        model,
+                        max_tokens: 8192,
+                        system: WIKI_SYSTEM_PROMPT,
+                        tools,
+                        messages: continuationMessages
+                    });
+                    if (options.verbose) {
+                        console.log(`[DirectAPI] Continuation turn ${continuationTurns}: ${response.stop_reason}`);
+                    }
+                    const assistantContent = [];
+                    const toolResults = [];
+                    for (const block of response.content) {
+                        assistantContent.push(block);
+                        if (block.type === 'tool_use') {
+                            totalToolCalls++;
+                            const result = await this.executeDirectApiTool(block.name, block.input);
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: block.id,
+                                content: result
+                            });
+                            if (options.verbose) {
+                                console.log(`[DirectAPI] Tool: ${block.name}`);
+                            }
+                        }
+                    }
+                    continuationMessages.push({ role: 'assistant', content: assistantContent });
+                    if (toolResults.length > 0) {
+                        continuationMessages.push({ role: 'user', content: toolResults });
+                    }
+                    if (response.stop_reason === 'end_turn' && toolResults.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if (verificationAttempts >= maxVerificationAttempts) {
+                console.log(`[DirectAPI] Warning: Max verification attempts (${maxVerificationAttempts}) reached`);
+                const finalCheck = await this.verifyWikiCompleteness(this.outputDir);
+                if (!finalCheck.isComplete) {
+                    console.log(`[DirectAPI] ${finalCheck.brokenLinks.length} broken links remain`);
+                    yield { type: 'step', message: `Warning: ${finalCheck.brokenLinks.length} broken links remain`, progress: 95 };
+                }
+            }
+            console.log('\n' + '='.repeat(60));
+            console.log('[DirectAPI] GENERATION COMPLETE');
+            console.log(`[DirectAPI] Total turns: ${turnCount}`);
+            console.log(`[DirectAPI] Total tool calls: ${totalToolCalls}`);
+            console.log('='.repeat(60) + '\n');
+            yield { type: 'complete', message: 'Wiki generation complete (Direct API)', progress: 100 };
+        }
+        catch (err) {
+            console.error('[DirectAPI] Error:', err.message);
+            if (options.verbose) {
+                console.error('[DirectAPI] Full error:', err);
+            }
+            yield { type: 'error', message: err.message };
             throw err;
         }
     }
+    /**
+     * Build tool definitions for direct API calls
+     */
+    buildDirectApiTools() {
+        return [
+            // Filesystem tools
+            {
+                name: 'read_file',
+                description: 'Read the contents of a file from the repository',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file relative to repository root' }
+                    },
+                    required: ['path']
+                }
+            },
+            {
+                name: 'list_directory',
+                description: 'List files and directories in a path',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the directory relative to repository root' }
+                    },
+                    required: ['path']
+                }
+            },
+            {
+                name: 'directory_tree',
+                description: 'Get a tree view of the directory structure',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the directory relative to repository root' },
+                        depth: { type: 'number', description: 'Maximum depth to traverse (default 3)' }
+                    },
+                    required: ['path']
+                }
+            },
+            // RAG/Wiki tools
+            {
+                name: 'search_codebase',
+                description: 'Semantic search over the codebase using embeddings. Returns relevant code snippets with file paths and line numbers.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Natural language search query' },
+                        maxResults: { type: 'number', description: 'Maximum results (default 10)' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'write_wiki_page',
+                description: 'Write a wiki documentation page to the output directory',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        pagePath: { type: 'string', description: 'Path relative to wiki root (e.g., "architecture/overview.md")' },
+                        title: { type: 'string', description: 'Page title' },
+                        content: { type: 'string', description: 'Full markdown content (excluding H1 title)' },
+                        description: { type: 'string', description: 'Brief page description' },
+                        sources: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Source files referenced'
+                        }
+                    },
+                    required: ['pagePath', 'title', 'content']
+                }
+            },
+            {
+                name: 'analyze_code_structure',
+                description: 'Analyze a code file to extract functions, classes, imports, and exports',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        filePath: { type: 'string', description: 'Path to the file to analyze' }
+                    },
+                    required: ['filePath']
+                }
+            },
+            {
+                name: 'verify_wiki_completeness',
+                description: 'Check for broken internal links in the wiki. Returns missing pages that need to be created.',
+                input_schema: {
+                    type: 'object',
+                    properties: {}
+                }
+            },
+            {
+                name: 'list_wiki_pages',
+                description: 'List all wiki pages that have been created',
+                input_schema: {
+                    type: 'object',
+                    properties: {}
+                }
+            }
+        ];
+    }
+    /**
+     * Execute a tool call for direct API mode
+     */
+    async executeDirectApiTool(name, input) {
+        try {
+            switch (name) {
+                case 'read_file': {
+                    const filePath = path.join(this.repoPath, input.path);
+                    if (!fs.existsSync(filePath)) {
+                        return `Error: File not found: ${input.path}`;
+                    }
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    return content;
+                }
+                case 'list_directory': {
+                    const dirPath = path.join(this.repoPath, input.path || '');
+                    if (!fs.existsSync(dirPath)) {
+                        return `Error: Directory not found: ${input.path}`;
+                    }
+                    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                    const result = entries.map(e => {
+                        const type = e.isDirectory() ? '[DIR]' : '[FILE]';
+                        return `${type} ${e.name}`;
+                    }).join('\n');
+                    return result;
+                }
+                case 'directory_tree': {
+                    const dirPath = path.join(this.repoPath, input.path || '');
+                    const maxDepth = input.depth || 3;
+                    const tree = this.buildDirectoryTree(dirPath, maxDepth, 0);
+                    return tree;
+                }
+                case 'search_codebase': {
+                    if (!this.ragSystem) {
+                        return 'Error: RAG system not initialized';
+                    }
+                    const maxResults = input.maxResults || 10;
+                    const results = await this.ragSystem.search(input.query, { maxResults });
+                    if (results.length === 0) {
+                        return 'No relevant code found for this query.';
+                    }
+                    const formatted = results.map((r, i) => `### Result ${i + 1} (score: ${r.score.toFixed(3)})\n` +
+                        `**Source:** \`${r.filePath}:${r.startLine}-${r.endLine}\`\n\n` +
+                        '```' + (r.language || '') + '\n' + r.content + '\n```').join('\n\n');
+                    return `Found ${results.length} relevant code snippets:\n\n${formatted}`;
+                }
+                case 'write_wiki_page': {
+                    const fullPath = path.join(this.outputDir, input.pagePath);
+                    const dir = path.dirname(fullPath);
+                    if (!fs.existsSync(dir)) {
+                        fs.mkdirSync(dir, { recursive: true });
+                    }
+                    const frontmatterData = {
+                        title: input.title,
+                        generated: new Date().toISOString(),
+                        description: input.description,
+                        sources: input.sources
+                    };
+                    const fullContent = matter.stringify(`# ${input.title}\n\n${input.content}`, frontmatterData);
+                    fs.writeFileSync(fullPath, fullContent, 'utf-8');
+                    return `Successfully wrote wiki page: ${input.pagePath}`;
+                }
+                case 'analyze_code_structure': {
+                    const filePath = path.join(this.repoPath, input.filePath);
+                    if (!fs.existsSync(filePath)) {
+                        return `Error: File not found: ${input.filePath}`;
+                    }
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const lines = content.split('\n');
+                    const ext = path.extname(input.filePath);
+                    const analysis = {
+                        functions: [],
+                        classes: [],
+                        imports: [],
+                        exports: []
+                    };
+                    if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+                        lines.forEach((line, idx) => {
+                            const lineNum = idx + 1;
+                            const funcMatch = line.match(/(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+                            if (funcMatch)
+                                analysis.functions.push({ name: funcMatch[1], line: lineNum });
+                            const classMatch = line.match(/(?:export\s+)?class\s+(\w+)/);
+                            if (classMatch)
+                                analysis.classes.push({ name: classMatch[1], line: lineNum });
+                            const importMatch = line.match(/import\s+.*\s+from\s+['"]([^'"]+)['"]/);
+                            if (importMatch)
+                                analysis.imports.push({ module: importMatch[1], line: lineNum });
+                            const exportMatch = line.match(/export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type)\s+(\w+)/);
+                            if (exportMatch)
+                                analysis.exports.push({ name: exportMatch[1], line: lineNum });
+                        });
+                    }
+                    let output = `# Code Analysis: ${input.filePath}\n`;
+                    output += `Lines: ${lines.length}\n\n`;
+                    output += `Functions (${analysis.functions.length}): ${analysis.functions.map(f => `${f.name}:${f.line}`).join(', ')}\n`;
+                    output += `Classes (${analysis.classes.length}): ${analysis.classes.map(c => `${c.name}:${c.line}`).join(', ')}\n`;
+                    output += `Imports (${analysis.imports.length}): ${analysis.imports.map(i => i.module).join(', ')}\n`;
+                    output += `Exports (${analysis.exports.length}): ${analysis.exports.map(e => e.name).join(', ')}`;
+                    return output;
+                }
+                case 'verify_wiki_completeness': {
+                    const result = await this.verifyWikiCompleteness(this.outputDir);
+                    let response = `# Wiki Completeness Report\n\n`;
+                    response += `Total pages: ${result.totalPages}\n`;
+                    response += `Missing pages: ${result.missingPages.length}\n`;
+                    response += `Broken links: ${result.brokenLinks.length}\n\n`;
+                    if (result.isComplete) {
+                        response += '✅ All internal links are valid! The wiki is complete.';
+                    }
+                    else {
+                        response += '❌ Missing Pages (MUST CREATE):\n\n';
+                        for (const link of result.brokenLinks) {
+                            response += `- ${link.target} (referenced from ${link.source})\n`;
+                        }
+                    }
+                    return response;
+                }
+                case 'list_wiki_pages': {
+                    const wikiFiles = this.findAllWikiFiles(this.outputDir);
+                    const pages = wikiFiles.map(f => {
+                        const relativePath = path.relative(this.outputDir, f).replace(/\\/g, '/');
+                        return relativePath;
+                    });
+                    return `Wiki Pages (${pages.length} total):\n${pages.sort().map(p => `- ${p}`).join('\n')}`;
+                }
+                default:
+                    return `Error: Unknown tool: ${name}`;
+            }
+        }
+        catch (error) {
+            return `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /**
+     * Build a directory tree string
+     */
+    buildDirectoryTree(dirPath, maxDepth, currentDepth, prefix = '') {
+        if (currentDepth >= maxDepth || !fs.existsSync(dirPath)) {
+            return '';
+        }
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+            .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules');
+        let result = '';
+        entries.forEach((entry, index) => {
+            const isLast = index === entries.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            result += `${prefix}${connector}${entry.name}\n`;
+            if (entry.isDirectory()) {
+                const childPath = path.join(dirPath, entry.name);
+                result += this.buildDirectoryTree(childPath, maxDepth, currentDepth + 1, prefix + childPrefix);
+            }
+        });
+        return result;
+    }
     /**
      * Estimate generation time and cost without making API calls
      */
@@ -238,9 +1131,11 @@ export class ArchitecturalWikiAgent {
                 // Custom tedmosby tools
                 'mcp__tedmosby__search_codebase',
                 'mcp__tedmosby__write_wiki_page',
-                'mcp__tedmosby__analyze_code_structure'
+                'mcp__tedmosby__analyze_code_structure',
+                'mcp__tedmosby__verify_wiki_completeness',
+                'mcp__tedmosby__list_wiki_pages'
             ],
-            maxTurns: 200,
+            maxTurns: wikiOptions.maxTurns || 200,
             permissionMode: 'acceptEdits',
             includePartialMessages: true,
             // Capture stderr from Claude Code subprocess
@@ -256,6 +1151,33 @@ export class ArchitecturalWikiAgent {
         const configNote = options.configPath && fs.existsSync(options.configPath)
             ? `\n\nConfiguration file provided at: ${options.configPath}\nPlease read it first to understand the wiki structure requirements.`
             : '';
+        // Continuation mode - only generate missing pages
+        if (options.missingPages && options.missingPages.length > 0) {
+            const missingList = options.missingPages.map(p => `- ${p}`).join('\n');
+            return `Continue generating the architectural documentation wiki. Some pages are missing and need to be created.
+
+**Repository:** ${options.repoUrl}
+**Output Directory:** ${this.outputDir}
+
+## Missing Pages That MUST Be Created
+
+The following wiki pages are referenced but do not exist. You MUST create each of these:
+
+${missingList}
+
+## Instructions
+
+1. First, use \`mcp__tedmosby__list_wiki_pages\` to see what pages already exist
+2. For each missing page above:
+   - Use \`mcp__tedmosby__search_codebase\` to find relevant code for that topic
+   - Use \`mcp__filesystem__read_file\` to read the specific source files
+   - Use \`mcp__tedmosby__write_wiki_page\` to create the page with proper source traceability
+3. After creating all pages, use \`mcp__tedmosby__verify_wiki_completeness\` to confirm all links are valid
+
+Remember: Every architectural concept MUST include file:line references to the source code.
+Do NOT modify existing pages unless they have broken internal links that need fixing.`;
+        }
+        // Full generation mode
         return `Generate a comprehensive architectural documentation wiki for this repository.
 
 **Repository:** ${options.repoUrl}
@@ -269,6 +1191,11 @@ Begin by:
 3. Planning the wiki structure
 4. Generating documentation with source code traceability
 
+**IMPORTANT:** After generating all pages, you MUST:
+5. Use \`mcp__tedmosby__verify_wiki_completeness\` to check for broken links
+6. If any pages are missing, create them immediately
+7. Repeat verification until all links are valid
+
 Remember: Every architectural concept MUST include file:line references to the source code.`;
     }
     /**
@@ -277,9 +1204,11 @@ Remember: Every architectural concept MUST include file:line references to the s
     createCustomToolServer() {
         const tools = [];
         // Tool 1: search_codebase - RAG-powered semantic search
+        // Get configured max results (default 10, can be limited for large codebases)
+        const configuredMaxResults = currentGenerationOptions?.maxSearchResults || 10;
         tools.push(tool('search_codebase', 'Semantic search over the codebase using embeddings. Returns relevant code snippets with file paths and line numbers. Use this to find code related to architectural concepts you are documenting.', {
             query: z.string().describe('Natural language search query (e.g., "authentication handling", "database connection")'),
-            maxResults: z.number().min(1).max(20).optional().default(10).describe('Maximum number of results to return'),
+            maxResults: z.number().min(1).max(20).optional().default(configuredMaxResults).describe('Maximum number of results to return'),
             fileTypes: z.array(z.string()).optional().describe('Filter by file extensions (e.g., [".ts", ".js"])'),
             excludeTests: z.boolean().optional().default(true).describe('Exclude test files from results')
         }, async (args) => {
@@ -292,8 +1221,10 @@ Remember: Every architectural concept MUST include file:line references to the s
                 };
             }
             try {
+                // Apply configured limit
+                const effectiveMaxResults = Math.min(args.maxResults || configuredMaxResults, configuredMaxResults);
                 const results = await this.ragSystem.search(args.query, {
-                    maxResults: args.maxResults || 10,
+                    maxResults: effectiveMaxResults,
                     fileTypes: args.fileTypes,
                     excludeTests: args.excludeTests ?? true
                 });
@@ -542,11 +1473,206 @@ Remember: Every architectural concept MUST include file:line references to the s
                 };
             }
         }));
+        // Tool 4: verify_wiki_completeness - Check for broken internal links and missing pages
+        tools.push(tool('verify_wiki_completeness', 'Verify that all internal links in the wiki resolve to actual pages. Returns a list of missing pages that need to be created. ALWAYS run this after generating wiki pages to ensure completeness.', {
+            fixBrokenLinks: z.boolean().optional().default(false).describe('If true, returns suggested content for missing pages')
+        }, async (args) => {
+            try {
+                const wikiFiles = this.findAllWikiFiles(this.outputDir);
+                const existingPages = new Set(wikiFiles.map(f => path.relative(this.outputDir, f).replace(/\\/g, '/')));
+                const brokenLinks = [];
+                const allReferencedPages = new Set();
+                // Scan all wiki files for internal links
+                for (const file of wikiFiles) {
+                    const content = fs.readFileSync(file, 'utf-8');
+                    const relativePath = path.relative(this.outputDir, file).replace(/\\/g, '/');
+                    const fileDir = path.dirname(file);
+                    // Find all markdown links
+                    const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+                    let match;
+                    while ((match = linkRegex.exec(content)) !== null) {
+                        const linkText = match[1];
+                        const linkPath = match[2];
+                        // Skip external links, anchors, and source code references
+                        if (linkPath.startsWith('http://') ||
+                            linkPath.startsWith('https://') ||
+                            linkPath.startsWith('#') ||
+                            linkPath.includes('github.com') ||
+                            linkPath.match(/\.(ts|js|py|go|rs|java|tsx|jsx)[:L#]/)) {
+                            continue;
+                        }
+                        // Resolve internal markdown links
+                        if (linkPath.endsWith('.md') || linkPath.includes('.md#')) {
+                            const cleanPath = linkPath.split('#')[0];
+                            const resolvedPath = path.resolve(fileDir, cleanPath);
+                            const relativeResolved = path.relative(this.outputDir, resolvedPath).replace(/\\/g, '/');
+                            allReferencedPages.add(relativeResolved);
+                            if (!fs.existsSync(resolvedPath)) {
+                                brokenLinks.push({
+                                    sourcePage: relativePath,
+                                    targetLink: cleanPath,
+                                    linkText
+                                });
+                            }
+                        }
+                    }
+                }
+                // Find missing pages (referenced but not created)
+                const missingPages = [...allReferencedPages].filter(p => !existingPages.has(p));
+                // Build response
+                let response = `# Wiki Completeness Report\n\n`;
+                response += `**Total pages:** ${existingPages.size}\n`;
+                response += `**Referenced pages:** ${allReferencedPages.size}\n`;
+                response += `**Missing pages:** ${missingPages.length}\n`;
+                response += `**Broken links:** ${brokenLinks.length}\n\n`;
+                if (brokenLinks.length === 0) {
+                    response += `✅ **All internal links are valid!** The wiki is complete.\n`;
+                }
+                else {
+                    response += `## ❌ Missing Pages (MUST CREATE)\n\n`;
+                    response += `The following pages are referenced but do not exist. You MUST create these pages:\n\n`;
+                    // Group by missing page
+                    const byMissingPage = new Map();
+                    for (const link of brokenLinks) {
+                        const key = link.targetLink;
+                        if (!byMissingPage.has(key)) {
+                            byMissingPage.set(key, []);
+                        }
+                        byMissingPage.get(key).push({ source: link.sourcePage, text: link.linkText });
+                    }
+                    for (const [missingPage, references] of byMissingPage) {
+                        response += `### ${missingPage}\n`;
+                        response += `Referenced by:\n`;
+                        for (const ref of references) {
+                            response += `- \`${ref.source}\` (link text: "${ref.text}")\n`;
+                        }
+                        response += `\n`;
+                    }
+                    response += `\n## Action Required\n\n`;
+                    response += `Use \`mcp__tedmosby__write_wiki_page\` to create each missing page above.\n`;
+                    response += `After creating all pages, run \`mcp__tedmosby__verify_wiki_completeness\` again to confirm.\n`;
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: response
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Verification error: ${error instanceof Error ? error.message : String(error)}`
+                        }]
+                };
+            }
+        }));
+        // Tool 5: list_wiki_pages - List all created wiki pages
+        tools.push(tool('list_wiki_pages', 'List all wiki pages that have been created in the output directory.', {}, async () => {
+            try {
+                const wikiFiles = this.findAllWikiFiles(this.outputDir);
+                const pages = wikiFiles.map(f => {
+                    const relativePath = path.relative(this.outputDir, f).replace(/\\/g, '/');
+                    const content = fs.readFileSync(f, 'utf-8');
+                    const titleMatch = content.match(/^#\s+(.+)$/m);
+                    return {
+                        path: relativePath,
+                        title: titleMatch ? titleMatch[1] : path.basename(f, '.md')
+                    };
+                });
+                let response = `# Wiki Pages (${pages.length} total)\n\n`;
+                for (const page of pages.sort((a, b) => a.path.localeCompare(b.path))) {
+                    response += `- \`${page.path}\` - ${page.title}\n`;
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: response
+                        }]
+                };
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error listing pages: ${error instanceof Error ? error.message : String(error)}`
+                        }]
+                };
+            }
+        }));
         return createSdkMcpServer({
             name: 'tedmosby',
             version: '1.0.0',
             tools
         });
     }
+    /**
+     * Find all markdown files in a directory recursively
+     */
+    findAllWikiFiles(dir) {
+        const files = [];
+        if (!fs.existsSync(dir)) {
+            return files;
+        }
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                files.push(...this.findAllWikiFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    /**
+     * Verify wiki completeness and return missing pages
+     */
+    async verifyWikiCompleteness(wikiDir) {
+        const wikiFiles = this.findAllWikiFiles(wikiDir);
+        const existingPages = new Set(wikiFiles.map(f => path.relative(wikiDir, f).replace(/\\/g, '/')));
+        const brokenLinks = [];
+        const allReferencedPages = new Set();
+        for (const file of wikiFiles) {
+            const content = fs.readFileSync(file, 'utf-8');
+            const relativePath = path.relative(wikiDir, file).replace(/\\/g, '/');
+            const fileDir = path.dirname(file);
+            const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+            let match;
+            while ((match = linkRegex.exec(content)) !== null) {
+                const linkText = match[1];
+                const linkPath = match[2];
+                if (linkPath.startsWith('http://') ||
+                    linkPath.startsWith('https://') ||
+                    linkPath.startsWith('#') ||
+                    linkPath.includes('github.com') ||
+                    linkPath.match(/\.(ts|js|py|go|rs|java|tsx|jsx)[:L#]/)) {
+                    continue;
+                }
+                if (linkPath.endsWith('.md') || linkPath.includes('.md#')) {
+                    const cleanPath = linkPath.split('#')[0];
+                    const resolvedPath = path.resolve(fileDir, cleanPath);
+                    const relativeResolved = path.relative(wikiDir, resolvedPath).replace(/\\/g, '/');
+                    allReferencedPages.add(relativeResolved);
+                    if (!fs.existsSync(resolvedPath)) {
+                        brokenLinks.push({
+                            source: relativePath,
+                            target: cleanPath,
+                            linkText
+                        });
+                    }
+                }
+            }
+        }
+        const missingPages = [...allReferencedPages].filter(p => !existingPages.has(p));
+        return {
+            totalPages: existingPages.size,
+            brokenLinks,
+            missingPages,
+            isComplete: brokenLinks.length === 0
+        };
+    }
 }
 //# sourceMappingURL=wiki-agent.js.map