@peakinfer/cli 1.0.133

package/data/inferencemax.json

@@ -0,0 +1,274 @@
+{
+  "version": "1.0",
+  "last_updated": "2025-12-28",
+  "source": "InferenceMAX Benchmark Suite",
+  "benchmarks": {
+    "gpt-4o:api:api": {
+      "model": "gpt-4o",
+      "provider": "openai",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 180,
+        "p50_latency_ms": 800,
+        "p95_latency_ms": 1200,
+        "p99_latency_ms": 1800,
+        "throughput_tps": 45,
+        "cost_per_1k_input": 0.005,
+        "cost_per_1k_output": 0.015
+      },
+      "notes": "OpenAI API baseline"
+    },
+    "gpt-4o-mini:api:api": {
+      "model": "gpt-4o-mini",
+      "provider": "openai",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 120,
+        "p50_latency_ms": 400,
+        "p95_latency_ms": 600,
+        "p99_latency_ms": 900,
+        "throughput_tps": 90,
+        "cost_per_1k_input": 0.00015,
+        "cost_per_1k_output": 0.0006
+      },
+      "notes": "OpenAI API baseline - mini model"
+    },
+    "gpt-4-turbo:api:api": {
+      "model": "gpt-4-turbo",
+      "provider": "openai",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 250,
+        "p50_latency_ms": 1200,
+        "p95_latency_ms": 2000,
+        "p99_latency_ms": 3000,
+        "throughput_tps": 30,
+        "cost_per_1k_input": 0.01,
+        "cost_per_1k_output": 0.03
+      },
+      "notes": "OpenAI API baseline - GPT-4 Turbo"
+    },
+    "claude-3-5-sonnet:api:api": {
+      "model": "claude-3-5-sonnet-20241022",
+      "provider": "anthropic",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 150,
+        "p50_latency_ms": 600,
+        "p95_latency_ms": 1000,
+        "p99_latency_ms": 1500,
+        "throughput_tps": 50,
+        "cost_per_1k_input": 0.003,
+        "cost_per_1k_output": 0.015
+      },
+      "notes": "Anthropic API baseline"
+    },
+    "claude-3-5-haiku:api:api": {
+      "model": "claude-3-5-haiku-20241022",
+      "provider": "anthropic",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 80,
+        "p50_latency_ms": 300,
+        "p95_latency_ms": 500,
+        "p99_latency_ms": 750,
+        "throughput_tps": 100,
+        "cost_per_1k_input": 0.001,
+        "cost_per_1k_output": 0.005
+      },
+      "notes": "Anthropic API baseline - Haiku"
+    },
+    "claude-3-opus:api:api": {
+      "model": "claude-3-opus-20240229",
+      "provider": "anthropic",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 300,
+        "p50_latency_ms": 1500,
+        "p95_latency_ms": 2500,
+        "p99_latency_ms": 4000,
+        "throughput_tps": 20,
+        "cost_per_1k_input": 0.015,
+        "cost_per_1k_output": 0.075
+      },
+      "notes": "Anthropic API baseline - Opus"
+    },
+    "gemini-2.0-flash:api:api": {
+      "model": "gemini-2.0-flash-exp",
+      "provider": "google",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 100,
+        "p50_latency_ms": 350,
+        "p95_latency_ms": 550,
+        "p99_latency_ms": 800,
+        "throughput_tps": 85,
+        "cost_per_1k_input": 0.00035,
+        "cost_per_1k_output": 0.0007
+      },
+      "notes": "Google API baseline - Gemini Flash"
+    },
+    "gemini-1.5-pro:api:api": {
+      "model": "gemini-1.5-pro",
+      "provider": "google",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 200,
+        "p50_latency_ms": 700,
+        "p95_latency_ms": 1100,
+        "p99_latency_ms": 1600,
+        "throughput_tps": 40,
+        "cost_per_1k_input": 0.00125,
+        "cost_per_1k_output": 0.005
+      },
+      "notes": "Google API baseline - Gemini Pro"
+    },
+    "llama-3.1-70b:vllm:h100": {
+      "model": "llama-3.1-70b-instruct",
+      "provider": "meta",
+      "framework": "vllm",
+      "hardware": "h100",
+      "metrics": {
+        "ttft_ms": 50,
+        "p50_latency_ms": 200,
+        "p95_latency_ms": 400,
+        "p99_latency_ms": 600,
+        "throughput_tps": 120,
+        "cost_per_1k_input": 0.0,
+        "cost_per_1k_output": 0.0
+      },
+      "optimal_config": {
+        "tensor_parallelism": 4,
+        "max_model_len": 8192,
+        "gpu_memory_utilization": 0.9
+      },
+      "notes": "Self-hosted on 4xH100"
+    },
+    "llama-3.1-70b:vllm:a100": {
+      "model": "llama-3.1-70b-instruct",
+      "provider": "meta",
+      "framework": "vllm",
+      "hardware": "a100",
+      "metrics": {
+        "ttft_ms": 80,
+        "p50_latency_ms": 350,
+        "p95_latency_ms": 600,
+        "p99_latency_ms": 900,
+        "throughput_tps": 70,
+        "cost_per_1k_input": 0.0,
+        "cost_per_1k_output": 0.0
+      },
+      "optimal_config": {
+        "tensor_parallelism": 4,
+        "max_model_len": 8192,
+        "gpu_memory_utilization": 0.9
+      },
+      "notes": "Self-hosted on 4xA100-80GB"
+    },
+    "llama-3.1-8b:vllm:a100": {
+      "model": "llama-3.1-8b-instruct",
+      "provider": "meta",
+      "framework": "vllm",
+      "hardware": "a100",
+      "metrics": {
+        "ttft_ms": 20,
+        "p50_latency_ms": 100,
+        "p95_latency_ms": 180,
+        "p99_latency_ms": 250,
+        "throughput_tps": 250,
+        "cost_per_1k_input": 0.0,
+        "cost_per_1k_output": 0.0
+      },
+      "optimal_config": {
+        "tensor_parallelism": 1,
+        "max_model_len": 8192,
+        "gpu_memory_utilization": 0.9
+      },
+      "notes": "Self-hosted on 1xA100-80GB"
+    },
+    "mistral-large:api:api": {
+      "model": "mistral-large-latest",
+      "provider": "mistral",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 160,
+        "p50_latency_ms": 550,
+        "p95_latency_ms": 900,
+        "p99_latency_ms": 1300,
+        "throughput_tps": 55,
+        "cost_per_1k_input": 0.004,
+        "cost_per_1k_output": 0.012
+      },
+      "notes": "Mistral API baseline"
+    },
+    "mixtral-8x7b:vllm:a100": {
+      "model": "mixtral-8x7b-instruct",
+      "provider": "mistral",
+      "framework": "vllm",
+      "hardware": "a100",
+      "metrics": {
+        "ttft_ms": 40,
+        "p50_latency_ms": 180,
+        "p95_latency_ms": 320,
+        "p99_latency_ms": 480,
+        "throughput_tps": 150,
+        "cost_per_1k_input": 0.0,
+        "cost_per_1k_output": 0.0
+      },
+      "optimal_config": {
+        "tensor_parallelism": 2,
+        "max_model_len": 32768,
+        "gpu_memory_utilization": 0.9
+      },
+      "notes": "Self-hosted on 2xA100-80GB"
+    },
+    "deepseek-v3:api:api": {
+      "model": "deepseek-chat",
+      "provider": "deepseek",
+      "framework": "api",
+      "hardware": "api",
+      "metrics": {
+        "ttft_ms": 120,
+        "p50_latency_ms": 450,
+        "p95_latency_ms": 750,
+        "p99_latency_ms": 1100,
+        "throughput_tps": 65,
+        "cost_per_1k_input": 0.00014,
+        "cost_per_1k_output": 0.00028
+      },
+      "notes": "DeepSeek API baseline"
+    }
+  },
+  "model_aliases": {
+    "gpt-4o": "gpt-4o:api:api",
+    "gpt-4o-mini": "gpt-4o-mini:api:api",
+    "gpt-4-turbo": "gpt-4-turbo:api:api",
+    "claude-3-5-sonnet": "claude-3-5-sonnet:api:api",
+    "claude-3.5-sonnet": "claude-3-5-sonnet:api:api",
+    "claude-3-5-haiku": "claude-3-5-haiku:api:api",
+    "claude-3.5-haiku": "claude-3-5-haiku:api:api",
+    "claude-3-opus": "claude-3-opus:api:api",
+    "gemini-2.0-flash": "gemini-2.0-flash:api:api",
+    "gemini-flash": "gemini-2.0-flash:api:api",
+    "gemini-1.5-pro": "gemini-1.5-pro:api:api",
+    "gemini-pro": "gemini-1.5-pro:api:api",
+    "llama-3.1-70b": "llama-3.1-70b:vllm:h100",
+    "llama-70b": "llama-3.1-70b:vllm:h100",
+    "llama-3.1-8b": "llama-3.1-8b:vllm:a100",
+    "llama-8b": "llama-3.1-8b:vllm:a100",
+    "mistral-large": "mistral-large:api:api",
+    "mixtral-8x7b": "mixtral-8x7b:vllm:a100",
+    "mixtral": "mixtral-8x7b:vllm:a100",
+    "deepseek-v3": "deepseek-v3:api:api",
+    "deepseek": "deepseek-v3:api:api"
+  }
+}

