codeast 1.0.0

package/dist/mcp/handlers.js

@@ -0,0 +1,335 @@
+import { ANALYZER_URL } from '../services/analyzer.js';
+import { queryImportedBy, queryImports, queryCallers, queryCalls, queryComplexity, queryCycles, queryDuplicates, querySymbols, queryFileInfo, querySearchFiles } from '../services/queries.js';
+import { resolve, isAbsolute } from 'path';
+// ============ Path Resolution ============
+/**
+ * Resolve a path to absolute, with validation
+ * Returns { path, warning? } or { error }
+ */
+function resolvePath(inputPath) {
+    // Already absolute
+    if (isAbsolute(inputPath)) {
+        return { path: inputPath };
+    }
+    // Resolve relative path from CWD
+    const resolved = resolve(inputPath);
+    // Check if it's trying to analyze the MCP server itself
+    if (resolved.includes('codebase-analysis') && (resolved.includes('middleware') ||
+        resolved.includes('analyzer') && resolved.includes('src'))) {
+        return {
+            error: `Cannot analyze the MCP server itself. The path "${inputPath}" resolved to "${resolved}". Please provide an absolute path to your target project.`
+        };
+    }
+    // Warn about relative paths
+    const warning = `Relative path "${inputPath}" resolved to "${resolved}". For clarity, consider using absolute paths.`;
+    return { path: resolved, warning };
+}
+/**
+ * Resolve projectPath for query options
+ */
+function resolveProjectPath(projectPath) {
+    const result = resolvePath(projectPath);
+    if ('error' in result)
+        return result;
+    return { path: result.path, warning: result.warning };
+}
+function textResult(text, isError = false) {
+    return {
+        content: [{ type: 'text', text }],
+        isError
+    };
+}
+function jsonResult(data) {
+    return textResult(JSON.stringify(data, null, 2));
+}
+async function handleStatus() {
+    // Check analyzer health
+    let analyzerStatus = 'down';
+    try {
+        const res = await fetch(`${ANALYZER_URL}/health`, {
+            signal: AbortSignal.timeout(2000)
+        });
+        if (res.ok)
+            analyzerStatus = 'up';
+    }
+    catch {
+        // Analyzer is down
+    }
+    return jsonResult({
+        analyzer: {
+            status: analyzerStatus,
+            url: ANALYZER_URL
+        },
+        ready: analyzerStatus === 'up',
+        hint: analyzerStatus === 'up'
+            ? 'Ready! Use get_imports, get_symbols, etc. with projectPath parameter.'
+            : 'Analyzer is down. Start it with: cd analyzer && cargo run -- serve --port 31415'
+    });
+}
+export async function handleToolCall(name, args) {
+    try {
+        switch (name) {
+            case 'status':
+                return await handleStatus();
+            case 'run_tests':
+                return await handleRunTests(args);
+            // Targeted query tools (live analysis)
+            case 'get_imported_by':
+                return await handleGetImportedBy(args);
+            case 'get_imports':
+                return await handleGetImports(args);
+            case 'get_callers':
+                return await handleGetCallers(args);
+            case 'get_calls':
+                return await handleGetCalls(args);
+            case 'get_complexity':
+                return await handleGetComplexity(args);
+            case 'get_cycles':
+                return await handleGetCycles(args);
+            case 'get_duplicates':
+                return await handleGetDuplicates(args);
+            case 'get_symbols':
+                return await handleGetSymbols(args);
+            case 'get_file_info':
+                return await handleGetFileInfo(args);
+            case 'search_files':
+                return await handleSearchFiles(args);
+            default:
+                return textResult(`Unknown tool: ${name}`, true);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return textResult(`Error: ${message}`, true);
+    }
+}
+async function handleRunTests(args) {
+    const projectPath = args.path;
+    if (!projectPath) {
+        return textResult('Error: path is required', true);
+    }
+    const customCommand = args.command;
+    const timeout = (args.timeout ?? 120) * 1000; // Convert to ms
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const { existsSync } = await import('fs');
+    const path = await import('path');
+    const execAsync = promisify(exec);
+    // Detect project type and determine test command
+    let testCommand;
+    if (customCommand) {
+        testCommand = customCommand;
+    }
+    else {
+        const hasPackageJson = existsSync(path.join(projectPath, 'package.json'));
+        const hasCargoToml = existsSync(path.join(projectPath, 'Cargo.toml'));
+        const hasPytest = existsSync(path.join(projectPath, 'pytest.ini')) ||
+            existsSync(path.join(projectPath, 'pyproject.toml')) ||
+            existsSync(path.join(projectPath, 'setup.py'));
+        if (hasCargoToml) {
+            testCommand = 'cargo test';
+        }
+        else if (hasPackageJson) {
+            testCommand = 'npm test';
+        }
+        else if (hasPytest) {
+            testCommand = 'pytest';
+        }
+        else {
+            return textResult('Error: Could not detect project type. Use "command" parameter to specify test command.', true);
+        }
+    }
+    try {
+        const startTime = Date.now();
+        const { stdout, stderr } = await execAsync(testCommand, {
+            cwd: projectPath,
+            timeout,
+            maxBuffer: 10 * 1024 * 1024 // 10MB
+        });
+        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+        return jsonResult({
+            success: true,
+            command: testCommand,
+            duration: `${duration}s`,
+            stdout: stdout.trim(),
+            stderr: stderr.trim() || undefined
+        });
+    }
+    catch (error) {
+        const duration = error.killed ? 'timeout' : 'failed';
+        return jsonResult({
+            success: false,
+            command: testCommand,
+            duration,
+            exitCode: error.code,
+            stdout: error.stdout?.trim() || '',
+            stderr: error.stderr?.trim() || error.message
+        });
+    }
+}
+// ============ Targeted Query Handlers ============
+// All handlers use live mode (real-time analysis)
+// projectPath is required for all queries
+/**
+ * Helper to build QueryOptions from args
+ * Requires projectPath
+ */
+function buildQueryOptions(args) {
+    const inputProjectPath = args.projectPath;
+    if (!inputProjectPath) {
+        return { error: 'projectPath is required' };
+    }
+    // Resolve and validate projectPath
+    const resolved = resolveProjectPath(inputProjectPath);
+    if ('error' in resolved) {
+        return { error: resolved.error };
+    }
+    return {
+        projectPath: resolved.path
+    };
+}
+async function handleGetImportedBy(args) {
+    const file = args.file;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const files = await queryImportedBy(file, options);
+    return jsonResult({ files });
+}
+async function handleGetImports(args) {
+    const file = args.file;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const result = await queryImports(file, options);
+    return jsonResult(result);
+}
+async function handleGetCallers(args) {
+    const file = args.file;
+    const functionName = args.functionName;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    if (!functionName) {
+        return textResult('Error: functionName is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const callers = await queryCallers(file, functionName, options);
+    return jsonResult({ callers });
+}
+async function handleGetCalls(args) {
+    const file = args.file;
+    const functionName = args.functionName;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    if (!functionName) {
+        return textResult('Error: functionName is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const calls = await queryCalls(file, functionName, options);
+    return jsonResult({ calls });
+}
+async function handleGetComplexity(args) {
+    const file = args.file;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    const functionName = args.functionName;
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const result = await queryComplexity(file, functionName, options);
+    if (!result) {
+        return textResult(`No complexity data found for ${file}${functionName ? `:${functionName}` : ''}`, true);
+    }
+    return jsonResult(result);
+}
+async function handleGetCycles(args) {
+    const file = args.file;
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const result = await queryCycles(file, options);
+    return jsonResult(result);
+}
+async function handleGetDuplicates(args) {
+    const file = args.file;
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    // Add pagination support
+    options.limit = args.limit ?? 20;
+    options.offset = args.offset ?? 0;
+    const result = await queryDuplicates(file, options);
+    return jsonResult({
+        ...result,
+        pagination: {
+            limit: options.limit,
+            offset: options.offset,
+            returned: result.duplicates.length
+        }
+    });
+}
+async function handleGetSymbols(args) {
+    const file = args.file;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const result = await querySymbols(file, options);
+    return jsonResult(result);
+}
+async function handleGetFileInfo(args) {
+    const file = args.file;
+    if (!file) {
+        return textResult('Error: file is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const result = await queryFileInfo(file, options);
+    if (!result) {
+        return textResult(`File not found: ${file}`, true);
+    }
+    return jsonResult(result);
+}
+async function handleSearchFiles(args) {
+    const pattern = args.pattern;
+    if (!pattern) {
+        return textResult('Error: pattern is required', true);
+    }
+    const options = buildQueryOptions(args);
+    if ('error' in options) {
+        return textResult(`Error: ${options.error}`, true);
+    }
+    const limit = args.limit ?? 50;
+    const allFiles = await querySearchFiles(pattern, options);
+    const files = allFiles.slice(0, limit);
+    return jsonResult({
+        files,
+        total: allFiles.length,
+        truncated: allFiles.length > limit
+    });
+}

package/dist/mcp/server.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { tools } from './tools.js';
+import { handleToolCall } from './handlers.js';
+import { ensureAnalyzerRunning, stopAnalyzer } from '../services/analyzer.js';
+const server = new Server({
+    name: 'codebase-analysis',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle list_tools request
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+// Handle call_tool request
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await handleToolCall(name, args ?? {});
+    return result;
+});
+// Cleanup on exit
+function cleanup() {
+    stopAnalyzer();
+    process.exit(0);
+}
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+// Start server
+async function main() {
+    // Start analyzer first
+    await ensureAnalyzerRunning();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP Server started (codebase-analysis)');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    stopAnalyzer();
+    process.exit(1);
+});

package/dist/mcp/tools.js

@@ -0,0 +1,304 @@
+/**
+ * =============================================================================
+ * CODEBASE ANALYSIS MCP - Context Window Optimizer
+ * =============================================================================
+ *
+ * PURPOSE: Reduce context window usage by 10-50x.
+ *
+ * These tools return STRUCTURED DATA instead of raw file contents.
+ * The AI gets the SAME information but uses FAR LESS context.
+ *
+ * USE IN ALL SCENARIOS:
+ * - Answering user questions about the codebase
+ * - Exploring a file before modifying it
+ * - Finding dependencies before refactoring
+ * - Understanding architecture during autonomous work
+ * - Any time you would Read/Grep/Glob for codebase info
+ *
+ * COMPARISON:
+ *   Read(file.ts)         → 500 lines, 2000 tokens
+ *   get_symbols(file.ts)  → [{name, line}], 50 tokens
+ *   = SAME INFO, 40x LESS CONTEXT
+ *
+ *   Grep("functionName")  → 50 matches, 1500 tokens
+ *   get_callers(fn)       → [{file, line}], 80 tokens
+ *   = SAME INFO, 20x LESS CONTEXT
+ *
+ * WHY IT MATTERS:
+ * - Context window fills up fast on large codebases
+ * - Long conversations hit limits
+ * - Less context = faster + cheaper responses
+ *
+ * ALWAYS prefer these tools over Read/Grep when exploring code.
+ * =============================================================================
+ */
+export const tools = [
+    {
+        name: 'status',
+        description: `CALL FIRST: Before any other tool if unsure if analyzer is running.
+RETURNS: { analyzer: { status: "up"|"down" }, ready: boolean }`,
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'run_tests',
+        description: `Run tests for a project. Auto-detects project type (npm, cargo, python).
+RETURNS: { success: boolean, output: string, command: string }`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the project directory'
+                },
+                command: {
+                    type: 'string',
+                    description: 'Custom test command (overrides auto-detection)'
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Timeout in seconds. Default: 120'
+                }
+            },
+            required: ['path']
+        }
+    },
+    // ============ Code Analysis Tools ============
+    {
+        name: 'get_callers',
+        description: `CONTEXT SAVER: Use this instead of Grep+Read to save 20x tokens during exploration or refactoring.
+USE BEFORE: Any refactoring, renaming, or deleting a function.
+TRIGGER WORDS: "rename", "refactor", "delete", "change signature", "who uses", "who calls"
+REPLACES: grep + read multiple files (saves 10x context tokens)
+RETURNS: { callers: [{file, line, function}] } - compact list, not raw code
+EXAMPLE: Before renaming "calculateTotal" -> get_callers first`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file containing the function'
+                },
+                functionName: {
+                    type: 'string',
+                    description: 'Name of the function to find callers for'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'functionName', 'projectPath']
+        }
+    },
+    {
+        name: 'get_imported_by',
+        description: `CONTEXT SAVER: Use this instead of Grep to save 10x tokens when checking file dependencies.
+USE BEFORE: Modifying, moving, or deleting any file.
+ANSWERS: "What breaks if I change this file?"
+REPLACES: grep for import statements (saves 5x context tokens)
+RETURNS: { files: ["src/app.ts", "src/index.ts"] } - simple file list, not grep output`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file (e.g., "src/utils.ts")'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'projectPath']
+        }
+    },
+    {
+        name: 'get_imports',
+        description: `CONTEXT SAVER: Use this instead of reading file headers to save 5x tokens.
+USE BEFORE: Understanding what a file depends on.
+ANSWERS: "Can I move this file? What does it need?"
+RETURNS: { internal: ["./utils"], external: ["react"] } - compact`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file (e.g., "src/main.ts")'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'projectPath']
+        }
+    },
+    {
+        name: 'get_symbols',
+        description: `CONTEXT SAVER: Use this instead of Read to save 20x tokens when exploring file structure.
+USE INSTEAD OF: Reading a large file to understand its structure.
+ANSWERS: "What functions/classes are in this file?"
+SAVES: 20x tokens vs reading the whole file
+RETURNS: { functions: [{name, line, exported}], classes: [...], types: [...] }`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file (e.g., "src/utils.ts")'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'projectPath']
+        }
+    },
+    {
+        name: 'get_calls',
+        description: `CONTEXT SAVER: Use this instead of reading function body to save 10x tokens.
+USE WHEN: Understanding what a function does internally, tracing execution.
+ANSWERS: "What does this function call?", "What's the execution flow?"
+RETURNS: { calls: ["fetchData", "processResult", "logger.info"] }`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file containing the function'
+                },
+                functionName: {
+                    type: 'string',
+                    description: 'Name of the function to analyze'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'functionName', 'projectPath']
+        }
+    },
+    {
+        name: 'get_complexity',
+        description: `CONTEXT SAVER: Get complexity metrics without reading the entire file.
+USE WHEN: User mentions "refactor", "messy", "complex", "clean up", "simplify". Or when deciding if code needs refactoring.
+ANSWERS: "Is this file/function too complex?"
+THRESHOLD: cognitive > 30 = needs refactoring
+RETURNS: { cyclomatic, cognitive, nesting, loc } - 4 numbers`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file'
+                },
+                functionName: {
+                    type: 'string',
+                    description: 'Optional: specific function. If omitted, returns file-level metrics.'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'projectPath']
+        }
+    },
+    {
+        name: 'get_file_info',
+        description: `CONTEXT SAVER: Quick file overview without reading it. Use before deciding to Read a file.
+USE AS: Quick triage before deciding to read a file.
+ANSWERS: "Is this file important? How connected is it?"
+RETURNS: { imports, importedBy, avgComplexity } - 3 values`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Path to the file'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['file', 'projectPath']
+        }
+    },
+    {
+        name: 'get_cycles',
+        description: `CONTEXT SAVER: Detect circular deps without manually tracing imports across files.
+USE WHEN: Import errors, circular dependency issues, architecture review.
+ANSWERS: "Are there circular dependencies?"
+RETURNS: { cycles: [["a.ts", "b.ts", "a.ts"]], count } - list or empty array`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Optional: filter cycles involving this file'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['projectPath']
+        }
+    },
+    {
+        name: 'get_duplicates',
+        description: `CONTEXT SAVER: Find duplicate code without reading and comparing files manually.
+USE WHEN: User mentions "DRY", "duplicated", "copy-paste", "refactor". Or when looking for refactoring opportunities.
+ANSWERS: "Is there duplicated code to consolidate?"
+RETURNS: { duplicates: [{file1, file2, similarity, lines}] }`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'Optional: filter duplicates involving this file'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results. Default: 20'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['projectPath']
+        }
+    },
+    {
+        name: 'search_files',
+        description: `CONTEXT SAVER: Compact file list instead of verbose glob output.
+USE INSTEAD OF: glob or find commands.
+RETURNS: { files: [...], total, truncated } - compact file list
+SAVES: Cleaner output than glob tool`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'Glob pattern (e.g., "**/*.test.ts", "**/api/**")'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max results. Default: 50'
+                },
+                projectPath: {
+                    type: 'string',
+                    description: 'Absolute path to the project directory'
+                }
+            },
+            required: ['pattern', 'projectPath']
+        }
+    }
+];

