@peakinfer/cli 1.0.133

package/src/config.ts

@@ -0,0 +1,188 @@
+/**
+ * Config Module (v1.6)
+ *
+ * Central configuration resolution for PeakInfer.
+ * Resolution chain: CLI flags → env vars → global config → local config → defaults
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse as parseYAML } from 'yaml';
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const GLOBAL_CONFIG_DIR = join(homedir(), '.peakinfer');
+const GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, 'config.yaml');
+const LOCAL_CONFIG_FILE = 'peakinfer.yaml';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface PeakInferConfig {
+  apiKey?: string;
+  provider: 'anthropic';
+  model: string;
+  analysisMode: 'agent' | 'llm' | 'regex';
+  maxFileSize: number;
+  historyRetentionDays: number;
+  verbose: boolean;
+}
+
+export interface ConfigOverrides {
+  apiKey?: string;
+  model?: string;
+  analysisMode?: string;
+  verbose?: boolean;
+}
+
+interface ConfigFile {
+  apiKey?: string;
+  model?: string;
+  analysisMode?: string;
+  verbose?: boolean;
+  maxFileSize?: number;
+  historyRetentionDays?: number;
+}
+
+// =============================================================================
+// DEFAULTS
+// =============================================================================
+
+const DEFAULT_CONFIG: PeakInferConfig = {
+  provider: 'anthropic',
+  model: 'claude-sonnet-4-20250514',
+  analysisMode: 'agent',
+  maxFileSize: 1048576, // 1MB
+  historyRetentionDays: 90,
+  verbose: false,
+};
+
+// =============================================================================
+// LOADERS
+// =============================================================================
+
+/**
+ * Load global config from ~/.peakinfer/config.yaml
+ */
+function loadGlobalConfig(): ConfigFile {
+  if (!existsSync(GLOBAL_CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
+    return parseYAML(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Load local config from ./peakinfer.yaml
+ */
+function loadLocalConfig(): ConfigFile {
+  if (!existsSync(LOCAL_CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(LOCAL_CONFIG_FILE, 'utf-8');
+    return parseYAML(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Get API key from environment variables
+ */
+function getEnvApiKey(): string | undefined {
+  // Check ANTHROPIC_API_KEY (Claude Agent SDK)
+  if (process.env.ANTHROPIC_API_KEY) {
+    return process.env.ANTHROPIC_API_KEY;
+  }
+  // Generic fallback
+  return process.env.PEAKINFER_API_KEY;
+}
+
+/**
+ * Get model from environment
+ */
+function getEnvModel(): string | undefined {
+  return process.env.PEAKINFER_MODEL;
+}
+
+// =============================================================================
+// RESOLUTION
+// =============================================================================
+
+/**
+ * Resolve configuration from all sources.
+ * Priority: CLI overrides → env vars → global config → local config → defaults
+ */
+export function resolveConfig(overrides: ConfigOverrides = {}): PeakInferConfig {
+  const local = loadLocalConfig();
+  const global = loadGlobalConfig();
+
+  // Start with defaults
+  const config: PeakInferConfig = { ...DEFAULT_CONFIG };
+
+  // Layer 1: Local config file (./peakinfer.yaml)
+  if (local.model) config.model = local.model;
+  if (local.analysisMode) config.analysisMode = local.analysisMode as PeakInferConfig['analysisMode'];
+  if (local.verbose !== undefined) config.verbose = local.verbose;
+  if (local.maxFileSize) config.maxFileSize = local.maxFileSize;
+  if (local.historyRetentionDays) config.historyRetentionDays = local.historyRetentionDays;
+  if (local.apiKey) config.apiKey = local.apiKey;
+
+  // Layer 2: Global config file (~/.peakinfer/config.yaml)
+  if (global.model) config.model = global.model;
+  if (global.analysisMode) config.analysisMode = global.analysisMode as PeakInferConfig['analysisMode'];
+  if (global.verbose !== undefined) config.verbose = global.verbose;
+  if (global.maxFileSize) config.maxFileSize = global.maxFileSize;
+  if (global.historyRetentionDays) config.historyRetentionDays = global.historyRetentionDays;
+  if (global.apiKey) config.apiKey = global.apiKey;
+
+  // Layer 3: Environment variables
+  const envApiKey = getEnvApiKey();
+  const envModel = getEnvModel();
+  const envVerbose = process.env.PEAKINFER_VERBOSE;
+
+  if (envApiKey) config.apiKey = envApiKey;
+  if (envModel) config.model = envModel;
+  if (envVerbose === '1' || envVerbose === 'true') config.verbose = true;
+
+  // Layer 4: CLI overrides (highest priority)
+  if (overrides.apiKey) config.apiKey = overrides.apiKey;
+  if (overrides.model) config.model = overrides.model;
+  if (overrides.analysisMode) config.analysisMode = overrides.analysisMode as PeakInferConfig['analysisMode'];
+  if (overrides.verbose !== undefined) config.verbose = overrides.verbose;
+
+  return config;
+}
+
+/**
+ * Get the resolved API key (convenience function)
+ */
+export function getApiKey(): string | undefined {
+  return resolveConfig().apiKey;
+}
+
+/**
+ * Check if API key is configured
+ */
+export function hasApiKey(): boolean {
+  return !!getApiKey();
+}
+
+/**
+ * Get config file paths for reference
+ */
+export function getConfigPaths(): { global: string; local: string } {
+  return {
+    global: GLOBAL_CONFIG_FILE,
+    local: LOCAL_CONFIG_FILE,
+  };
+}

package/src/connectors/helicone.ts

@@ -0,0 +1,164 @@
+/**
+ * Helicone API Connector
+ *
+ * Fetches LLM request logs from Helicone's API.
+ * Docs: https://docs.helicone.ai/rest/request/post-v1requestquery
+ */
+
+import {
+  ConnectorConfig,
+  ConnectorResult,
+  ConnectorError,
+  NormalizedEvent,
+  calculateSummary,
+} from './types.js';
+
+const HELICONE_API_URL = 'https://api.helicone.ai/v1/request/query';
+
+interface HeliconeRequest {
+  request_id: string;
+  created_at: string;
+  model: string;
+  provider: string;
+  request_path: string;
+  response_status: number;
+  latency_ms: number;
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+  cost_usd?: number;
+  user_id?: string;
+  properties?: Record<string, string>;
+  request_body?: {
+    stream?: boolean;
+    model?: string;
+  };
+  response_body?: {
+    error?: { message?: string };
+  };
+}
+
+interface HeliconeResponse {
+  data: HeliconeRequest[];
+  error?: string;
+}
+
+function normalizeHeliconeEvent(req: HeliconeRequest): NormalizedEvent {
+  const isSuccess = req.response_status >= 200 && req.response_status < 400;
+  const isStreaming = req.request_body?.stream === true;
+
+  return {
+    id: req.request_id,
+    timestamp: req.created_at,
+    model: req.model || req.request_body?.model || 'unknown',
+    provider: normalizeProvider(req.provider),
+    latency_ms: req.latency_ms,
+    prompt_tokens: req.prompt_tokens,
+    completion_tokens: req.completion_tokens,
+    total_tokens: req.total_tokens,
+    cost_usd: req.cost_usd,
+    success: isSuccess,
+    error: !isSuccess ? req.response_body?.error?.message : undefined,
+    streaming: isStreaming,
+    request_path: req.request_path,
+    user_id: req.user_id,
+    raw: req as unknown as Record<string, unknown>,
+  };
+}
+
+function normalizeProvider(provider: string): string {
+  const providerMap: Record<string, string> = {
+    'openai': 'openai',
+    'openai-azure': 'azure-openai',
+    'azure': 'azure-openai',
+    'anthropic': 'anthropic',
+    'google': 'google',
+    'vertex': 'google-vertex',
+    'aws': 'aws-bedrock',
+    'bedrock': 'aws-bedrock',
+    'together': 'together',
+    'fireworks': 'fireworks',
+    'groq': 'groq',
+    'deepseek': 'deepseek',
+  };
+
+  return providerMap[provider.toLowerCase()] || provider.toLowerCase();
+}
+
+export async function fetchHeliconeEvents(
+  config: ConnectorConfig
+): Promise<ConnectorResult> {
+  const limit = config.limit || 1000;
+
+  // Build filter
+  const filter: Record<string, unknown> = {};
+
+  if (config.startDate) {
+    filter.created_at = { gte: config.startDate };
+  }
+
+  if (config.filter?.model) {
+    filter.model = { equals: config.filter.model };
+  }
+
+  if (config.filter?.success !== undefined) {
+    filter.response_status = config.filter.success
+      ? { gte: 200, lt: 400 }
+      : { gte: 400 };
+  }
+
+  try {
+    const response = await fetch(HELICONE_API_URL, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        filter: Object.keys(filter).length > 0 ? filter : undefined,
+        limit,
+        sort: {
+          created_at: 'desc',
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ConnectorError(
+        `Helicone API error: ${response.status} ${errorText}`,
+        'helicone',
+        response.status
+      );
+    }
+
+    const data = await response.json() as HeliconeResponse;
+
+    if (data.error) {
+      throw new ConnectorError(data.error, 'helicone');
+    }
+
+    const events = (data.data || []).map(normalizeHeliconeEvent);
+    const summary = calculateSummary(events);
+
+    return {
+      events,
+      summary,
+      metadata: {
+        source: 'helicone',
+        fetched_at: new Date().toISOString(),
+        total_fetched: events.length,
+        truncated: events.length >= limit,
+        api_version: 'v1',
+      },
+    };
+  } catch (error) {
+    if (error instanceof ConnectorError) {
+      throw error;
+    }
+    throw new ConnectorError(
+      `Failed to fetch from Helicone: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      'helicone'
+    );
+  }
+}

package/src/connectors/index.ts

@@ -0,0 +1,93 @@
+/**
+ * Runtime Data Connectors
+ *
+ * Unified interface for fetching LLM runtime data from various sources.
+ * Supports: Helicone, LangSmith
+ *
+ * Usage:
+ *   const result = await fetchRuntimeData({
+ *     source: 'helicone',
+ *     apiKey: process.env.HELICONE_API_KEY,
+ *     limit: 1000,
+ *   });
+ */
+
+import { fetchHeliconeEvents } from './helicone.js';
+import { fetchLangSmithTraces } from './langsmith.js';
+import {
+  ConnectorConfig,
+  ConnectorResult,
+  ConnectorError,
+  NormalizedEvent,
+  ConnectorSummary,
+} from './types.js';
+
+export type RuntimeSource = 'helicone' | 'langsmith';
+
+export interface FetchRuntimeOptions extends Omit<ConnectorConfig, 'apiKey'> {
+  source: RuntimeSource;
+  apiKey: string;
+}
+
+/**
+ * Fetch runtime data from the specified source
+ */
+export async function fetchRuntimeData(options: FetchRuntimeOptions): Promise<ConnectorResult> {
+  const { source, ...config } = options;
+
+  switch (source) {
+    case 'helicone':
+      return fetchHeliconeEvents(config);
+    case 'langsmith':
+      return fetchLangSmithTraces(config);
+    default:
+      throw new ConnectorError(
+        `Unknown runtime source: ${source}. Supported sources: helicone, langsmith`,
+        source as RuntimeSource
+      );
+  }
+}
+
+/**
+ * Get API key from environment for the given source
+ */
+export function getApiKeyFromEnv(source: RuntimeSource): string | undefined {
+  const envVarMap: Record<RuntimeSource, string[]> = {
+    helicone: ['HELICONE_API_KEY', 'HELICONE_KEY'],
+    langsmith: ['LANGSMITH_API_KEY', 'LANGCHAIN_API_KEY'],
+  };
+
+  const envVars = envVarMap[source] || [];
+  for (const envVar of envVars) {
+    const value = process.env[envVar];
+    if (value) return value;
+  }
+  return undefined;
+}
+
+/**
+ * Validate that the source is supported
+ */
+export function isValidSource(source: string): source is RuntimeSource {
+  return source === 'helicone' || source === 'langsmith';
+}
+
+/**
+ * Get a human-readable description of the source
+ */
+export function getSourceDescription(source: RuntimeSource): string {
+  const descriptions: Record<RuntimeSource, string> = {
+    helicone: 'Helicone LLM Observability',
+    langsmith: 'LangSmith Tracing',
+  };
+  return descriptions[source] || source;
+}
+
+// Re-export types
+export {
+  ConnectorConfig,
+  ConnectorResult,
+  ConnectorError,
+  NormalizedEvent,
+  ConnectorSummary,
+} from './types.js';

package/src/connectors/langsmith.ts

@@ -0,0 +1,179 @@
+/**
+ * LangSmith API Connector
+ *
+ * Fetches LLM traces from LangSmith's API.
+ * Docs: https://docs.smith.langchain.com/reference/api
+ */
+
+import {
+  ConnectorConfig,
+  ConnectorResult,
+  ConnectorError,
+  NormalizedEvent,
+  calculateSummary,
+} from './types.js';
+
+const LANGSMITH_API_URL = 'https://api.smith.langchain.com';
+
+interface LangSmithRun {
+  id: string;
+  name: string;
+  run_type: string;
+  start_time: string;
+  end_time?: string;
+  status: string;
+  error?: string;
+  inputs?: Record<string, unknown>;
+  outputs?: Record<string, unknown>;
+  extra?: {
+    invocation_params?: {
+      model?: string;
+      model_name?: string;
+      stream?: boolean;
+    };
+    metadata?: Record<string, unknown>;
+  };
+  total_tokens?: number;
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_cost?: number;
+  trace_id?: string;
+  parent_run_id?: string;
+  session_id?: string;
+}
+
+interface LangSmithResponse {
+  runs?: LangSmithRun[];
+  cursors?: {
+    next?: string;
+  };
+}
+
+function normalizeProvider(runName: string, invocationParams?: Record<string, unknown>): string {
+  const nameLower = runName.toLowerCase();
+
+  if (nameLower.includes('openai') || nameLower.includes('gpt')) return 'openai';
+  if (nameLower.includes('anthropic') || nameLower.includes('claude')) return 'anthropic';
+  if (nameLower.includes('azure')) return 'azure-openai';
+  if (nameLower.includes('bedrock')) return 'aws-bedrock';
+  if (nameLower.includes('vertex') || nameLower.includes('palm') || nameLower.includes('gemini')) return 'google';
+  if (nameLower.includes('together')) return 'together';
+  if (nameLower.includes('fireworks')) return 'fireworks';
+  if (nameLower.includes('groq')) return 'groq';
+
+  // Check invocation params
+  const modelName = invocationParams?.model_name || invocationParams?.model;
+  if (typeof modelName === 'string') {
+    if (modelName.includes('gpt')) return 'openai';
+    if (modelName.includes('claude')) return 'anthropic';
+    if (modelName.includes('gemini')) return 'google';
+  }
+
+  return 'unknown';
+}
+
+function normalizeLangSmithRun(run: LangSmithRun): NormalizedEvent | null {
+  // Only include LLM runs
+  if (run.run_type !== 'llm') {
+    return null;
+  }
+
+  const startTime = new Date(run.start_time).getTime();
+  const endTime = run.end_time ? new Date(run.end_time).getTime() : startTime;
+  const latencyMs = endTime - startTime;
+
+  const invocationParams = run.extra?.invocation_params;
+  const model = invocationParams?.model || invocationParams?.model_name || 'unknown';
+  const isStreaming = invocationParams?.stream === true;
+  const isSuccess = run.status === 'success' || run.status === 'completed';
+
+  return {
+    id: run.id,
+    timestamp: run.start_time,
+    model: typeof model === 'string' ? model : 'unknown',
+    provider: normalizeProvider(run.name, invocationParams),
+    latency_ms: Math.max(0, latencyMs),
+    prompt_tokens: run.prompt_tokens,
+    completion_tokens: run.completion_tokens,
+    total_tokens: run.total_tokens,
+    cost_usd: run.total_cost,
+    success: isSuccess,
+    error: run.error,
+    streaming: isStreaming,
+    trace_id: run.trace_id,
+    parent_span_id: run.parent_run_id,
+    session_id: run.session_id,
+    raw: run as unknown as Record<string, unknown>,
+  };
+}
+
+export async function fetchLangSmithTraces(
+  config: ConnectorConfig
+): Promise<ConnectorResult> {
+  const limit = config.limit || 1000;
+
+  // Build query params
+  const params = new URLSearchParams();
+  params.set('limit', limit.toString());
+  params.set('run_type', 'llm'); // Only fetch LLM runs
+  params.set('is_root', 'false'); // Include nested runs
+
+  if (config.startDate) {
+    params.set('start_time', config.startDate);
+  }
+
+  if (config.endDate) {
+    params.set('end_time', config.endDate);
+  }
+
+  if (config.filter?.success !== undefined) {
+    params.set('error', config.filter.success ? 'false' : 'true');
+  }
+
+  try {
+    const response = await fetch(`${LANGSMITH_API_URL}/runs?${params.toString()}`, {
+      method: 'GET',
+      headers: {
+        'X-API-Key': config.apiKey,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ConnectorError(
+        `LangSmith API error: ${response.status} ${errorText}`,
+        'langsmith',
+        response.status
+      );
+    }
+
+    const data = await response.json() as LangSmithResponse;
+
+    const events = (data.runs || [])
+      .map(normalizeLangSmithRun)
+      .filter((e): e is NormalizedEvent => e !== null);
+
+    const summary = calculateSummary(events);
+
+    return {
+      events,
+      summary,
+      metadata: {
+        source: 'langsmith',
+        fetched_at: new Date().toISOString(),
+        total_fetched: events.length,
+        truncated: data.cursors?.next !== undefined,
+        api_version: 'v1',
+      },
+    };
+  } catch (error) {
+    if (error instanceof ConnectorError) {
+      throw error;
+    }
+    throw new ConnectorError(
+      `Failed to fetch from LangSmith: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      'langsmith'
+    );
+  }
+}