lynkr 8.0.0 → 9.0.1

package/src/routing/complexity-analyzer.js

@@ -2,17 +2,19 @@
  * Complexity Analyzer Module
  *
  * Analyzes request complexity to determine optimal model routing.
- * Implements all 4 phases of auto model selection:
+ * Implements all 5 phases of auto model selection:
  * - Phase 1: Basic Scoring (token count, tool count, task classification)
  * - Phase 2: Advanced Classification (code complexity, reasoning detection)
  * - Phase 3: Learning & Tracking (metrics, feedback storage)
  * - Phase 4: ML-Based (embeddings similarity)
+ * - Phase 5: Structural Analysis (code-review-graph blast radius & dependency signals)
  *
  * @module routing/complexity-analyzer
  */
 
 const logger = require('../logger');
 const config = require('../config');
+const codeGraph = require('../tools/code-graph');
 
 // ============================================================================
 // PHASE 1: Basic Scoring Patterns
@@ -178,6 +180,189 @@ const routingMetrics = {
   },
 };
 
+// ============================================================================
+// PHASE 5: Structural Analysis Helpers (code-review-graph)
+// ============================================================================
+
+/** Pattern to match file paths in message content */
+const FILE_PATH_PATTERN = /(?:^|\s|["'`(])([.\w/-]+\.(?:js|ts|py|rb|go|rs|java|cpp|c|h|jsx|tsx|vue|svelte|json|yaml|yml|toml|sql|sh|bash|css|scss|html))\b/gi;
+
+/**
+ * Extract file paths from text using the FILE_PATH_PATTERN regex.
+ * @param {string} text
+ * @param {Set<string>} paths — accumulator set
+ */
+function extractPathsFromText(text, paths) {
+  if (typeof text !== 'string') return;
+  for (const match of text.matchAll(FILE_PATH_PATTERN)) {
+    paths.add(match[1]);
+  }
+}
+
+/**
+ * Extract file paths from the full conversation payload.
+ *
+ * Supports both Anthropic and OpenAI message formats:
+ * - Anthropic: system (string/array), messages with tool_use/tool_result blocks
+ * - OpenAI: messages with role=system, tool_calls with function.arguments
+ * - Cursor/Windsurf: file context embedded in system prompts
+ * - Codex CLI / Aider: function call arguments with file paths
+ *
+ * @param {Object} payload — request payload
+ * @returns {string[]} deduplicated file paths
+ */
+function extractFilePaths(payload) {
+  const paths = new Set();
+
+  if (!payload) return [];
+
+  // --- Anthropic system prompt (string or array of content blocks) ---
+  if (typeof payload.system === 'string') {
+    extractPathsFromText(payload.system, paths);
+  } else if (Array.isArray(payload.system)) {
+    for (const block of payload.system) {
+      if (block?.type === 'text' && block.text) {
+        extractPathsFromText(block.text, paths);
+      }
+    }
+  }
+
+  if (!Array.isArray(payload.messages)) return Array.from(paths);
+
+  for (const msg of payload.messages) {
+    // --- String content (both Anthropic and OpenAI) ---
+    if (typeof msg.content === 'string') {
+      extractPathsFromText(msg.content, paths);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        // Text blocks (Anthropic format)
+        if (block?.type === 'text' && block.text) {
+          extractPathsFromText(block.text, paths);
+        }
+        // Tool use blocks (Anthropic format — Claude Code, Cline, Zed)
+        if (block?.type === 'tool_use' && block.input) {
+          const input = block.input;
+          if (typeof input.file_path === 'string') paths.add(input.file_path);
+          if (typeof input.path === 'string') paths.add(input.path);
+          if (typeof input.command === 'string') {
+            extractPathsFromText(input.command, paths);
+          }
+        }
+        // Tool result blocks (Anthropic format)
+        if (block?.type === 'tool_result') {
+          const resultContent = Array.isArray(block.content) ? block.content : [];
+          for (const rc of resultContent) {
+            if (rc?.type === 'text' && rc.text) {
+              extractPathsFromText(rc.text, paths);
+            }
+          }
+        }
+      }
+    }
+
+    // --- OpenAI tool_calls format (Codex CLI, Aider, Continue.dev) ---
+    if (Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        if (tc?.function?.arguments) {
+          try {
+            // function.arguments is a JSON string in OpenAI format
+            const args = typeof tc.function.arguments === 'string'
+              ? JSON.parse(tc.function.arguments)
+              : tc.function.arguments;
+            if (typeof args.file_path === 'string') paths.add(args.file_path);
+            if (typeof args.path === 'string') paths.add(args.path);
+            if (typeof args.command === 'string') {
+              extractPathsFromText(args.command, paths);
+            }
+            // Also scan the full arguments text for paths
+            if (typeof tc.function.arguments === 'string') {
+              extractPathsFromText(tc.function.arguments, paths);
+            }
+          } catch {
+            // If arguments isn't valid JSON, scan as text
+            if (typeof tc.function.arguments === 'string') {
+              extractPathsFromText(tc.function.arguments, paths);
+            }
+          }
+        }
+      }
+    }
+
+    // --- OpenAI function_call format (legacy, some tools still use it) ---
+    if (msg.function_call?.arguments) {
+      try {
+        const args = typeof msg.function_call.arguments === 'string'
+          ? JSON.parse(msg.function_call.arguments)
+          : msg.function_call.arguments;
+        if (typeof args.file_path === 'string') paths.add(args.file_path);
+        if (typeof args.path === 'string') paths.add(args.path);
+      } catch {
+        if (typeof msg.function_call.arguments === 'string') {
+          extractPathsFromText(msg.function_call.arguments, paths);
+        }
+      }
+    }
+  }
+
+  return Array.from(paths);
+}
+
+/**
+ * Calculate score adjustment from Graphify complexity signals.
+ * Capped at +35 (increased from +25 due to richer signals).
+ *
+ * @param {{ blast_radius: number, dependency_depth: number, test_coverage_pct: number, is_infrastructure: boolean, god_node_touched: boolean, community_count: number, cohesion: number }} signals
+ * @returns {{ adjustment: number, reasons: string[] }}
+ */
+function scoreGraphSignals(signals) {
+  let adjustment = 0;
+  const reasons = [];
+
+  // Blast radius — how many files are affected
+  if (signals.blast_radius > 30) {
+    adjustment += 15;
+    reasons.push('blast_radius_high');
+  } else if (signals.blast_radius > 10) {
+    adjustment += 10;
+    reasons.push('blast_radius_medium');
+  } else if (signals.blast_radius > 5) {
+    adjustment += 5;
+    reasons.push('blast_radius_low');
+  }
+
+  // Dependency depth — deep call chains are harder to reason about
+  if (signals.dependency_depth > 4) {
+    adjustment += 5;
+    reasons.push('deep_dependencies');
+  }
+
+  // Infrastructure files — config/CI/deploy changes are high-risk
+  if (signals.is_infrastructure) {
+    adjustment += 10;
+    reasons.push('infrastructure_file');
+  }
+
+  // Low test coverage — changes in untested areas are riskier
+  if (signals.test_coverage_pct < 30) {
+    adjustment += 5;
+    reasons.push('low_test_coverage');
+  }
+
+  // God node touched — editing a hub class that many things depend on
+  if (signals.god_node_touched) {
+    adjustment += 10;
+    reasons.push('god_node_touched');
+  }
+
+  // Low community cohesion — loosely coupled code is harder to change safely
+  if (typeof signals.cohesion === 'number' && signals.cohesion < 0.15 && signals.community_count > 1) {
+    adjustment += 5;
+    reasons.push('low_community_cohesion');
+  }
+
+  return { adjustment: Math.min(adjustment, 35), reasons };
+}
+
 // ============================================================================
 // CORE ANALYSIS FUNCTIONS
 // ============================================================================