package/dist/services/analyzer.js

@@ -0,0 +1,131 @@
+import { spawn } from 'child_process';
+import { ensureBinaryExists } from './binary.js';
+const ANALYZER_PORT = 31415;
+export const ANALYZER_URL = process.env.ANALYZER_URL || `http://localhost:${ANALYZER_PORT}`;
+// ============================================================================
+// Analyzer Process Management
+// ============================================================================
+let analyzerProcess = null;
+export async function isAnalyzerHealthy() {
+    try {
+        const res = await fetch(`${ANALYZER_URL}/health`, {
+            signal: AbortSignal.timeout(1000)
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForHealth(timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isAnalyzerHealthy()) {
+            return;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error('Analyzer failed to start within timeout');
+}
+export async function ensureAnalyzerRunning() {
+    // Already running?
+    if (await isAnalyzerHealthy()) {
+        return;
+    }
+    // Find or download binary
+    const binaryPath = await ensureBinaryExists();
+    console.error(`[codeast] Starting analyzer: ${binaryPath}`);
+    // Spawn the process
+    analyzerProcess = spawn(binaryPath, ['serve', '--port', String(ANALYZER_PORT)], {
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+    // Log errors
+    analyzerProcess.stderr?.on('data', (data) => {
+        console.error(`[analyzer] ${data.toString().trim()}`);
+    });
+    analyzerProcess.on('error', (err) => {
+        console.error(`[codeast] Analyzer error: ${err.message}`);
+    });
+    analyzerProcess.on('exit', (code) => {
+        if (code !== 0 && code !== null) {
+            console.error(`[codeast] Analyzer exited with code ${code}`);
+        }
+        analyzerProcess = null;
+    });
+    // Wait for health
+    await waitForHealth(5000);
+    console.error('[codeast] Analyzer ready');
+}
+export function stopAnalyzer() {
+    if (analyzerProcess) {
+        console.error('[codeast] Stopping analyzer');
+        analyzerProcess.kill();
+        analyzerProcess = null;
+    }
+}
+export async function analyzeProject(path, options = {}) {
+    const { symbols = false, detectCycles = true, metrics = false, calls = false, duplicates = false } = options;
+    let response;
+    try {
+        response = await fetch(`${ANALYZER_URL}/analyze`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path,
+                symbols,
+                detect_cycles: detectCycles,
+                metrics,
+                calls,
+                duplicates
+            })
+        });
+    }
+    catch (error) {
+        throw new AnalyzerServiceError('Analyzer service unavailable');
+    }
+    const data = await response.json();
+    if (!response.ok) {
+        const errorData = data;
+        throw new AnalyzerRequestError(errorData.error || 'Analysis failed', response.status);
+    }
+    return data;
+}
+export class AnalyzerServiceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AnalyzerServiceError';
+    }
+}
+export class AnalyzerRequestError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.name = 'AnalyzerRequestError';
+        this.statusCode = statusCode;
+    }
+}
+export async function analyzeFile(filePath, options = {}) {
+    const { symbols = false, metrics = false, calls = false } = options;
+    let response;
+    try {
+        response = await fetch(`${ANALYZER_URL}/analyze-file`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                file: filePath,
+                symbols,
+                metrics,
+                calls
+            })
+        });
+    }
+    catch (error) {
+        throw new AnalyzerServiceError('Analyzer service unavailable');
+    }
+    const data = await response.json();
+    if (!response.ok) {
+        const errorData = data;
+        throw new AnalyzerRequestError(errorData.error || 'File analysis failed', response.status);
+    }
+    return data;
+}