package/dist/agent-analyzer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Agent-based Semantic Analyzer for PeakInfer
+ *
+ * Uses Claude Agent SDK (per TDD v1.9.3) for multi-step code analysis:
+ * 1. Read source files
+ * 2. Extract patterns and variable assignments
+ * 3. Trace variable definitions to resolve model names
+ * 4. Identify actual LLM callsites (not client initialization)
+ *
+ * Architecture: Claude Agent SDK = Engine, TypeScript = Glue (per TDD §1)
+ */
+import 'dotenv/config';
+import type { ScanResult, Callsite, Patterns } from './types.js';
+interface AgentCallsite {
+    file: string;
+    line: number;
+    provider: string | null;
+    model: string | null;
+    framework: string | null;
+    patterns: Partial<Patterns>;
+    confidence: number;
+    reasoning: string;
+}
+interface AgentInsight {
+    severity: 'critical' | 'warning' | 'info';
+    category: string;
+    headline: string;
+    evidence: string;
+    location: string;
+    recommendation?: string;
+}
+interface AgentAnalysisResult {
+    callsites: AgentCallsite[];
+    insights: AgentInsight[];
+}
+export declare function analyzeWithAgent(scanResult: ScanResult, options?: {
+    verbose?: boolean;
+    maxIterations?: number;
+}): Promise<AgentAnalysisResult>;
+/**
+ * Convert agent results to standard Callsite format
+ */
+export declare function convertAgentCallsites(agentCallsites: AgentCallsite[]): Callsite[];
+export {};
+//# sourceMappingURL=agent-analyzer.d.ts.map

