@claudetools/tools 0.7.0 → 0.7.2

package/dist/handlers/codedna-handlers.js

@@ -15,13 +15,75 @@ import { VueFrontendGenerator } from '../codedna/generators/vue-frontend.js';
 import { UIComponentGenerator } from '../codedna/generators/ui-component.js';
 import { errorTracker } from '../helpers/error-tracking.js';
 import { analytics } from '../helpers/usage-analytics.js';
+import { apiRequest } from '../helpers/api-client.js';
 // Singleton registry instance
 const registry = new TemplateRegistry();
+// =============================================================================
+// Pattern Integration Helpers
+// =============================================================================
+/**
+ * Build PatternContext from detected patterns for use in generation
+ */
+function buildPatternContext(detectedPatterns, confidenceScores = {}) {
+    const detected = detectedPatterns.map(p => ({
+        pattern_id: p.pattern_id,
+        name: p.name,
+        category: p.category,
+        confidence: confidenceScores[p.pattern_id] || 0.5,
+    }));
+    // Separate preferred from avoid (anti-patterns)
+    const preferred = detected
+        .filter(p => !detectedPatterns.find(dp => dp.pattern_id === p.pattern_id)?.is_anti_pattern)
+        .map(p => p.pattern_id);
+    const avoid = detected
+        .filter(p => detectedPatterns.find(dp => dp.pattern_id === p.pattern_id)?.is_anti_pattern)
+        .map(p => p.pattern_id);
+    return { detected, preferred, avoid };
+}
+/**
+ * Detect patterns from package.json and build PatternContext
+ */
+async function detectPatternsFromPackageJson(packageJson) {
+    try {
+        // Get all patterns from registry
+        const patterns = await apiRequest('/api/v1/codedna/patterns');
+        const deps = {
+            ...(packageJson.dependencies || {}),
+            ...(packageJson.devDependencies || {}),
+        };
+        const detected = [];
+        const confidenceScores = {};
+        for (const pattern of patterns) {
+            let confidence = 0;
+            let matched = false;
+            for (const signal of pattern.package_signals) {
+                if (deps[signal]) {
+                    matched = true;
+                    confidence += 0.4; // Each package match adds confidence
+                }
+            }
+            if (matched) {
+                detected.push(pattern);
+                confidenceScores[pattern.pattern_id] = Math.min(confidence, 1.0);
+            }
+        }
+        return buildPatternContext(detected, confidenceScores);
+    }
+    catch (error) {
+        console.warn('Pattern detection failed, proceeding without patterns:', error);
+        return { detected: [], preferred: [], avoid: [] };
+    }
+}
 /**
  * Handle codedna_generate_api tool call
+ *
+ * Pattern-aware generation:
+ * - If package_json is provided, patterns are detected automatically
+ * - If patterns is provided in options, those are used directly
+ * - Generated code will use template variants matching detected patterns
  */
 export async function handleGenerateApi(args) {
-    const { spec, framework, options = {} } = args;
+    const { spec, framework, options = {}, package_json } = args;
     // Validate Entity DSL specification
     const validation = validateSpec(spec);
     if (!validation.valid) {
@@ -51,8 +113,18 @@ export async function handleGenerateApi(args) {
     }
     try {
         const startTime = Date.now();
+        // Detect patterns if package.json provided
+        let patternContext = options.patterns;
+        if (!patternContext && package_json) {
+            patternContext = await detectPatternsFromPackageJson(package_json);
+        }
+        // Merge pattern context into options
+        const generationOptions = {
+            ...options,
+            patterns: patternContext,
+        };
         // Generate code
-        const result = await generator.generate(validation.parsed, options);
+        const result = await generator.generate(validation.parsed, generationOptions);
         const executionTime = Date.now() - startTime;
         // Track successful generation
         await analytics.trackGeneration({
@@ -65,13 +137,16 @@ export async function handleGenerateApi(args) {
             filesGenerated: result.metadata.filesGenerated,
             linesOfCode: result.metadata.linesOfCode,
             tokensSaved: result.metadata.estimatedTokensSaved,
-            options: options,
+            options: generationOptions,
             executionTimeMs: executionTime,
         });
         return {
             success: true,
             files: result.files,
             metadata: result.metadata,
+            patternsApplied: patternContext?.detected?.length
+                ? patternContext.detected.map(p => p.pattern_id)
+                : undefined,
             tokenSavings: {
                 traditional: result.metadata.linesOfCode * 25, // ~25 tokens per line
                 codedna: 150, // ~150 tokens for MCP call
@@ -91,9 +166,14 @@ export async function handleGenerateApi(args) {
 }
 /**
  * Handle codedna_generate_frontend tool call
+ *
+ * Pattern-aware generation:
+ * - If package_json is provided, patterns are detected automatically
+ * - Detects React Hook Form, Zod, TanStack Query, etc.
+ * - Uses template variants matching detected patterns
  */
 export async function handleGenerateFrontend(args) {
-    const { spec, framework, options = {} } = args;
+    const { spec, framework, options = {}, package_json } = args;
     // Validate Entity DSL specification
     const validation = validateSpec(spec);
     if (!validation.valid) {
@@ -118,8 +198,18 @@ export async function handleGenerateFrontend(args) {
     }
     try {
         const startTime = Date.now();
+        // Detect patterns if package.json provided
+        let patternContext = options.patterns;
+        if (!patternContext && package_json) {
+            patternContext = await detectPatternsFromPackageJson(package_json);
+        }
+        // Merge pattern context into options
+        const generationOptions = {
+            ...options,
+            patterns: patternContext,
+        };
         // Generate code
-        const result = await generator.generate(validation.parsed, options);
+        const result = await generator.generate(validation.parsed, generationOptions);
         const executionTime = Date.now() - startTime;
         // Track successful generation
         await analytics.trackGeneration({
@@ -132,13 +222,16 @@ export async function handleGenerateFrontend(args) {
             filesGenerated: result.metadata.filesGenerated,
             linesOfCode: result.metadata.linesOfCode,
             tokensSaved: result.metadata.estimatedTokensSaved,
-            options: options,
+            options: generationOptions,
             executionTimeMs: executionTime,
         });
         return {
             success: true,
             files: result.files,
             metadata: result.metadata,
+            patternsApplied: patternContext?.detected?.length
+                ? patternContext.detected.map(p => p.pattern_id)
+                : undefined,
             tokenSavings: {
                 traditional: result.metadata.linesOfCode * 25,
                 codedna: 150,
@@ -157,9 +250,13 @@ export async function handleGenerateFrontend(args) {
 }
 /**
  * Handle codedna_generate_component tool call
+ *
+ * Pattern-aware generation:
+ * - If package_json is provided, patterns are detected automatically
+ * - Uses matching patterns for form libraries, validation, etc.
  */
 export async function handleGenerateComponent(args) {
-    const { spec, type, framework, options = {} } = args;
+    const { spec, type, framework, options = {}, package_json } = args;
     // Validate Entity DSL specification
     const validation = validateSpec(spec);
     if (!validation.valid) {
@@ -186,8 +283,18 @@ export async function handleGenerateComponent(args) {
     }
     try {
         const startTime = Date.now();
+        // Detect patterns if package.json provided
+        let patternContext = options.patterns;
+        if (!patternContext && package_json) {
+            patternContext = await detectPatternsFromPackageJson(package_json);
+        }
+        // Merge pattern context into options
+        const generationOptions = {
+            ...options,
+            patterns: patternContext,
+        };
         const generator = new UIComponentGenerator(registry, type, framework);
-        const result = await generator.generate(validation.parsed, options);
+        const result = await generator.generate(validation.parsed, generationOptions);
         const executionTime = Date.now() - startTime;
         await analytics.trackGeneration({
             operation: 'generate_component',
@@ -199,13 +306,16 @@ export async function handleGenerateComponent(args) {
             filesGenerated: result.metadata.filesGenerated,
             linesOfCode: result.metadata.linesOfCode,
             tokensSaved: result.metadata.estimatedTokensSaved,
-            options: options,
+            options: generationOptions,
             executionTimeMs: executionTime,
         });
         return {
             success: true,
             files: result.files,
             metadata: result.metadata,
+            patternsApplied: patternContext?.detected?.length
+                ? patternContext.detected.map(p => p.pattern_id)
+                : undefined,
             tokenSavings: {
                 traditional: result.metadata.linesOfCode * 25,
                 codedna: 100,
@@ -224,18 +334,47 @@ export async function handleGenerateComponent(args) {
 }
 /**
  * Handle codedna_list_generators tool call
+ * @param args.domain Optional domain filter: 'api' | 'frontend' | 'component'
  */
-export async function handleListGenerators() {
+export async function handleListGenerators(args) {
     try {
-        const generators = await registry.listGenerators();
+        const domain = args?.domain;
+        const generators = await registry.listGenerators(domain);
+        // Collect unique UI libraries across all generators
+        const allUiLibraries = new Set();
+        generators.forEach(gen => {
+            gen.uiLibraries?.forEach(lib => allUiLibraries.add(lib));
+        });
+        // Group by domain for easier discovery (only when not filtered)
+        const byDomain = domain ? undefined : generators.reduce((acc, gen) => {
+            const d = gen.domain || 'unknown';
+            if (!acc[d])
+                acc[d] = [];
+            acc[d].push(gen);
+            return acc;
+        }, {});
         return {
             generators,
+            ...(byDomain && { byDomain }),
             summary: {
                 total: generators.length,
+                ...(domain && { filteredByDomain: domain }),
                 byFramework: generators.reduce((acc, gen) => {
                     acc[gen.framework] = (acc[gen.framework] || 0) + 1;
                     return acc;
                 }, {}),
+                byDomain: domain ? undefined : generators.reduce((acc, gen) => {
+                    const d = gen.domain || 'unknown';
+                    acc[d] = (acc[d] || 0) + 1;
+                    return acc;
+                }, {}),
+                availableUiLibraries: Array.from(allUiLibraries),
+            },
+            usage: {
+                api: 'codedna_generate_api(spec, framework, options)',
+                frontend: 'codedna_generate_frontend(spec, framework, options)',
+                component: 'codedna_generate_component(spec, type, framework, options)',
+                note: 'Check generator.uiLibraries for available UI options. Pass ui: "shadcn"|"mui"|"chakra" in options.',
             },
         };
     }
@@ -281,3 +420,232 @@ export async function handleValidateSpec(args) {
         errors: validation.errors,
     };
 }
+// =============================================================================
+// Pattern Library Handlers
+// =============================================================================
+/**
+ * Handle codedna_list_patterns tool call
+ * Lists patterns from the library, optionally filtered by category
+ */
+export async function handleListPatterns(args) {
+    try {
+        const { category, recommended_only, include_anti_patterns = true } = args || {};
+        // Build query parameters
+        const params = new URLSearchParams();
+        if (category)
+            params.set('category', category);
+        if (recommended_only)
+            params.set('recommended_only', 'true');
+        if (!include_anti_patterns)
+            params.set('exclude_anti_patterns', 'true');
+        const patterns = await apiRequest(`/api/v1/codedna/patterns?${params.toString()}`);
+        // Group by category for easier discovery
+        const byCategory = patterns.reduce((acc, p) => {
+            if (!acc[p.category])
+                acc[p.category] = [];
+            acc[p.category].push(p);
+            return acc;
+        }, {});
+        const recommended = patterns.filter(p => p.is_recommended);
+        const antiPatterns = patterns.filter(p => p.is_anti_pattern);
+        return {
+            patterns,
+            byCategory,
+            summary: {
+                total: patterns.length,
+                recommended: recommended.length,
+                antiPatterns: antiPatterns.length,
+                categories: Object.keys(byCategory),
+            },
+            usage: {
+                getDetails: 'codedna_get_pattern(pattern_id) - Get full pattern documentation',
+                detect: 'codedna_detect_patterns(project_path) - Detect patterns in codebase',
+                init: 'codedna_init_project(patterns) - Initialize project with chosen patterns',
+            },
+        };
+    }
+    catch (error) {
+        return {
+            error: 'Failed to list patterns',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Handle codedna_get_pattern tool call
+ * Gets detailed pattern information including full markdown documentation
+ */
+export async function handleGetPattern(args) {
+    try {
+        const { pattern_id } = args;
+        if (!pattern_id) {
+            return { error: 'pattern_id is required' };
+        }
+        const pattern = await apiRequest(`/api/v1/codedna/patterns/${pattern_id}`);
+        return {
+            pattern,
+            sections: {
+                description: pattern.description,
+                whenToUse: pattern.conditions,
+                whenNotToUse: pattern.anti_conditions,
+                relatedPatterns: pattern.related_patterns,
+                migratesFrom: pattern.migrates_from,
+            },
+            detection: {
+                codeSignals: pattern.code_signals,
+                packageSignals: pattern.package_signals,
+            },
+            content: pattern.content, // Full markdown from R2
+        };
+    }
+    catch (error) {
+        return {
+            error: 'Failed to get pattern',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Handle codedna_detect_patterns tool call
+ * Detects patterns in a project based on code and package.json signals
+ */
+export async function handleDetectPatterns(args) {
+    try {
+        const { project_path, package_json, code_samples } = args;
+        // Get all patterns with their detection signals
+        const patterns = await apiRequest('/api/v1/codedna/patterns');
+        const detected = [];
+        for (const pattern of patterns) {
+            const matchedSignals = [];
+            let confidence = 0;
+            // Check package.json signals
+            if (package_json?.dependencies || package_json?.devDependencies) {
+                const deps = {
+                    ...(package_json.dependencies || {}),
+                    ...(package_json.devDependencies || {}),
+                };
+                for (const signal of pattern.package_signals) {
+                    if (deps[signal]) {
+                        matchedSignals.push(`package:${signal}`);
+                        confidence += 0.4; // Package match is strong signal
+                    }
+                }
+            }
+            // Check code signals in samples
+            if (code_samples) {
+                const allCode = code_samples.join('\n');
+                for (const signal of pattern.code_signals) {
+                    if (allCode.includes(signal)) {
+                        matchedSignals.push(`code:${signal}`);
+                        confidence += 0.2; // Code match is moderate signal
+                    }
+                }
+            }
+            // Add to detected if any signals matched
+            if (matchedSignals.length > 0) {
+                detected.push({
+                    pattern,
+                    confidence: Math.min(confidence, 1.0),
+                    signals: matchedSignals,
+                });
+            }
+        }
+        // Sort by confidence
+        detected.sort((a, b) => b.confidence - a.confidence);
+        // Separate recommended vs detected anti-patterns
+        const goodPatterns = detected.filter(d => !d.pattern.is_anti_pattern);
+        const antiPatterns = detected.filter(d => d.pattern.is_anti_pattern);
+        return {
+            detected: goodPatterns,
+            warnings: antiPatterns.length > 0 ? {
+                message: 'Anti-patterns detected in codebase',
+                patterns: antiPatterns,
+            } : undefined,
+            summary: {
+                totalDetected: detected.length,
+                goodPatterns: goodPatterns.length,
+                antiPatterns: antiPatterns.length,
+                highConfidence: detected.filter(d => d.confidence >= 0.6).length,
+            },
+            recommendations: patterns
+                .filter(p => p.is_recommended && !detected.find(d => d.pattern.pattern_id === p.pattern_id))
+                .slice(0, 5)
+                .map(p => ({
+                pattern_id: p.pattern_id,
+                name: p.name,
+                description: p.description,
+                reason: 'Recommended pattern not yet detected in codebase',
+            })),
+        };
+    }
+    catch (error) {
+        return {
+            error: 'Failed to detect patterns',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Handle codedna_init_project tool call
+ * Initializes a new project with recommended patterns
+ */
+export async function handleInitProject(args) {
+    try {
+        const { project_id, patterns: selectedPatterns, auto_detect = true, project_type = 'new' } = args;
+        if (!project_id) {
+            return { error: 'project_id is required' };
+        }
+        // Get all patterns
+        const allPatterns = await apiRequest('/api/v1/codedna/patterns');
+        let patternsToApply;
+        if (project_type === 'new' && !selectedPatterns) {
+            // For new projects, use recommended patterns
+            patternsToApply = allPatterns
+                .filter(p => p.is_recommended && !p.is_anti_pattern)
+                .map(p => p.pattern_id);
+        }
+        else if (selectedPatterns) {
+            // Use explicitly selected patterns
+            patternsToApply = selectedPatterns;
+        }
+        else {
+            // No patterns specified
+            patternsToApply = [];
+        }
+        // Store pattern associations in memory
+        const stored = await apiRequest(`/api/v1/codedna/projects/${project_id}/patterns`, 'POST', {
+            patterns: patternsToApply,
+            detection_source: selectedPatterns ? 'user_selected' : 'recommended',
+        });
+        const appliedPatterns = allPatterns.filter(p => patternsToApply.includes(p.pattern_id));
+        return {
+            success: stored.success,
+            project_id,
+            project_type,
+            patterns: appliedPatterns.map(p => ({
+                pattern_id: p.pattern_id,
+                name: p.name,
+                category: p.category,
+                description: p.description,
+            })),
+            summary: {
+                totalPatterns: patternsToApply.length,
+                byCategory: appliedPatterns.reduce((acc, p) => {
+                    acc[p.category] = (acc[p.category] || 0) + 1;
+                    return acc;
+                }, {}),
+            },
+            nextSteps: [
+                'Patterns are now associated with this project',
+                'CodeDNA generators will use these patterns for template selection',
+                'Use codedna_detect_patterns to update as codebase evolves',
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            error: 'Failed to initialize project patterns',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/handlers/tool-handlers.js

@@ -13,7 +13,7 @@ import { formatContextForClaude } from '../helpers/formatter.js';
 import { createTask, listTasks, getTask, claimTask, releaseTask, updateTaskStatus, addTaskContext, getTaskSummary, heartbeatTask, parseJsonArray, getDispatchableTasks, getExecutionContext, resolveTaskDependencies, getEpicStatus, getActiveTaskCount, } from '../helpers/tasks.js';
 import { detectTimedOutTasks, retryTask, failTask, autoRetryTimedOutTasks, } from '../helpers/tasks-retry.js';
 import { detectLibrariesFromPlan } from '../helpers/library-detection.js';
-import { handleGenerateApi, handleGenerateFrontend, handleGenerateComponent, handleListGenerators, handleValidateSpec, } from './codedna-handlers.js';
+import { handleGenerateApi, handleGenerateFrontend, handleGenerateComponent, handleListGenerators, handleValidateSpec, handleListPatterns, handleGetPattern, handleDetectPatterns, handleInitProject, } from './codedna-handlers.js';
 export function registerToolHandlers(server) {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
@@ -758,7 +758,7 @@ export function registerToolHandlers(server) {
                                 blocked: '🚫', review: '👀', done: '✅', cancelled: '❌'
                             };
                             const emoji = statusEmoji[t.status] || '📝';
-                            let line = `- ${emoji} **${t.title}** (${t.id.slice(0, 8)}...)`;
+                            let line = `- ${emoji} **${t.title}** (\`${t.id}\`)`;
                             line += ` [${t.status}]`;
                             if (t.priority !== 'medium')
                                 line += ` [${t.priority}]`;
@@ -817,12 +817,12 @@ export function registerToolHandlers(server) {
                         }
                         if (data.parent) {
                             output += `\n## Parent\n`;
-                            output += `- **${data.parent.title}** (${data.parent.id.slice(0, 8)}...) [${data.parent.status}]\n`;
+                            output += `- **${data.parent.title}** (\`${data.parent.id}\`) [${data.parent.status}]\n`;
                         }
                         if (data.subtasks?.length) {
                             output += `\n## Subtasks (${data.subtasks.length})\n`;
                             data.subtasks.forEach(s => {
-                                output += `- ${s.title} (${s.id.slice(0, 8)}...) [${s.status}]\n`;
+                                output += `- ${s.title} (\`${s.id}\`) [${s.status}]\n`;
                             });
                         }
                         if (data.context?.length) {
@@ -1430,14 +1430,20 @@ export function registerToolHandlers(server) {
                 // =========================================================================
                 case 'codebase_map': {
                     // Use raw fetch since this endpoint returns markdown, not JSON
+                    // But we still need auth header
+                    const { getConfig } = await import('../helpers/config-manager.js');
+                    const config = getConfig();
+                    const apiKey = config.apiKey || process.env.CLAUDETOOLS_API_KEY || process.env.MEMORY_API_KEY;
                     const url = `${API_BASE_URL}/api/v1/codebase/${projectId}/map`;
-                    const response = await fetch(url);
+                    const response = await fetch(url, {
+                        headers: apiKey ? { 'Authorization': `Bearer ${apiKey}` } : {},
+                    });
                     mcpLogger.toolResult(name, response.ok, timer());
                     if (!response.ok) {
                         return {
                             content: [{
                                     type: 'text',
-                                    text: `# No Codebase Map Found\n\nThe codebase map hasn't been generated yet. Use the file watcher or API to generate one.`,
+                                    text: `# No Codebase Map Found\n\nThe codebase map hasn't been generated yet. Use the file watcher or API to generate one.\n\n**Debug:** \`${url}\` returned ${response.status}`,
                                 }],
                         };
                     }
@@ -1697,7 +1703,7 @@ export function registerToolHandlers(server) {
                     };
                 }
                 case 'codedna_list_generators': {
-                    const result = await handleListGenerators();
+                    const result = await handleListGenerators(args);
                     mcpLogger.toolResult(name, true, timer());
                     return {
                         content: [{
@@ -1716,6 +1722,49 @@ export function registerToolHandlers(server) {
                             }],
                     };
                 }
+                // =====================================================================
+                // CodeDNA Pattern Library Tools
+                // =====================================================================
+                case 'codedna_list_patterns': {
+                    const result = await handleListPatterns(args);
+                    mcpLogger.toolResult(name, true, timer());
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            }],
+                    };
+                }
+                case 'codedna_get_pattern': {
+                    const result = await handleGetPattern(args);
+                    mcpLogger.toolResult(name, true, timer());
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            }],
+                    };
+                }
+                case 'codedna_detect_patterns': {
+                    const result = await handleDetectPatterns(args);
+                    mcpLogger.toolResult(name, true, timer());
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            }],
+                    };
+                }
+                case 'codedna_init_project': {
+                    const result = await handleInitProject(args);
+                    mcpLogger.toolResult(name, true, timer());
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            }],
+                    };
+                }
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }

package/dist/helpers/codebase-mapper.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Codebase Mapper
+ *
+ * Client-side AST analysis to generate codebase maps.
+ * Runs in the MCP server and uploads results to the API.
+ */
+export interface FileSymbol {
+    name: string;
+    type: 'function' | 'class' | 'interface' | 'type' | 'const' | 'enum' | 'component';
+    exported: boolean;
+    line: number;
+    signature?: string;
+    description?: string;
+}
+export interface FileEntry {
+    path: string;
+    relativePath: string;
+    role: FileRole;
+    symbols: FileSymbol[];
+    imports: string[];
+    exports: string[];
+    dependencies: string[];
+    dependents: string[];
+    linesOfCode: number;
+}
+export type FileRole = 'entry-point' | 'route-handler' | 'api-endpoint' | 'mcp-tool' | 'component' | 'hook' | 'utility' | 'type-definitions' | 'config' | 'test' | 'model' | 'service' | 'extractor' | 'unknown';
+export interface DirectoryEntry {
+    path: string;
+    role: string;
+    fileCount: number;
+    primaryLanguage: string;
+    keyFiles: string[];
+}
+export interface CodebaseIndex {
+    version: string;
+    generatedAt: string;
+    projectRoot: string;
+    summary: {
+        totalFiles: number;
+        totalSymbols: number;
+        languages: Record<string, number>;
+        frameworks: string[];
+    };
+    directories: Record<string, DirectoryEntry>;
+    files: Record<string, FileEntry>;
+    symbols: Record<string, {
+        file: string;
+        line: number;
+        type: string;
+        exported: boolean;
+    }[]>;
+    callGraph: Record<string, string[]>;
+    reverseCallGraph: Record<string, string[]>;
+}
+export declare function generateCodebaseMap(projectRoot: string, projectId: string, apiKey: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Generate a codebase map locally without uploading
+ * Useful for previewing or debugging
+ */
+export declare function generateCodebaseMapLocal(projectRoot: string): {
+    index: CodebaseIndex;
+    markdown: string;
+};