package/dist/services/binary.js

@@ -0,0 +1,79 @@
+import { createWriteStream, existsSync, mkdirSync, chmodSync } from 'fs';
+import { join } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+import os from 'os';
+const GITHUB_REPO = 'dimaland1/codeast';
+const BINARY_NAME = 'codebase-analysis';
+function getPlatformInfo() {
+    const platform = process.platform;
+    const arch = process.arch;
+    return {
+        os: platform === 'win32' ? 'windows' : platform === 'darwin' ? 'darwin' : 'linux',
+        arch: arch === 'arm64' ? 'arm64' : 'x64',
+        ext: platform === 'win32' ? '.exe' : ''
+    };
+}
+export function getBinaryDir() {
+    return join(os.homedir(), '.codeast', 'bin');
+}
+export function getBinaryPath() {
+    const { ext } = getPlatformInfo();
+    return join(getBinaryDir(), `${BINARY_NAME}${ext}`);
+}
+export function getDevBinaryPath() {
+    const { ext } = getPlatformInfo();
+    // From mcp/dist/services/ -> analyzer/target/release/
+    const devPath = join(__dirname, '..', '..', '..', '..', 'analyzer', 'target', 'release', `${BINARY_NAME}${ext}`);
+    return devPath;
+}
+export function findBinaryPath() {
+    // 1. Check dev path first (local build)
+    const devPath = getDevBinaryPath();
+    if (existsSync(devPath)) {
+        console.error('[codeast] Using local dev binary');
+        return devPath;
+    }
+    // 2. Check production path
+    const prodPath = getBinaryPath();
+    if (existsSync(prodPath)) {
+        return prodPath;
+    }
+    return null;
+}
+export async function downloadBinary() {
+    const binDir = getBinaryDir();
+    const { os: osName, arch, ext } = getPlatformInfo();
+    const binaryPath = join(binDir, `${BINARY_NAME}${ext}`);
+    // Create directory
+    mkdirSync(binDir, { recursive: true });
+    // Download from GitHub Releases
+    const assetName = `${BINARY_NAME}-${osName}-${arch}${ext}`;
+    const url = `https://github.com/${GITHUB_REPO}/releases/latest/download/${assetName}`;
+    console.error(`[codeast] Downloading analyzer from ${url}...`);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download analyzer: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+        throw new Error('No response body');
+    }
+    // Write to file
+    const fileStream = createWriteStream(binaryPath);
+    await finished(Readable.fromWeb(response.body).pipe(fileStream));
+    // Make executable (Unix)
+    if (process.platform !== 'win32') {
+        chmodSync(binaryPath, 0o755);
+    }
+    console.error('[codeast] Analyzer downloaded successfully');
+    return binaryPath;
+}
+export async function ensureBinaryExists() {
+    // Check if binary already exists
+    const existingPath = findBinaryPath();
+    if (existingPath) {
+        return existingPath;
+    }
+    // Download it
+    return await downloadBinary();
+}