package/dist/agent-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-analyzer.d.ts","sourceRoot":"","sources":["../src/agent-analyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,eAAe,CAAC;AAMvB,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AA4D3E,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,YAAY;IACpB,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,mBAAmB;IAC3B,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AA0MD,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,OAAO,CAAC,mBAAmB,CAAC,CAiJ9B;AAcD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,aAAa,EAAE,GAAG,QAAQ,EAAE,CAYjF"}

package/dist/agent-analyzer.js

@@ -0,0 +1,374 @@
+/**
+ * Agent-based Semantic Analyzer for PeakInfer
+ *
+ * Uses Claude Agent SDK (per TDD v1.9.3) for multi-step code analysis:
+ * 1. Read source files
+ * 2. Extract patterns and variable assignments
+ * 3. Trace variable definitions to resolve model names
+ * 4. Identify actual LLM callsites (not client initialization)
+ *
+ * Architecture: Claude Agent SDK = Engine, TypeScript = Glue (per TDD §1)
+ */
+import 'dotenv/config';
+import { query, tool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { loadPrompt, loadConfig, getConfiguredModel } from './templates.js';
+// Load agent system prompt from YAML (with hardcoded fallback)
+function getAgentSystemPrompt() {
+    const prompt = loadPrompt('agent-analyzer');
+    if (prompt) {
+        return prompt.prompt;
+    }
+    // Fallback to hardcoded prompt if YAML not available
+    return `You are an expert code analyst specializing in identifying LLM/AI inference points in source code.
+
+Your task is to analyze code and find ALL actual LLM inference points with accurate provider and model information.
+
+## CRITICAL RULES
+
+### What IS an inference point (DO report these):
+- client.chat.completions.create() - OpenAI API call
+- client.messages.create() - Anthropic API call
+- client.embeddings.create() - OpenAI embeddings call
+- predictor(question=...) - DSPy module invocation (after dspy.Predict/ChainOfThought)
+- chain.invoke() - LangChain invocation
+- llm.generate() - Direct generation calls
+
+### What is NOT an inference point (DO NOT report these):
+- Client initialization: openai.OpenAI(), anthropic.Anthropic()
+- Import statements
+- Variable assignments: model = "gpt-4o"
+- Class/function definitions
+- DSPy Predict/ChainOfThought creation (only report the invocation)
+
+### Model Extraction Rules:
+1. Look at the model= parameter in the function call
+2. Trace variables back to their definitions
+3. For DSPy: find dspy.LM("provider/model") and extract the model part
+4. Return the FULL exact model name (e.g., "gpt-4o-mini" not "gpt-4")
+
+### Framework Detection:
+- DSPy: look for dspy imports, dspy.Predict, dspy.ChainOfThought
+- LangChain: look for langchain imports, ChatOpenAI, LLMChain
+- LlamaIndex: look for llama_index imports
+
+## WORKFLOW
+
+1. Use search_pattern to find potential inference point locations
+2. Use read_file to examine the code in detail
+3. Use trace_variable to find where models/clients are defined
+4. Use report_callsites to report your findings
+
+Be thorough but precise. Only report actual inference points, not initialization or configuration.`;
+}
+// =============================================================================
+// MCP TOOLS USING CLAUDE AGENT SDK
+// =============================================================================
+/**
+ * Helper to create ToolResult from string
+ */
+function makeToolResult(text) {
+    return {
+        content: [{ type: 'text', text }],
+    };
+}
+/**
+ * Create MCP server with analysis tools using Claude Agent SDK
+ */
+function createAnalysisMcpServer(ctx) {
+    // Tool: read_file - Read source code file contents
+    const readFileTool = tool('read_file', 'Read the contents of a source code file. Use this to examine code in detail.', {
+        file_path: z.string().describe('Relative path to the file from project root'),
+    }, async ({ file_path }) => {
+        // Try from cache first
+        if (ctx.fileContents.has(file_path)) {
+            const content = ctx.fileContents.get(file_path);
+            const numbered = content.split('\n')
+                .map((line, i) => `${i + 1}: ${line}`)
+                .join('\n');
+            return makeToolResult(numbered.slice(0, 8000)); // Limit size
+        }
+        // Try reading from disk
+        const absPath = join(ctx.projectRoot, file_path);
+        if (existsSync(absPath)) {
+            try {
+                const content = readFileSync(absPath, 'utf-8');
+                const numbered = content.split('\n')
+                    .map((line, i) => `${i + 1}: ${line}`)
+                    .join('\n');
+                return makeToolResult(numbered.slice(0, 8000));
+            }
+            catch (e) {
+                return makeToolResult(`Error reading file: ${e}`);
+            }
+        }
+        return makeToolResult(`File not found: ${file_path}`);
+    });
+    // Tool: search_pattern - Search for regex patterns across files
+    const searchPatternTool = tool('search_pattern', 'Search for a regex pattern across all source files. Returns matching lines with file and line number.', {
+        pattern: z.string().describe('Regex pattern to search for (e.g., "dspy\\.LM\\(" or "model\\s*=")'),
+        file_filter: z.string().optional().describe('Optional glob pattern to filter files (e.g., "*.py" or "*.ts")'),
+    }, async ({ pattern, file_filter }) => {
+        const results = [];
+        const regex = new RegExp(pattern, 'gi');
+        for (const [filePath, content] of ctx.fileContents) {
+            // Apply file filter if provided
+            if (file_filter && !filePath.match(new RegExp(file_filter.replace('*', '.*')))) {
+                continue;
+            }
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                    results.push(`${filePath}:${i + 1}: ${lines[i].trim().slice(0, 100)}`);
+                    if (results.length >= 20)
+                        break;
+                }
+            }
+            if (results.length >= 20)
+                break;
+        }
+        return makeToolResult(results.length > 0 ? results.join('\n') : 'No matches found');
+    });
+    // Tool: trace_variable - Find variable definitions and assignments
+    const traceVariableTool = tool('trace_variable', 'Find where a variable is defined or assigned in a file. Useful for tracing model names.', {
+        file_path: z.string().describe('File to search in'),
+        variable_name: z.string().describe('Variable name to trace (e.g., "model", "lm", "client")'),
+    }, async ({ file_path, variable_name }) => {
+        const content = ctx.fileContents.get(file_path);
+        if (!content) {
+            return makeToolResult(`File not found: ${file_path}`);
+        }
+        const results = [];
+        const lines = content.split('\n');
+        // Look for assignments and definitions
+        const patterns = [
+            new RegExp(`\\b${variable_name}\\s*=\\s*(.+)`, 'g'),
+            new RegExp(`\\bconst\\s+${variable_name}\\s*=\\s*(.+)`, 'g'),
+            new RegExp(`\\blet\\s+${variable_name}\\s*=\\s*(.+)`, 'g'),
+            new RegExp(`\\bvar\\s+${variable_name}\\s*=\\s*(.+)`, 'g'),
+            new RegExp(`\\bdef\\s+.*${variable_name}.*:`, 'g'),
+            new RegExp(`${variable_name}\\s*:\\s*(.+)`, 'g'),
+        ];
+        for (let i = 0; i < lines.length; i++) {
+            for (const p of patterns) {
+                if (p.test(lines[i])) {
+                    results.push(`Line ${i + 1}: ${lines[i].trim()}`);
+                    break;
+                }
+            }
+        }
+        return makeToolResult(results.length > 0
+            ? `Found ${results.length} references to "${variable_name}":\n${results.join('\n')}`
+            : `No definitions found for "${variable_name}"`);
+    });
+    // Tool: report_callsites - Report discovered LLM callsites
+    const reportCallsitesTool = tool('report_callsites', 'Report discovered LLM callsites. Call this when you have identified callsites with their details.', {
+        callsites: z.array(z.object({
+            file: z.string().describe('File path'),
+            line: z.number().describe('Line number of the actual inference call'),
+            provider: z.string().describe('Provider: openai, anthropic, google, etc.'),
+            model: z.string().optional().describe('Exact model name as found in code'),
+            framework: z.string().optional().describe('Framework: dspy, langchain, llamaindex, or null'),
+            reasoning: z.string().describe('Brief explanation of how you identified this'),
+        })).describe('Array of identified callsites'),
+    }, async ({ callsites }) => {
+        for (const cs of callsites) {
+            ctx.reportedCallsites.push({
+                file: cs.file,
+                line: cs.line,
+                provider: cs.provider || null,
+                model: cs.model || null,
+                framework: cs.framework || null,
+                patterns: {},
+                confidence: 0.9,
+                reasoning: cs.reasoning,
+            });
+        }
+        return makeToolResult(`Recorded ${callsites.length} callsites. Total: ${ctx.reportedCallsites.length}`);
+    });
+    // Create MCP server with all tools
+    return createSdkMcpServer({
+        name: 'peakinfer-analyzer',
+        version: '1.0.0',
+        tools: [readFileTool, searchPatternTool, traceVariableTool, reportCallsitesTool],
+    });
+}
+// =============================================================================
+// AGENT LOOP USING CLAUDE AGENT SDK
+// =============================================================================
+// AGENT_SYSTEM_PROMPT is now loaded from prompts/agent-analyzer.yaml via getAgentSystemPrompt()
+/**
+ * Extract text content from SDK messages
+ */
+function extractTextFromMessages(messages) {
+    let text = '';
+    for (const msg of messages) {
+        if (msg.type === 'assistant' && msg.message?.content) {
+            for (const block of msg.message.content) {
+                if (block.type === 'text') {
+                    text += block.text;
+                }
+            }
+        }
+    }
+    return text;
+}
+export async function analyzeWithAgent(scanResult, options = {}) {
+    // Load configuration
+    const config = loadConfig();
+    const { verbose = config.agent.verbose } = options;
+    // Check for API key
+    if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error('ANTHROPIC_API_KEY required for agent analysis');
+    }
+    // Build file contents map
+    const fileContents = new Map();
+    for (const file of scanResult.files) {
+        try {
+            const absPath = join(scanResult.root, file.path);
+            fileContents.set(file.path, readFileSync(absPath, 'utf-8'));
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    // Create tool context for shared state
+    const ctx = {
+        projectRoot: scanResult.root,
+        fileContents,
+        reportedCallsites: [],
+    };
+    // Create MCP server with analysis tools
+    const mcpServer = createAnalysisMcpServer(ctx);
+    // Build initial task with candidate info
+    const candidateInfo = scanResult.candidates
+        .map(c => `- ${c.file}:${c.line}: ${c.snippet}`)
+        .join('\n');
+    const fileList = scanResult.files.map(f => f.path).join('\n');
+    const prompt = `Analyze this codebase to identify all LLM inference callsites.
+
+## Files in project:
+${fileList}
+
+## Candidate locations (from regex scan):
+${candidateInfo}
+
+## Instructions:
+1. Start by examining the candidate files
+2. For each candidate, determine if it's a real callsite or false positive
+3. Look for callsites that the regex might have missed (especially framework calls)
+4. Trace variable assignments to find exact model names
+5. Report all confirmed callsites using the report_callsites tool
+
+Begin your analysis.`;
+    if (verbose) {
+        console.log('[agent] Starting Claude Agent SDK analysis...');
+    }
+    // Get model from config
+    const model = getConfiguredModel('agent', false);
+    try {
+        // Use Claude Agent SDK query() function with MCP server
+        const agentQuery = query({
+            prompt,
+            options: {
+                systemPrompt: getAgentSystemPrompt(),
+                model,
+                mcpServers: {
+                    'peakinfer-analyzer': mcpServer,
+                },
+                permissionMode: 'default',
+                cwd: scanResult.root,
+            },
+        });
+        // Collect all messages from the agent
+        const messages = [];
+        for await (const message of agentQuery) {
+            messages.push(message);
+            if (verbose && message.type === 'assistant') {
+                // Log tool usage for debugging
+                if (message.message?.content) {
+                    for (const block of message.message.content) {
+                        if (block.type === 'tool_use') {
+                            console.log(`[agent] Tool: ${block.name}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (verbose) {
+            console.log('[agent] Analysis complete');
+            console.log(`[agent] Found ${ctx.reportedCallsites.length} callsites`);
+        }
+        return {
+            callsites: ctx.reportedCallsites,
+            insights: [],
+        };
+    }
+    catch (error) {
+        // If primary model fails, try fallback
+        const fallbackModel = getConfiguredModel('agent', true);
+        if (verbose) {
+            console.log(`[agent] ${model} failed, trying ${fallbackModel}`);
+        }
+        const agentQuery = query({
+            prompt,
+            options: {
+                systemPrompt: getAgentSystemPrompt(),
+                model: fallbackModel,
+                mcpServers: {
+                    'peakinfer-analyzer': mcpServer,
+                },
+                permissionMode: 'default',
+                cwd: scanResult.root,
+            },
+        });
+        for await (const message of agentQuery) {
+            if (verbose && message.type === 'assistant') {
+                if (message.message?.content) {
+                    for (const block of message.message.content) {
+                        if (block.type === 'tool_use') {
+                            console.log(`[agent] Tool: ${block.name}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (verbose) {
+            console.log('[agent] Analysis complete (fallback)');
+        }
+        return {
+            callsites: ctx.reportedCallsites,
+            insights: [],
+        };
+    }
+}
+// =============================================================================
+// INTEGRATION HELPER
+// =============================================================================
+function generateCallsiteId(file, line) {
+    const hash = createHash('sha256')
+        .update(`${file}:${line}`)
+        .digest('hex')
+        .slice(0, 8);
+    return `cs_${hash}`;
+}
+/**
+ * Convert agent results to standard Callsite format
+ */
+export function convertAgentCallsites(agentCallsites) {
+    return agentCallsites.map(ac => ({
+        id: generateCallsiteId(ac.file, ac.line),
+        file: ac.file,
+        line: ac.line,
+        provider: ac.provider,
+        model: ac.model,
+        framework: ac.framework,
+        runtime: null,
+        patterns: ac.patterns,
+        confidence: ac.confidence,
+    }));
+}
+//# sourceMappingURL=agent-analyzer.js.map