@@ -546,7 +731,7 @@ function getThreshold() {
  * @param {Object} options - Analysis options
  * @returns {Object} Complexity analysis result
  */
-function analyzeComplexity(payload, options = {}) {
+async function analyzeComplexity(payload, options = {}) {
   const content = extractContent(payload);
   const messageCount = payload?.messages?.length ?? 0;
   const useWeighted = options.weighted ?? config.routing?.weightedScoring ?? false;
@@ -568,7 +753,7 @@ function analyzeComplexity(payload, options = {}) {
       recommendation = weighted.score >= threshold ? 'cloud' : 'local';
     }
 
-    return {
+    const result = {
       score: weighted.score,
       threshold,
       mode: 'weighted',
@@ -578,7 +763,39 @@ function analyzeComplexity(payload, options = {}) {
       meta: weighted.meta,
       forceReason: taskTypeResult.reason?.startsWith('force_') ? taskTypeResult.reason : null,
       content: content.slice(0, 100) + (content.length > 100 ? '...' : ''),
+      graphSignals: null,
     };
+
+    // Phase 5: Structural Analysis (code-review-graph, optional)
+    try {
+      const filePaths = extractFilePaths(payload);
+      const graphOpts = { filePaths, workspace: options?.workspace };
+      const graphAvailable = await codeGraph.isAvailable(graphOpts);
+      if (graphAvailable && filePaths.length > 0) {
+        const signals = await codeGraph.getComplexitySignals(filePaths, graphOpts);
+        if (signals) {
+          const { adjustment, reasons } = scoreGraphSignals(signals);
+          result.score = Math.min(result.score + adjustment, 100);
+          result.graphSignals = { ...signals, adjustment, reasons };
+
+          // Re-evaluate recommendation with adjusted score
+          if (!result.forceReason) {
+            result.recommendation = result.score >= threshold ? 'cloud' : 'local';
+          }
+
+          logger.debug({
+            filePaths: filePaths.slice(0, 5),
+            signals,
+            adjustment,
+            reasons,
+          }, '[complexity] Phase 5: graph signals applied');
+        }
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, '[complexity] Phase 5: code-graph query failed');
+    }
+
+    return result;
   }
 
   // Standard scoring (original logic)
@@ -600,7 +817,7 @@ function analyzeComplexity(payload, options = {}) {
 
   // Conversation length bonus (long conversations tend to be complex)
   const conversationBonus = messageCount > 10 ? 5 : (messageCount > 5 ? 2 : 0);
-  const adjustedScore = Math.min(totalScore + conversationBonus, 100);
+  let adjustedScore = Math.min(totalScore + conversationBonus, 100);
 
   // Determine recommendation
   const threshold = getThreshold();
@@ -615,7 +832,7 @@ function analyzeComplexity(payload, options = {}) {
     recommendation = adjustedScore >= threshold ? 'cloud' : 'local';
   }
 
-  return {
+  const result = {
     score: adjustedScore,
     threshold,
     mode,
@@ -629,7 +846,39 @@ function analyzeComplexity(payload, options = {}) {
       conversationBonus,
     },
     content: content.slice(0, 100) + (content.length > 100 ? '...' : ''),
+    graphSignals: null,
   };
+
+  // Phase 5: Structural Analysis (code-review-graph, optional)
+  try {
+    const filePaths = extractFilePaths(payload);
+    const graphOpts = { filePaths, workspace: options?.workspace };
+    const graphAvailable = await codeGraph.isAvailable(graphOpts);
+    if (graphAvailable && filePaths.length > 0) {
+      const signals = await codeGraph.getComplexitySignals(filePaths, graphOpts);
+      if (signals) {
+        const { adjustment, reasons } = scoreGraphSignals(signals);
+        result.score = Math.min(result.score + adjustment, 100);
+        result.graphSignals = { ...signals, adjustment, reasons };
+
+        // Re-evaluate recommendation with adjusted score
+        if (taskTypeResult.reason !== 'force_local' && taskTypeResult.reason !== 'force_cloud') {
+          result.recommendation = result.score >= threshold ? 'cloud' : 'local';
+        }
+
+        logger.debug({
+          filePaths: filePaths.slice(0, 5),
+          signals,
+          adjustment,
+          reasons,
+        }, '[complexity] Phase 5: graph signals applied');
+      }
+    }
+  } catch (err) {
+    logger.debug({ err: err.message }, '[complexity] Phase 5: code-graph query failed');
+  }
+
+  return result;
 }
 
 /**
@@ -784,6 +1033,10 @@ module.exports = {
   analyzeWithEmbeddings,
   getContentEmbedding,
 
+  // Phase 5: Structural Analysis (code-review-graph)
+  extractFilePaths,
+  scoreGraphSignals,
+
   // Constants (for testing)
   PATTERNS,
   ADVANCED_PATTERNS,

package/src/routing/index.js

@@ -23,6 +23,11 @@ const { getAgenticDetector, AGENT_TYPES } = require('./agentic-detector');
 const { getModelTierSelector, TIER_DEFINITIONS } = require('./model-tiers');
 const { getCostOptimizer } = require('./cost-optimizer');
 
+// Telemetry modules
+const telemetry = require('./telemetry');
+const { scoreResponseQuality } = require('./quality-scorer');
+const { getLatencyTracker } = require('./latency-tracker');
+
 // Local providers
 const LOCAL_PROVIDERS = ['ollama', 'llamacpp', 'lmstudio'];
 
@@ -148,9 +153,9 @@ async function determineProviderSmart(payload, options = {}) {
     return decision;
   }
 
-  // Full complexity analysis
+  // Full complexity analysis (pass workspace for code-graph integration)
   const useWeightedScoring = config.routing?.weightedScoring ?? false;
-  const analysis = analyzeComplexity(payload, { weighted: useWeightedScoring });
+  const analysis = await analyzeComplexity(payload, { weighted: useWeightedScoring, workspace: options.workspace });
 
   // Phase 4: Optional embeddings adjustment
   let embeddingsResult = null;
@@ -381,4 +386,9 @@ module.exports = {
   getCostOptimizer,
   AGENT_TYPES,
   TIER_DEFINITIONS,
+
+  // Telemetry
+  telemetry,
+  scoreResponseQuality,
+  getLatencyTracker,
 };

package/src/routing/latency-tracker.js

@@ -0,0 +1,148 @@
+/**
+ * Rolling Latency Tracker
+ *
+ * Tracks per-provider latency using circular buffers to provide
+ * P50/P95/P99 percentile statistics for routing decisions.
+ *
+ * @module routing/latency-tracker
+ */
+
+const logger = require("../logger");
+
+/** Size of the circular buffer per provider */
+const BUFFER_SIZE = 200;
+
+/** Minimum sample count before penalizeScore returns a meaningful value */
+const MIN_SAMPLES = 10;
+
+/**
+ * @typedef {Object} LatencyStats
+ * @property {number} p50 - 50th percentile latency (ms)
+ * @property {number} p95 - 95th percentile latency (ms)
+ * @property {number} p99 - 99th percentile latency (ms)
+ * @property {number} avg - Average latency (ms)
+ * @property {number} count - Total measurements recorded
+ * @property {number} lastUpdated - Timestamp of the last recorded measurement
+ */
+
+class LatencyTracker {
+  constructor() {
+    /** @type {Map<string, { buffer: number[], index: number, count: number, lastUpdated: number }>} */
+    this._providers = new Map();
+  }
+
+  /**
+   * Record a latency measurement for a provider.
+   * @param {string} provider - Provider name (e.g. "databricks", "ollama")
+   * @param {number} latencyMs - Measured latency in milliseconds
+   */
+  record(provider, latencyMs) {
+    if (!provider || typeof latencyMs !== "number" || latencyMs < 0) {
+      return;
+    }
+
+    let entry = this._providers.get(provider);
+    if (!entry) {
+      entry = {
+        buffer: new Array(BUFFER_SIZE).fill(0),
+        index: 0,
+        count: 0,
+        lastUpdated: 0,
+      };
+      this._providers.set(provider, entry);
+    }
+
+    entry.buffer[entry.index] = latencyMs;
+    entry.index = (entry.index + 1) % BUFFER_SIZE;
+    entry.count += 1;
+    entry.lastUpdated = Date.now();
+  }
+
+  /**
+   * Get latency statistics for a specific provider.
+   * @param {string} provider - Provider name
+   * @returns {LatencyStats|null} Statistics or null if no data
+   */
+  getStats(provider) {
+    const entry = this._providers.get(provider);
+    if (!entry || entry.count === 0) {
+      return null;
+    }
+
+    const sampleCount = Math.min(entry.count, BUFFER_SIZE);
+    const samples = entry.buffer.slice(0, sampleCount);
+    const sorted = samples.slice().sort((a, b) => a - b);
+
+    const sum = sorted.reduce((acc, v) => acc + v, 0);
+
+    return {
+      p50: sorted[Math.floor(sampleCount * 0.5)],
+      p95: sorted[Math.floor(sampleCount * 0.95)],
+      p99: sorted[Math.floor(sampleCount * 0.99)],
+      avg: Math.round(sum / sampleCount),
+      count: entry.count,
+      lastUpdated: entry.lastUpdated,
+    };
+  }
+
+  /**
+   * Calculate a routing score penalty/bonus based on provider latency.
+   *
+   * Returns a value from -5 to +10 that can be added to a routing score:
+   *   +10 if P95 > 10000ms (very slow, penalise by boosting complexity toward cloud)
+   *   +5  if P95 > 5000ms
+   *   -5  if P50 < 1000ms (fast, reward)
+   *    0  otherwise or if insufficient data
+   *
+   * @param {string} provider - Provider name
+   * @returns {number} Score adjustment (-5 to +10)
+   */
+  penalizeScore(provider) {
+    const stats = this.getStats(provider);
+    if (!stats || stats.count < MIN_SAMPLES) {
+      return 0;
+    }
+
+    if (stats.p95 > 10000) return 10;
+    if (stats.p95 > 5000) return 5;
+    if (stats.p50 < 1000) return -5;
+
+    return 0;
+  }
+
+  /**
+   * Get statistics for all tracked providers.
+   * @returns {Map<string, LatencyStats>}
+   */
+  getAllStats() {
+    const result = new Map();
+    for (const provider of this._providers.keys()) {
+      const stats = this.getStats(provider);
+      if (stats) {
+        result.set(provider, stats);
+      }
+    }
+    return result;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+
+/** @type {LatencyTracker|null} */
+let instance = null;
+
+/**
+ * Get the singleton LatencyTracker instance.
+ * @returns {LatencyTracker}
+ */
+function getLatencyTracker() {
+  if (!instance) {
+    instance = new LatencyTracker();
+    logger.debug("LatencyTracker initialised");
+  }
+  return instance;
+}
+
+module.exports = { LatencyTracker, getLatencyTracker };

package/src/routing/model-tiers.js

@@ -213,6 +213,8 @@ class ModelTierSelector {
         return config.zai?.model || null;
       case 'moonshot':
         return config.moonshot?.model || null;
+      case 'codex':
+        return config.codex?.model || null;
       case 'vertex':
         return config.vertex?.model || null;
       case 'databricks':

package/src/routing/quality-scorer.js

@@ -0,0 +1,113 @@
+/**
+ * Quality Scorer Module
+ *
+ * Lightweight heuristic scorer that evaluates response quality on a 0-100
+ * scale. Used by the telemetry system to detect over/under-provisioned
+ * routing decisions so they can be corrected over time.
+ *
+ * @module routing/quality-scorer
+ */
+
+/**
+ * @typedef {Object} RequestContext
+ * @property {string} [tier] - Routing tier (SIMPLE, MODERATE, COMPLEX, REASONING)
+ * @property {boolean} [hasTools] - Whether the original request included tools
+ */
+
+/**
+ * @typedef {Object} ResponseOutcome
+ * @property {number} [status_code] - HTTP status code
+ * @property {number} [output_tokens] - Tokens produced in the response
+ * @property {number} [tool_calls_made] - Number of tool calls executed
+ * @property {boolean} [was_fallback] - Whether a fallback provider was used
+ * @property {number} [retry_count] - Number of retries before success
+ * @property {string} [error_type] - Error classification if the request failed
+ * @property {number} [latency_ms] - End-to-end latency in milliseconds
+ */
+
+/**
+ * Score the quality of a routed response.
+ *
+ * Starts at 50 and applies additive/subtractive heuristics.
+ * Final value is clamped to [0, 100].
+ *
+ * @param {RequestContext} request - Contextual information about the request
+ * @param {Object} _response - Raw response object (reserved for future use)
+ * @param {ResponseOutcome} outcome - Measured outcome metrics
+ * @returns {number} Quality score in range 0-100
+ */
+function scoreResponseQuality(request, _response, outcome) {
+  let score = 50;
+
+  const {
+    status_code,
+    output_tokens,
+    tool_calls_made,
+    was_fallback,
+    retry_count,
+    error_type,
+    latency_ms,
+  } = outcome || {};
+
+  const tier = request?.tier;
+  const hasTools = request?.hasTools ?? false;
+
+  // --- Positive signals ---
+
+  if (status_code === 200) {
+    score += 10;
+  }
+
+  if (typeof output_tokens === "number" && output_tokens > 100) {
+    score += 5;
+  }
+
+  if (typeof tool_calls_made === "number" && tool_calls_made > 0 && hasTools) {
+    score += 10;
+  }
+
+  if (!was_fallback) {
+    score += 5;
+  }
+
+  if (retry_count === 0) {
+    score += 5;
+  }
+
+  // --- Negative signals ---
+
+  if (error_type) {
+    score -= 30;
+  }
+
+  if (was_fallback) {
+    score -= 10;
+  }
+
+  if (typeof retry_count === "number" && retry_count > 1) {
+    score -= 10;
+  }
+
+  if (typeof latency_ms === "number" && latency_ms > 30000) {
+    score -= 10;
+  }
+
+  if (typeof output_tokens === "number" && output_tokens < 20 && hasTools) {
+    score -= 15;
+  }
+
+  // --- Tier mismatch signals ---
+
+  if (tier === "REASONING" && typeof output_tokens === "number" && output_tokens < 50) {
+    score -= 10;
+  }
+
+  if (tier === "COMPLEX" && typeof latency_ms === "number" && latency_ms < 500) {
+    score -= 5;
+  }
+
+  // Clamp to [0, 100]
+  return Math.max(0, Math.min(100, score));
+}
+
+module.exports = { scoreResponseQuality };