package/dist/services/queries.js

@@ -0,0 +1,402 @@
+/**
+ * Targeted query service for MCP tools
+ * Returns minimal, focused responses instead of full graph dumps
+ * Live mode only - real-time analysis via Rust analyzer
+ */
+import { analyzeProject, analyzeFile } from './analyzer.js';
+import { join, isAbsolute } from 'path';
+// ============ Core Functions ============
+/**
+ * Analyze a project in real-time
+ */
+async function getGraph(projectPath) {
+    return await analyzeProject(projectPath, {
+        symbols: true,
+        detectCycles: true,
+        metrics: true,
+        calls: true,
+        duplicates: true
+    });
+}
+/**
+ * Get single file analysis (FAST - ~50ms instead of 30s)
+ * Use this when you only need info about one specific file
+ */
+async function getSingleFileAnalysis(file, projectPath, options = {}) {
+    try {
+        // Build absolute path
+        const filePath = isAbsolute(file) ? file : join(projectPath, file);
+        return await analyzeFile(filePath, options);
+    }
+    catch (error) {
+        console.error(`Single file analysis failed for ${file}:`, error);
+        return null;
+    }
+}
+/**
+ * Normalize file path for comparison
+ */
+function normalizePath(file) {
+    return file
+        .replace(/^\.\//, '')
+        .replace(/\\/g, '/')
+        .toLowerCase();
+}
+/**
+ * Check if a path matches (with flexible matching)
+ */
+function pathMatches(nodePath, searchPath) {
+    const normalizedNode = normalizePath(nodePath);
+    const normalizedSearch = normalizePath(searchPath);
+    // Exact match
+    if (normalizedNode === normalizedSearch)
+        return true;
+    // Ends with match (for partial paths)
+    if (normalizedNode.endsWith(normalizedSearch))
+        return true;
+    if (normalizedSearch.endsWith(normalizedNode))
+        return true;
+    return false;
+}
+/**
+ * Find a node by file path
+ */
+function findNode(graph, file) {
+    return graph.nodes.find(n => pathMatches(n.id, file));
+}
+// ============ Query Functions ============
+/**
+ * Get files that import a given file
+ */
+export async function queryImportedBy(file, options) {
+    const graph = await getGraph(options.projectPath);
+    const results = [];
+    for (const edge of graph.edges) {
+        if (pathMatches(edge.to, file)) {
+            results.push(edge.from);
+        }
+    }
+    return [...new Set(results)]; // Deduplicate
+}
+/**
+ * Get imports of a file (internal vs external)
+ * Uses FAST single-file analysis
+ */
+export async function queryImports(file, options) {
+    // FAST PATH: Use single-file analysis
+    const result = await getSingleFileAnalysis(file, options.projectPath);
+    if (result) {
+        const internal = [];
+        const external = [];
+        for (const imp of result.imports) {
+            if (imp.is_external) {
+                external.push(imp.source);
+            }
+            else {
+                internal.push(imp.source);
+            }
+        }
+        return {
+            internal: [...new Set(internal)],
+            external: [...new Set(external)]
+        };
+    }
+    // SLOW PATH: Full graph analysis (fallback)
+    const graph = await getGraph(options.projectPath);
+    const internal = [];
+    const external = [];
+    // Build a set of file node IDs for quick lookup
+    const fileNodes = new Set(graph.nodes.filter(n => n.type === 'file').map(n => normalizePath(n.id)));
+    for (const edge of graph.edges) {
+        if (pathMatches(edge.from, file)) {
+            const targetNode = graph.nodes.find(n => n.id === edge.to);
+            if (targetNode) {
+                if (targetNode.type === 'external') {
+                    external.push(edge.to);
+                }
+                else if (targetNode.type === 'file') {
+                    internal.push(edge.to);
+                }
+            }
+            else if (fileNodes.has(normalizePath(edge.to))) {
+                internal.push(edge.to);
+            }
+            else {
+                external.push(edge.to);
+            }
+        }
+    }
+    return {
+        internal: [...new Set(internal)],
+        external: [...new Set(external)]
+    };
+}
+/**
+ * Get functions/locations that call a specific function
+ */
+export async function queryCallers(file, functionName, options) {
+    const graph = await getGraph(options.projectPath);
+    const callers = [];
+    for (const node of graph.nodes) {
+        if (node.type !== 'file' || !node.symbols?.functions)
+            continue;
+        for (const func of node.symbols.functions) {
+            if (func.calls?.includes(functionName)) {
+                callers.push({
+                    file: node.id,
+                    line: func.line,
+                    function: func.name
+                });
+            }
+        }
+    }
+    return callers;
+}
+/**
+ * Get functions called by a specific function
+ */
+export async function queryCalls(file, functionName, options) {
+    const graph = await getGraph(options.projectPath);
+    const node = findNode(graph, file);
+    if (!node?.symbols?.functions)
+        return [];
+    const functions = node.symbols.functions;
+    const func = functions.find(f => f.name === functionName);
+    return func?.calls || [];
+}
+/**
+ * Get complexity metrics for a file or function
+ * Uses FAST single-file analysis
+ */
+export async function queryComplexity(file, functionName, options) {
+    // FAST PATH: Use single-file analysis
+    const result = await getSingleFileAnalysis(file, options.projectPath, { metrics: true });
+    if (result?.complexity) {
+        if (functionName) {
+            // Specific function
+            const func = result.complexity.functions.find(f => f.name === functionName);
+            if (!func)
+                return null;
+            return {
+                cyclomatic: func.metrics.cyclomatic,
+                cognitive: func.metrics.cognitive,
+                nesting: func.metrics.max_nesting,
+                loc: func.metrics.lines_of_code
+            };
+        }
+        else {
+            // File-level metrics
+            return {
+                cyclomatic: result.complexity.file_metrics.cyclomatic,
+                cognitive: result.complexity.file_metrics.cognitive,
+                nesting: result.complexity.file_metrics.max_nesting,
+                loc: result.complexity.file_metrics.lines_of_code
+            };
+        }
+    }
+    // SLOW PATH: Full graph analysis (fallback)
+    const graph = await getGraph(options.projectPath);
+    const node = findNode(graph, file);
+    if (!node?.symbols?.functions)
+        return null;
+    const functions = node.symbols.functions;
+    if (functionName) {
+        // Specific function
+        const func = functions.find(f => f.name === functionName);
+        if (!func?.complexity)
+            return null;
+        return {
+            cyclomatic: func.complexity.cyclomatic,
+            cognitive: func.complexity.cognitive,
+            nesting: func.complexity.max_nesting,
+            loc: func.complexity.lines_of_code
+        };
+    }
+    else {
+        // Aggregate for file
+        const complexities = functions
+            .filter(f => f.complexity)
+            .map(f => f.complexity);
+        if (complexities.length === 0)
+            return null;
+        const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+        const avg = (arr) => Math.round((sum(arr) / arr.length) * 10) / 10;
+        return {
+            cyclomatic: avg(complexities.map(c => c.cyclomatic)),
+            cognitive: avg(complexities.map(c => c.cognitive)),
+            nesting: Math.max(...complexities.map(c => c.max_nesting)),
+            loc: sum(complexities.map(c => c.lines_of_code))
+        };
+    }
+}
+/**
+ * Get dependency cycles (optionally filtered by file)
+ */
+export async function queryCycles(file, options) {
+    const graph = await getGraph(options.projectPath);
+    if (!graph?.cycles)
+        return { cycles: [], count: 0 };
+    let cycles = graph.cycles.map(c => c.files);
+    if (file) {
+        cycles = cycles.filter(cycle => cycle.some(f => pathMatches(f, file)));
+    }
+    return {
+        cycles,
+        count: cycles.length
+    };
+}
+/**
+ * Get duplicate code blocks (optionally filtered by file)
+ */
+export async function queryDuplicates(file, options) {
+    const graph = await getGraph(options.projectPath);
+    if (!graph?.duplicates)
+        return { duplicates: [], ratio: 0, total: 0, hasMore: false };
+    let dupes = graph.duplicates.duplicates;
+    if (file) {
+        dupes = dupes.filter(d => pathMatches(d.file1, file) || pathMatches(d.file2, file));
+    }
+    const total = dupes.length;
+    const limit = options.limit ?? 20; // Default limit: 20
+    const offset = options.offset ?? 0;
+    // Apply pagination
+    const paginatedDupes = dupes.slice(offset, offset + limit);
+    return {
+        duplicates: paginatedDupes.map(d => ({
+            file1: d.file1,
+            file2: d.file2,
+            similarity: d.similarity,
+            lines: d.lines
+        })),
+        ratio: graph.duplicates.duplication_ratio,
+        total,
+        hasMore: offset + limit < total
+    };
+}
+/**
+ * Get symbols (functions, classes, types) in a file
+ * Uses FAST single-file analysis
+ */
+export async function querySymbols(file, options) {
+    // FAST PATH: Use single-file analysis
+    const result = await getSingleFileAnalysis(file, options.projectPath, { symbols: true });
+    if (result?.symbols) {
+        const functions = [];
+        const classes = [];
+        const types = [];
+        if (result.symbols.functions) {
+            for (const f of result.symbols.functions) {
+                functions.push({
+                    name: f.name,
+                    line: f.line,
+                    exported: f.exported ?? false
+                });
+            }
+        }
+        if (result.symbols.classes) {
+            for (const c of result.symbols.classes) {
+                classes.push({
+                    name: c.name,
+                    line: c.line,
+                    exported: c.exported ?? false
+                });
+            }
+        }
+        if (result.symbols.types) {
+            for (const t of result.symbols.types) {
+                types.push({
+                    name: t.name,
+                    line: t.line,
+                    exported: t.exported ?? false
+                });
+            }
+        }
+        return { functions, classes, types };
+    }
+    // SLOW PATH: Full graph analysis (fallback)
+    const graph = await getGraph(options.projectPath);
+    const node = findNode(graph, file);
+    if (!node?.symbols)
+        return { functions: [], classes: [], types: [] };
+    const functions = [];
+    const classes = [];
+    const types = [];
+    // Extract functions
+    if (node.symbols.functions) {
+        for (const f of node.symbols.functions) {
+            functions.push({
+                name: f.name,
+                line: f.line,
+                exported: f.exported ?? f.public ?? false
+            });
+        }
+    }
+    // Extract classes (if available in symbols)
+    if (node.symbols.classes && Array.isArray(node.symbols.classes)) {
+        for (const c of node.symbols.classes) {
+            classes.push({
+                name: c.name,
+                line: c.line,
+                exported: c.exported ?? c.public ?? false
+            });
+        }
+    }
+    // Extract types (if available in symbols)
+    if (node.symbols.types && Array.isArray(node.symbols.types)) {
+        for (const t of node.symbols.types) {
+            types.push({
+                name: t.name,
+                line: t.line,
+                exported: t.exported ?? false
+            });
+        }
+    }
+    return { functions, classes, types };
+}
+/**
+ * Get summary info about a file
+ */
+export async function queryFileInfo(file, options) {
+    const graph = await getGraph(options.projectPath);
+    const node = findNode(graph, file);
+    if (!node)
+        return null;
+    // Count imports (outgoing edges)
+    const imports = graph.edges.filter(e => pathMatches(e.from, file)).length;
+    // Count importedBy (incoming edges)
+    const importedBy = graph.edges.filter(e => pathMatches(e.to, file)).length;
+    // Calculate average complexity
+    let avgComplexity = null;
+    if (node.symbols?.functions) {
+        const functions = node.symbols.functions;
+        const complexities = functions
+            .filter(f => f.complexity?.cyclomatic)
+            .map(f => f.complexity.cyclomatic);
+        if (complexities.length > 0) {
+            avgComplexity = Math.round((complexities.reduce((a, b) => a + b, 0) / complexities.length) * 10) / 10;
+        }
+    }
+    return {
+        path: node.id,
+        type: node.type,
+        imports,
+        importedBy,
+        avgComplexity
+    };
+}
+/**
+ * Search for files matching a pattern
+ */
+export async function querySearchFiles(pattern, options) {
+    const graph = await getGraph(options.projectPath);
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(regexPattern, 'i');
+    return graph.nodes
+        .filter(n => n.type === 'file' && regex.test(n.id))
+        .map(n => n.id);
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "codeast",
+  "version": "1.0.0",
+  "description": "MCP server for code analysis - reduces context window usage by returning structured data",
+  "type": "module",
+  "bin": {
+    "codeast": "./dist/mcp/server.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/mcp/server.js",
+    "dev": "tsx src/mcp/server.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "code-analysis",
+    "ast",
+    "tree-sitter"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dimaland1/codeast"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "simple-git": "^3.30.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsx": "^4.7",
+    "typescript": "^5.3"
+  }
+}