lynkr 7.2.5 → 8.0.0

package/src/routing/agentic-detector.js

@@ -0,0 +1,320 @@
+/**
+ * Agentic Workflow Detector
+ * Detects multi-step tool chains and autonomous agent patterns
+ * Used to boost complexity tier for agentic workloads
+ */
+
+const logger = require('../logger');
+
+// Agent type classification with tier requirements
+const AGENT_TYPES = {
+  SINGLE_SHOT: {
+    minTier: 'SIMPLE',
+    scoreBoost: 0,
+    description: 'Simple request-response, no tool chains',
+  },
+  TOOL_CHAIN: {
+    minTier: 'MEDIUM',
+    scoreBoost: 15,
+    requiresToolUse: true,
+    description: 'Sequential tool usage (read -> edit -> test)',
+  },
+  ITERATIVE: {
+    minTier: 'COMPLEX',
+    scoreBoost: 25,
+    requiresToolUse: true,
+    description: 'Retry loops, debugging cycles, iterative refinement',
+  },
+  AUTONOMOUS: {
+    minTier: 'REASONING',
+    scoreBoost: 35,
+    requiresToolUse: true,
+    description: 'Open-ended tasks, full autonomy, complex decision making',
+  },
+};
+
+// Detection patterns
+const PATTERNS = {
+  // Tool chain indicators
+  toolChain: /\b(then\s+use|after\s+that|next\s+step|finally|first.*then|step\s*\d+)\b/i,
+
+  // Iterative work indicators
+  iterative: /\b(keep\s+trying|until|repeat|loop|retry|iterate|fix.*again|try.*different|debug)\b/i,
+
+  // Autonomous work indicators
+  autonomous: /\b(figure\s+out|solve|complete\s+the\s+task|do\s+whatever|make\s+it\s+work|find\s+a\s+way|whatever\s+it\s+takes)\b/i,
+
+  // Multi-file work
+  multiFile: /\b(multiple\s+files?|across\s+(the\s+)?codebase|all\s+files?|refactor\s+entire|whole\s+project|everywhere)\b/i,
+
+  // Planning indicators
+  planning: /\b(plan|design|architect|strategy|roadmap|approach|how\s+would\s+you)\b/i,
+
+  // Implementation indicators
+  implementation: /\b(implement|build|create|develop|write|code|add\s+feature)\b/i,
+
+  // Analysis indicators
+  analysis: /\b(analyze|investigate|understand|explain|why\s+is|what\s+causes|root\s+cause)\b/i,
+
+  // Testing indicators
+  testing: /\b(test|verify|validate|check|ensure|confirm|make\s+sure)\b/i,
+};
+
+// High-complexity tools that indicate agentic work
+const AGENTIC_TOOLS = new Set([
+  // Execution tools
+  'Bash', 'bash', 'shell', 'execute', 'run_command',
+  // Write tools
+  'Write', 'write_file', 'fs_write', 'create_file',
+  // Edit tools
+  'Edit', 'edit_file', 'fs_edit', 'edit_patch', 'str_replace_editor',
+  // Agent tools
+  'Task', 'agent_task', 'spawn_agent', 'delegate',
+  // Git tools
+  'Git', 'git_commit', 'git_push', 'git_create_branch',
+  // Test tools
+  'Test', 'run_tests', 'pytest', 'jest',
+  // Notebook tools
+  'NotebookEdit', 'notebook_edit',
+]);
+
+// Read-only tools (lower complexity)
+const READ_ONLY_TOOLS = new Set([
+  'Read', 'read_file', 'fs_read',
+  'Glob', 'glob', 'find_files',
+  'Grep', 'grep', 'search', 'ripgrep',
+  'WebFetch', 'web_fetch', 'fetch_url',
+  'WebSearch', 'web_search',
+]);
+
+class AgenticDetector {
+  /**
+   * Detect agentic workflow patterns
+   * @param {Object} payload - Request payload with messages and tools
+   * @returns {Object} Detection result
+   */
+  detect(payload) {
+    const messages = payload?.messages || [];
+    const tools = payload?.tools || [];
+    const content = this._extractContent(messages);
+
+    let score = 0;
+    const signals = [];
+
+    // Signal 1: Tool count (many tools = likely multi-step)
+    const toolCount = tools.length;
+    if (toolCount > 10) {
+      score += 25;
+      signals.push({ signal: 'very_high_tool_count', value: toolCount, weight: 25 });
+    } else if (toolCount > 5) {
+      score += 15;
+      signals.push({ signal: 'high_tool_count', value: toolCount, weight: 15 });
+    } else if (toolCount > 3) {
+      score += 8;
+      signals.push({ signal: 'moderate_tool_count', value: toolCount, weight: 8 });
+    }
+
+    // Signal 2: Agentic tools present (Bash, Write, Edit, Task)
+    const agenticToolCount = tools.filter(t => {
+      const name = t.name || t.function?.name || '';
+      return AGENTIC_TOOLS.has(name);
+    }).length;
+
+    if (agenticToolCount > 3) {
+      score += 25;
+      signals.push({ signal: 'many_agentic_tools', value: agenticToolCount, weight: 25 });
+    } else if (agenticToolCount > 1) {
+      score += 15;
+      signals.push({ signal: 'has_agentic_tools', value: agenticToolCount, weight: 15 });
+    } else if (agenticToolCount === 1) {
+      score += 8;
+      signals.push({ signal: 'single_agentic_tool', value: agenticToolCount, weight: 8 });
+    }
+
+    // Signal 3: Prior tool results (already in agentic loop)
+    const toolResultCount = this._countToolResults(messages);
+    if (toolResultCount > 5) {
+      score += 30;
+      signals.push({ signal: 'deep_tool_loop', value: toolResultCount, weight: 30 });
+    } else if (toolResultCount > 2) {
+      score += 20;
+      signals.push({ signal: 'active_tool_loop', value: toolResultCount, weight: 20 });
+    } else if (toolResultCount > 0) {
+      score += 10;
+      signals.push({ signal: 'has_tool_results', value: toolResultCount, weight: 10 });
+    }
+
+    // Signal 4: Pattern matching on content
+    if (PATTERNS.autonomous.test(content)) {
+      score += 25;
+      signals.push({ signal: 'autonomous_pattern', weight: 25 });
+    }
+
+    if (PATTERNS.iterative.test(content)) {
+      score += 20;
+      signals.push({ signal: 'iterative_pattern', weight: 20 });
+    }
+
+    if (PATTERNS.toolChain.test(content)) {
+      score += 15;
+      signals.push({ signal: 'tool_chain_pattern', weight: 15 });
+    }
+
+    if (PATTERNS.multiFile.test(content)) {
+      score += 15;
+      signals.push({ signal: 'multi_file_work', weight: 15 });
+    }
+
+    if (PATTERNS.planning.test(content)) {
+      score += 10;
+      signals.push({ signal: 'planning_required', weight: 10 });
+    }
+
+    if (PATTERNS.implementation.test(content) && PATTERNS.testing.test(content)) {
+      score += 15;
+      signals.push({ signal: 'implementation_with_testing', weight: 15 });
+    }
+
+    // Signal 5: Conversation depth
+    const messageCount = messages.length;
+    if (messageCount > 15) {
+      score += 20;
+      signals.push({ signal: 'very_deep_conversation', value: messageCount, weight: 20 });
+    } else if (messageCount > 8) {
+      score += 12;
+      signals.push({ signal: 'deep_conversation', value: messageCount, weight: 12 });
+    } else if (messageCount > 4) {
+      score += 6;
+      signals.push({ signal: 'ongoing_conversation', value: messageCount, weight: 6 });
+    }
+
+    // Signal 6: Content length (longer prompts often = more complex tasks)
+    if (content.length > 2000) {
+      score += 10;
+      signals.push({ signal: 'long_prompt', value: content.length, weight: 10 });
+    }
+
+    // Determine agent type
+    const agentType = this._classifyAgentType(score, signals);
+    const isAgentic = score >= 25;
+
+    const result = {
+      isAgentic,
+      agentType,
+      confidence: Math.min(score / 100, 1),
+      score,
+      signals,
+      minTier: AGENT_TYPES[agentType].minTier,
+      scoreBoost: AGENT_TYPES[agentType].scoreBoost,
+      description: AGENT_TYPES[agentType].description,
+    };
+
+    if (isAgentic) {
+      logger.debug({
+        agentType,
+        score,
+        signalCount: signals.length,
+        toolCount,
+        toolResultCount,
+      }, '[AgenticDetector] Agentic workflow detected');
+    }
+
+    return result;
+  }
+
+  /**
+   * Classify agent type based on score and signals
+   */
+  _classifyAgentType(score, signals) {
+    // Check for specific signal combinations
+    const hasAutonomousPattern = signals.some(s => s.signal === 'autonomous_pattern');
+    const hasDeepToolLoop = signals.some(s => s.signal === 'deep_tool_loop');
+    const hasManyAgenticTools = signals.some(s => s.signal === 'many_agentic_tools');
+
+    // Autonomous: high score + autonomous pattern or very deep tool usage
+    if (score >= 60 || (hasAutonomousPattern && score >= 40)) {
+      return 'AUTONOMOUS';
+    }
+
+    // Iterative: moderate-high score with tool loops
+    if (score >= 40 || (hasDeepToolLoop && score >= 30)) {
+      return 'ITERATIVE';
+    }
+
+    // Tool chain: some tool usage indicated
+    if (score >= 20 || hasManyAgenticTools) {
+      return 'TOOL_CHAIN';
+    }
+
+    return 'SINGLE_SHOT';
+  }
+
+  /**
+   * Extract user content from messages
+   */
+  _extractContent(messages) {
+    const userMsgs = messages.filter(m => m?.role === 'user');
+    if (userMsgs.length === 0) return '';
+
+    // Get last user message
+    const last = userMsgs[userMsgs.length - 1];
+
+    if (typeof last.content === 'string') {
+      return last.content;
+    }
+
+    if (Array.isArray(last.content)) {
+      return last.content
+        .filter(block => block?.type === 'text')
+        .map(block => block.text || '')
+        .join(' ');
+    }
+
+    return '';
+  }
+
+  /**
+   * Count tool results in conversation
+   */
+  _countToolResults(messages) {
+    let count = 0;
+
+    for (const msg of messages) {
+      if (msg?.role === 'user' && Array.isArray(msg.content)) {
+        count += msg.content.filter(c => c?.type === 'tool_result').length;
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Get detection stats for debugging
+   */
+  getPatternStats(content) {
+    const stats = {};
+    for (const [name, pattern] of Object.entries(PATTERNS)) {
+      stats[name] = pattern.test(content);
+    }
+    return stats;
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+function getAgenticDetector() {
+  if (!instance) {
+    instance = new AgenticDetector();
+  }
+  return instance;
+}
+
+module.exports = {
+  AgenticDetector,
+  getAgenticDetector,
+  AGENT_TYPES,
+  PATTERNS,
+  AGENTIC_TOOLS,
+  READ_ONLY_TOOLS,
+};

package/src/routing/complexity-analyzer.js

@@ -88,6 +88,58 @@ const FORCE_LOCAL_PATTERNS = [
   /^(help|menu|commands?|options?)[\s\.\!\?]*$/i,
 ];
 
+// Weighted Scoring (15 Dimensions)
+const DIMENSION_WEIGHTS = {
+  // Content Analysis (35%)
+  tokenCount: 0.08,
+  promptComplexity: 0.10,
+  technicalDepth: 0.10,
+  domainSpecificity: 0.07,
+  // Tool Analysis (25%)
+  toolCount: 0.08,
+  toolComplexity: 0.10,
+  toolChainPotential: 0.07,
+  // Reasoning Requirements (25%)
+  multiStepReasoning: 0.10,
+  codeGeneration: 0.08,
+  analysisDepth: 0.07,
+  // Context Factors (15%)
+  conversationDepth: 0.05,
+  priorToolUsage: 0.05,
+  ambiguity: 0.05,
+};
+
+// Tool complexity weights (higher = more complex)
+const TOOL_COMPLEXITY_WEIGHTS = {
+  Bash: 0.9,
+  bash: 0.9,
+  shell: 0.9,
+  Write: 0.8,
+  write_file: 0.8,
+  Edit: 0.7,
+  edit_file: 0.7,
+  NotebookEdit: 0.7,
+  Task: 0.9,
+  agent_task: 0.9,
+  WebSearch: 0.5,
+  WebFetch: 0.4,
+  Read: 0.3,
+  read_file: 0.3,
+  Glob: 0.2,
+  Grep: 0.2,
+  default: 0.5,
+};
+
+// Domain-specific keywords for complexity
+const DOMAIN_KEYWORDS = {
+  security: /\b(auth|encrypt|vulnerability|injection|xss|csrf|jwt|oauth|password|credential|secret)\b/i,
+  ml: /\b(model|train|inference|tensor|embedding|neural|llm|gpt|transformer|pytorch|tensorflow)\b/i,
+  distributed: /\b(microservice|kafka|redis|queue|scale|cluster|replicate|kubernetes|docker|container)\b/i,
+  database: /\b(sql|nosql|migration|index|query|transaction|orm|postgres|mongodb|mysql)\b/i,
+  frontend: /\b(react|vue|angular|svelte|css|html|component|state|redux|hooks)\b/i,
+  devops: /\b(ci\/cd|pipeline|deploy|terraform|ansible|github\s*actions|jenkins)\b/i,
+};
+
 // ============================================================================
 // PHASE 3: Metrics Tracking
 // ============================================================================
@@ -360,6 +412,116 @@ function scoreReasoning(content) {
   return { score: Math.min(score, 15), reasons };
 }
 
+// ============================================================================
+// WEIGHTED SCORING FUNCTION (15 Dimensions)
+// ============================================================================
+
+/**
+ * Calculate weighted complexity score (0-100)
+ * Uses 15 dimensions with configurable weights
+ * @param {Object} payload - Request payload
+ * @param {string} content - Extracted content
+ * @returns {Object} Weighted score result
+ */
+function calculateWeightedScore(payload, content) {
+  const dimensions = {};
+
+  // 1. Token count (0-100)
+  const tokens = estimateTokens(payload);
+  dimensions.tokenCount = tokens < 500 ? 10 : tokens < 2000 ? 30 : tokens < 5000 ? 50 : tokens < 10000 ? 70 : 90;
+
+  // 2. Prompt complexity (sentence structure, avg length)
+  const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+  const avgLength = content.length / Math.max(sentences.length, 1);
+  dimensions.promptComplexity = Math.min(avgLength / 2, 100);
+
+  // 3. Technical depth (keyword density)
+  const techMatches = (content.match(PATTERNS.technical) || []).length;
+  dimensions.technicalDepth = Math.min(techMatches * 15, 100);
+
+  // 4. Domain specificity (how many domains are touched)
+  let domainScore = 0;
+  const domainsMatched = [];
+  for (const [domain, regex] of Object.entries(DOMAIN_KEYWORDS)) {
+    if (regex.test(content)) {
+      domainScore += 20;
+      domainsMatched.push(domain);
+    }
+  }
+  dimensions.domainSpecificity = Math.min(domainScore, 100);
+
+  // 5. Tool count
+  const toolCount = payload?.tools?.length ?? 0;
+  dimensions.toolCount = toolCount === 0 ? 0 :
+    toolCount <= 3 ? 20 :
+    toolCount <= 6 ? 40 :
+    toolCount <= 10 ? 60 :
+    toolCount <= 15 ? 80 : 100;
+
+  // 6. Tool complexity (weighted by tool types)
+  if (payload?.tools?.length > 0) {
+    const totalWeight = payload.tools.reduce((sum, t) => {
+      const name = t.name || t.function?.name || '';
+      return sum + (TOOL_COMPLEXITY_WEIGHTS[name] || TOOL_COMPLEXITY_WEIGHTS.default);
+    }, 0);
+    const avgWeight = totalWeight / payload.tools.length;
+    dimensions.toolComplexity = avgWeight * 100;
+  } else {
+    dimensions.toolComplexity = 0;
+  }
+
+  // 7. Tool chain potential (sequential operations)
+  dimensions.toolChainPotential = /\b(then|after|next|finally|first.*then|step\s*\d+)\b/i.test(content) ? 70 : 20;
+
+  // 8. Multi-step reasoning
+  dimensions.multiStepReasoning = ADVANCED_PATTERNS.reasoning.stepByStep.test(content) ? 80 :
+    ADVANCED_PATTERNS.reasoning.planning.test(content) ? 60 : 20;
+
+  // 9. Code generation requirement
+  dimensions.codeGeneration = /\b(write|create|implement|build|generate)\s+(a\s+)?(new\s+)?(function|class|module|api|endpoint|service|component)/i.test(content) ? 80 : 20;
+
+  // 10. Analysis depth
+  dimensions.analysisDepth = ADVANCED_PATTERNS.reasoning.tradeoffs.test(content) ? 80 :
+    ADVANCED_PATTERNS.reasoning.analysis.test(content) ? 60 : 20;
+
+  // 11. Conversation depth
+  const messageCount = payload?.messages?.length ?? 0;
+  dimensions.conversationDepth = messageCount < 3 ? 10 :
+    messageCount < 6 ? 30 :
+    messageCount < 10 ? 50 : 70;
+
+  // 12. Prior tool usage (tool results in conversation)
+  const toolResults = (payload?.messages || []).filter(m =>
+    m.role === 'user' && Array.isArray(m.content) && m.content.some(c => c.type === 'tool_result')
+  ).length;
+  dimensions.priorToolUsage = toolResults === 0 ? 10 :
+    toolResults < 3 ? 40 :
+    toolResults < 6 ? 60 : 80;
+
+  // 13. Ambiguity (inverse of specificity)
+  const hasSpecifics = /\b(file|function|line\s*\d+|error|bug|at\s+[\w.]+:\d+|\/[\w/]+\.\w+)\b/i.test(content);
+  dimensions.ambiguity = hasSpecifics ? 20 : content.length < 50 ? 70 : 40;
+
+  // Calculate weighted total
+  let weightedTotal = 0;
+  for (const [dimension, weight] of Object.entries(DIMENSION_WEIGHTS)) {
+    weightedTotal += (dimensions[dimension] || 0) * weight;
+  }
+
+  return {
+    score: Math.round(weightedTotal),
+    dimensions,
+    weights: DIMENSION_WEIGHTS,
+    meta: {
+      tokens,
+      toolCount,
+      messageCount,
+      toolResults,
+      domainsMatched,
+    },
+  };
+}
+
 /**
  * Get threshold based on SMART_TOOL_SELECTION_MODE
  */
@@ -381,13 +543,45 @@ function getThreshold() {
  * Analyze request complexity and return full analysis
  *
  * @param {Object} payload - Request payload
+ * @param {Object} options - Analysis options
  * @returns {Object} Complexity analysis result
  */
-function analyzeComplexity(payload) {
+function analyzeComplexity(payload, options = {}) {
   const content = extractContent(payload);
   const messageCount = payload?.messages?.length ?? 0;
+  const useWeighted = options.weighted ?? config.routing?.weightedScoring ?? false;
+
+  // Use weighted scoring if enabled
+  if (useWeighted) {
+    const weighted = calculateWeightedScore(payload, content);
+    const threshold = getThreshold();
+    const mode = config.smartToolSelection?.mode ?? 'heuristic';
+
+    // Check force patterns
+    const taskTypeResult = scoreTaskType(content);
+    let recommendation;
+    if (taskTypeResult.reason === 'force_local') {
+      recommendation = 'local';
+    } else if (taskTypeResult.reason === 'force_cloud') {
+      recommendation = 'cloud';
+    } else {
+      recommendation = weighted.score >= threshold ? 'cloud' : 'local';
+    }
 
-  // Calculate individual scores
+    return {
+      score: weighted.score,
+      threshold,
+      mode: 'weighted',
+      recommendation,
+      breakdown: weighted.dimensions,
+      weights: weighted.weights,
+      meta: weighted.meta,
+      forceReason: taskTypeResult.reason?.startsWith('force_') ? taskTypeResult.reason : null,
+      content: content.slice(0, 100) + (content.length > 100 ? '...' : ''),
+    };
+  }
+
+  // Standard scoring (original logic)
   const tokenScore = scoreTokens(payload);
   const toolScore = scoreTools(payload);
   const taskTypeResult = scoreTaskType(content);
@@ -577,6 +771,9 @@ module.exports = {
   scoreCodeComplexity,
   scoreReasoning,
 
+  // Weighted scoring
+  calculateWeightedScore,
+
   // Configuration
   getThreshold,
 
@@ -592,4 +789,7 @@ module.exports = {
   ADVANCED_PATTERNS,
   FORCE_CLOUD_PATTERNS,
   FORCE_LOCAL_PATTERNS,
+  DIMENSION_WEIGHTS,
+  TOOL_COMPLEXITY_WEIGHTS,
+  DOMAIN_KEYWORDS,
 };