lynkr 3.0.0 → 3.2.0

package/src/prompts/system.js

@@ -0,0 +1,320 @@
+/**
+ * Dynamic System Prompt Optimization
+ *  * Provides utilities for optimizing system prompts and tool descriptions
+ * to reduce token usage while maintaining functionality.
+ *
+ */
+
+const logger = require('../logger');
+const config = require('../config');
+
+/**
+ * Compress tool descriptions to minimal format
+ *
+ * Converts verbose tool schemas to minimal versions by:
+ * - Shortening descriptions
+ * - Removing optional fields when not critical
+ * - Using concise parameter descriptions
+ *
+ * @param {Array} tools - Array of Anthropic-format tool definitions
+ * @param {string} mode - 'minimal' or 'full' (default: from config)
+ * @returns {Array} Optimized tool definitions
+ */
+function compressToolDescriptions(tools, mode = null) {
+  if (!tools || tools.length === 0) return tools;
+
+  mode = mode || config.systemPrompt?.toolDescriptions || 'minimal';
+
+  if (mode !== 'minimal') {
+    return tools; // Return unmodified if not in minimal mode
+  }
+
+  return tools.map(tool => {
+    const compressed = {
+      name: tool.name,
+      input_schema: {
+        type: tool.input_schema.type,
+        properties: {},
+        required: tool.input_schema.required || [],
+      }
+    };
+
+    // Add minimal description only if it exists
+    if (tool.description) {
+      compressed.description = compressText(tool.description, 50);
+    }
+
+    // Compress property descriptions
+    if (tool.input_schema.properties) {
+      for (const [key, value] of Object.entries(tool.input_schema.properties)) {
+        compressed.input_schema.properties[key] = {
+          type: value.type,
+        };
+
+        // Only include description if it's critical
+        if (value.description && !isObviousFromName(key)) {
+          compressed.input_schema.properties[key].description = compressText(value.description, 30);
+        }
+
+        // Preserve enum, format, and other critical constraints
+        if (value.enum) compressed.input_schema.properties[key].enum = value.enum;
+        if (value.format) compressed.input_schema.properties[key].format = value.format;
+        if (value.items) compressed.input_schema.properties[key].items = value.items;
+        if (value.additionalProperties !== undefined) {
+          compressed.input_schema.properties[key].additionalProperties = value.additionalProperties;
+        }
+      }
+    }
+
+    // Preserve additionalProperties if set
+    if (tool.input_schema.additionalProperties !== undefined) {
+      compressed.input_schema.additionalProperties = tool.input_schema.additionalProperties;
+    }
+
+    return compressed;
+  });
+}
+
+/**
+ * Compress text to maximum length while preserving meaning
+ * @param {string} text - Text to compress
+ * @param {number} maxLength - Maximum length
+ * @returns {string} Compressed text
+ */
+function compressText(text, maxLength) {
+  if (!text || text.length <= maxLength) return text;
+
+  // Try to cut at sentence/word boundary
+  let cut = text.substring(0, maxLength);
+  const lastPeriod = cut.lastIndexOf('.');
+  const lastSpace = cut.lastIndexOf(' ');
+
+  if (lastPeriod > maxLength * 0.7) {
+    return cut.substring(0, lastPeriod + 1);
+  } else if (lastSpace > maxLength * 0.8) {
+    return cut.substring(0, lastSpace);
+  }
+
+  return cut;
+}
+
+/**
+ * Check if property name is self-explanatory
+ * @param {string} name - Property name
+ * @returns {boolean} True if name is obvious
+ */
+function isObviousFromName(name) {
+  const obvious = [
+    'id', 'name', 'type', 'value', 'data', 'text', 'content',
+    'message', 'query', 'command', 'url', 'path', 'file', 'filename',
+    'email', 'username', 'password', 'token', 'key', 'timeout',
+    'limit', 'offset', 'page', 'size', 'count', 'total', 'status'
+  ];
+  return obvious.includes(name.toLowerCase());
+}
+
+/**
+ * Optimize system prompt based on context
+ *
+ * Analyzes the system prompt and removes or compresses sections
+ * that aren't relevant to the current context.
+ *
+ * @param {string|Array} system - System prompt (string or content blocks)
+ * @param {Object} context - Context information
+ * @param {Array} context.tools - Tools available in this request
+ * @param {Array} context.messages - Recent messages
+ * @param {string} mode - 'dynamic' or 'full' (default: from config)
+ * @returns {string|Array} Optimized system prompt
+ */
+function optimizeSystemPrompt(system, context = {}, mode = null) {
+  if (!system) return system;
+
+  mode = mode || config.systemPrompt?.mode || 'dynamic';
+
+  if (mode !== 'dynamic') {
+    return system; // Return unmodified if not in dynamic mode
+  }
+
+  // Convert to string if array of blocks
+  let text = typeof system === 'string' ? system : flattenBlocks(system);
+
+  const optimizations = [];
+  const originalLength = text.length;
+
+  // 1. Remove verbose tool usage examples if no tools present
+  if (!context.tools || context.tools.length === 0) {
+    text = removeSection(text, /# Tool Usage Examples?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'tool examples');
+    text = removeSection(text, /<tool_usage>[\s\S]*?<\/tool_usage>/gi, optimizations, 'tool usage blocks');
+  }
+
+  // 2. Remove file operation guidelines if no file tools
+  const hasFileTools = context.tools?.some(t =>
+    ['Read', 'Write', 'Edit', 'Glob', 'Grep'].includes(t.name)
+  );
+  if (!hasFileTools) {
+    text = removeSection(text, /# File Operations?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'file operations');
+  }
+
+  // 3. Remove git guidelines if no git tools
+  const hasGitTools = context.tools?.some(t =>
+    t.name.toLowerCase().includes('git')
+  );
+  if (!hasGitTools) {
+    text = removeSection(text, /# Git.*?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'git guidelines');
+    text = removeSection(text, /## Committing changes[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'git commit guidelines');
+  }
+
+  // 4. Remove web search guidelines if no web tools
+  const hasWebTools = context.tools?.some(t =>
+    ['WebSearch', 'WebFetch'].includes(t.name)
+  );
+  if (!hasWebTools) {
+    text = removeSection(text, /# Web.*?[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'web guidelines');
+  }
+
+  // 5. Compress code review guidelines if no recent code edits
+  const hasRecentEdits = context.messages?.some(m =>
+    typeof m.content === 'string' && m.content.toLowerCase().includes('edit')
+  );
+  if (!hasRecentEdits) {
+    text = removeSection(text, /# Code Review[\s\S]*?(?=\n#|\n\n[A-Z]|$)/gi, optimizations, 'code review');
+  }
+
+  // 6. Remove verbose examples and keep only essential instructions
+  text = text.replace(/(<example>[\s\S]*?<\/example>\s*){3,}/g, (match) => {
+    // Keep first two examples, remove rest
+    const examples = match.match(/<example>[\s\S]*?<\/example>/g) || [];
+    optimizations.push('excessive examples');
+    return examples.slice(0, 2).join('\n\n');
+  });
+
+  // 7. Compress whitespace
+  text = text.replace(/\n{4,}/g, '\n\n\n'); // Max 2 blank lines
+  text = text.replace(/[ \t]+\n/g, '\n'); // Remove trailing spaces
+
+  const finalLength = text.length;
+  const saved = originalLength - finalLength;
+
+  if (saved > 100 && optimizations.length > 0) {
+    logger.debug({
+      originalLength,
+      finalLength,
+      saved,
+      percentage: ((saved / originalLength) * 100).toFixed(1),
+      optimizations: [...new Set(optimizations)]
+    }, 'System prompt optimization applied');
+  }
+
+  // Return in original format (string or blocks)
+  return typeof system === 'string' ? text : text;
+}
+
+/**
+ * Remove a section from text using regex
+ * @param {string} text - Text to modify
+ * @param {RegExp} pattern - Pattern to match
+ * @param {Array} optimizations - Array to track optimizations
+ * @param {string} label - Label for this optimization
+ * @returns {string} Modified text
+ */
+function removeSection(text, pattern, optimizations, label) {
+  const matches = text.match(pattern);
+  if (matches && matches.length > 0) {
+    optimizations.push(label);
+    return text.replace(pattern, '');
+  }
+  return text;
+}
+
+/**
+ * Flatten content blocks to text
+ * @param {Array} blocks - Content blocks
+ * @returns {string} Flattened text
+ */
+function flattenBlocks(blocks) {
+  if (!Array.isArray(blocks)) return String(blocks || '');
+
+  return blocks
+    .map(block => {
+      if (typeof block === 'string') return block;
+      if (block.type === 'text' && block.text) return block.text;
+      if (block.text) return block.text;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+/**
+ * Analyze context to determine what optimizations are safe
+ * @param {Object} context - Request context
+ * @returns {Object} Analysis results
+ */
+function analyzeContext(context) {
+  const analysis = {
+    hasTools: Boolean(context.tools && context.tools.length > 0),
+    toolCount: context.tools?.length || 0,
+    toolNames: context.tools?.map(t => t.name) || [],
+    messageCount: context.messages?.length || 0,
+    hasFileOps: false,
+    hasGitOps: false,
+    hasWebOps: false,
+    hasBashOps: false,
+  };
+
+  if (context.tools) {
+    analysis.hasFileOps = context.tools.some(t =>
+      ['Read', 'Write', 'Edit', 'Glob', 'Grep'].includes(t.name)
+    );
+    analysis.hasGitOps = context.tools.some(t =>
+      t.name.toLowerCase().includes('git')
+    );
+    analysis.hasWebOps = context.tools.some(t =>
+      ['WebSearch', 'WebFetch'].includes(t.name)
+    );
+    analysis.hasBashOps = context.tools.some(t =>
+      ['Bash', 'BashOutput', 'KillShell'].includes(t.name)
+    );
+  }
+
+  return analysis;
+}
+
+/**
+ * Calculate token savings from optimizations
+ * @param {string|Array} original - Original system prompt
+ * @param {string|Array} optimized - Optimized system prompt
+ * @returns {Object} Savings statistics
+ */
+function calculateSavings(original, optimized) {
+  const origText = typeof original === 'string' ? original : flattenBlocks(original);
+  const optText = typeof optimized === 'string' ? optimized : flattenBlocks(optimized);
+
+  const origLength = origText.length;
+  const optLength = optText.length;
+  const saved = origLength - optLength;
+
+  // Rough token estimate (4 chars ≈ 1 token)
+  const tokensOriginal = Math.ceil(origLength / 4);
+  const tokensOptimized = Math.ceil(optLength / 4);
+  const tokensSaved = tokensOriginal - tokensOptimized;
+
+  return {
+    originalChars: origLength,
+    optimizedChars: optLength,
+    charsSaved: saved,
+    tokensOriginal,
+    tokensOptimized,
+    tokensSaved,
+    percentage: origLength > 0 ? ((saved / origLength) * 100).toFixed(1) : '0.0'
+  };
+}
+
+module.exports = {
+  compressToolDescriptions,
+  optimizeSystemPrompt,
+  analyzeContext,
+  calculateSavings,
+  compressText,
+  flattenBlocks,
+};

package/src/tools/index.js

@@ -1,4 +1,5 @@
 const logger = require("../logger");
+const { truncateToolOutput } = require("./truncate");
 
 const registry = new Map();
 const registryLowercase = new Map();
@@ -216,14 +217,22 @@ async function executeToolCall(call, context = {}) {
       context,
     );
     const formatted = normalizeHandlerResult(result);
+
+    // Apply tool output truncation for token efficiency
+    const truncatedContent = truncateToolOutput(normalisedCall.name, formatted.content);
+
     return {
       id: normalisedCall.id,
       name: normalisedCall.name,
       arguments: normalisedCall.arguments,
       ...formatted,
+      content: truncatedContent,
       metadata: {
         ...(formatted.metadata ?? {}),
         registered: true,
+        truncated: truncatedContent !== formatted.content,
+        originalLength: formatted.content?.length,
+        truncatedLength: truncatedContent?.length
       },
     };
   } catch (err) {

package/src/tools/smart-selection.js

@@ -0,0 +1,356 @@
+/**
+ * Smart Tool Selection Module
+ *
+ * Intelligently selects relevant tools based on request type classification.
+ * Reduces tool token overhead by 50-70% for non-coding queries.
+ *
+ * @module tools/smart-selection
+ */
+
+const logger = require('../logger');
+
+/**
+ * Tool selection map: request type → relevant tools
+ */
+const TOOL_SELECTION_MAP = {
+  conversational: [],  // No tools needed for greetings
+  simple_qa: [],       // No tools needed for simple questions
+
+  research: [
+    'Read', 'Grep', 'Glob',           // File search
+    'WebSearch', 'WebFetch'           // Web research
+  ],
+
+  file_reading: [
+    'Read', 'Grep', 'Glob'            // Read-only tools
+  ],
+
+  file_modification: [
+    'Read', 'Write', 'Edit',          // Full I/O
+    'Grep', 'Glob', 'Bash'            // Support tools
+  ],
+
+  code_execution: [
+    'Read', 'Write', 'Edit',          // File operations
+    'Bash', 'Grep', 'Glob'            // Execution + search
+  ],
+
+  coding: [
+    'Read', 'Write', 'Edit',          // Core file ops
+    'Bash', 'Grep', 'Glob'            // Support tools
+  ],
+
+  complex_task: [
+    'Read', 'Write', 'Edit',          // Tier 1
+    'Bash', 'Grep', 'Glob',           // Tier 1
+    'WebSearch', 'WebFetch',          // Tier 2
+    'Task', 'TodoWrite', 'AskUserQuestion'  // Tier 3+4
+  ]
+};
+
+/**
+ * Extract content from last user message
+ */
+function getLastUserMessage(payload) {
+  if (!Array.isArray(payload.messages) || payload.messages.length === 0) {
+    return null;
+  }
+
+  // Find last user message
+  for (let i = payload.messages.length - 1; i >= 0; i--) {
+    const msg = payload.messages[i];
+    if (msg?.role === 'user') {
+      return msg;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract text content from message (handles string or array format)
+ */
+function extractContent(message) {
+  if (!message) return '';
+
+  if (typeof message.content === 'string') {
+    return message.content;
+  }
+
+  if (Array.isArray(message.content)) {
+    return message.content
+      .filter(block => block?.type === 'text')
+      .map(block => block.text || '')
+      .join(' ');
+  }
+
+  return '';
+}
+
+/**
+ * Check if content matches greeting patterns
+ */
+function isGreeting(content) {
+  const greetingPattern = /^(hi|hello|hey|good morning|good afternoon|good evening|howdy|greetings|sup|yo)[\s\.\!\?]*$/i;
+  return greetingPattern.test(content.trim());
+}
+
+/**
+ * Check if content is short and non-technical
+ */
+function isShortNonTechnical(content) {
+  const trimmed = content.trim();
+
+  // Very short messages (< 20 chars)
+  if (trimmed.length >= 20) return false;
+
+  // Check for technical keywords
+  const technicalKeywords = /code|file|function|error|bug|fix|write|read|create|implement|class|module|import|export|async|await/i;
+  return !technicalKeywords.test(trimmed);
+}
+
+/**
+ * Check if content is a simple question
+ */
+function isSimpleQuestion(content) {
+  const questionPattern = /^(what is|what's|how does|when|where|why|explain|define|tell me about|can you explain)/i;
+  return questionPattern.test(content.trim());
+}
+
+/**
+ * Check for technical keywords
+ */
+function hasTechnicalKeywords(content) {
+  const technicalPattern = /code|function|class|file|module|import|export|async|await|promise|callback|api|database|server|client|component|method|variable|array|object|string|number/i;
+  return technicalPattern.test(content);
+}
+
+/**
+ * Check for explanation/research keywords
+ */
+function hasExplanationKeywords(content) {
+  const explanationPattern = /explain|describe|summarize|what does|how does|tell me about|give me an overview|clarify|elaborate/i;
+  return explanationPattern.test(content);
+}
+
+/**
+ * Check for web/search keywords
+ */
+function hasWebKeywords(content) {
+  const webPattern = /search|lookup|find info|google|documentation|docs|website|url|link|online|internet|browse/i;
+  return webPattern.test(content);
+}
+
+/**
+ * Check for file reading keywords
+ */
+function hasReadKeywords(content) {
+  const readPattern = /read|show|display|view|cat|check|inspect|look at|see|examine|review|print|output/i;
+  return readPattern.test(content);
+}
+
+/**
+ * Check for file writing/modification keywords
+ */
+function hasWriteKeywords(content) {
+  const writePattern = /write|create|add|update|modify|change|fix|delete|remove|insert|append|replace|save/i;
+  return writePattern.test(content);
+}
+
+/**
+ * Check for edit/refactor keywords
+ */
+function hasEditKeywords(content) {
+  const editPattern = /edit|refactor|rename|move|reorganize|restructure|rewrite/i;
+  return editPattern.test(content);
+}
+
+/**
+ * Check for execution/testing keywords
+ */
+function hasExecutionKeywords(content) {
+  const executionPattern = /run|execute|test|compile|build|deploy|start|install|launch|boot|fire up|npm|git|python|node|docker|bash|sh|cmd/i;
+  return executionPattern.test(content);
+}
+
+/**
+ * Check for complex task keywords
+ */
+function hasComplexKeywords(content) {
+  const complexPattern = /implement|build|create|develop|design|architect|plan|strategy|approach|help with|work on|improve|optimize|enhance|refactor|migrate/i;
+  return complexPattern.test(content);
+}
+
+/**
+ * Classify request type based on content analysis
+ *
+ * @param {Object} payload - Request payload with messages
+ * @returns {Object} Classification result { type, confidence, keywords }
+ */
+function classifyRequestType(payload) {
+  const lastMessage = getLastUserMessage(payload);
+
+  if (!lastMessage) {
+    logger.debug('No user message found for classification');
+    return { type: 'coding', confidence: 0.5, keywords: [] };
+  }
+
+  const content = extractContent(lastMessage);
+  const contentLower = content.toLowerCase();
+  const messageCount = payload.messages?.length ?? 0;
+
+  logger.debug({
+    contentLength: content.length,
+    messageCount,
+    contentPreview: content.substring(0, 100)
+  }, 'Classifying request type');
+
+  // 1. Conversational (no tools)
+  if (isGreeting(contentLower)) {
+    return { type: 'conversational', confidence: 1.0, keywords: ['greeting'] };
+  }
+
+  if (isShortNonTechnical(contentLower)) {
+    return { type: 'conversational', confidence: 0.8, keywords: ['short', 'non-technical'] };
+  }
+
+  // 2. Simple Q&A (no tools)
+  if (isSimpleQuestion(contentLower) && !hasTechnicalKeywords(contentLower)) {
+    return { type: 'simple_qa', confidence: 0.9, keywords: ['question', 'non-technical'] };
+  }
+
+  // 3. Research/Explanation (minimal tools)
+  if (hasExplanationKeywords(contentLower)) {
+    return { type: 'research', confidence: 0.85, keywords: ['explanation'] };
+  }
+
+  if (hasWebKeywords(contentLower)) {
+    return { type: 'research', confidence: 0.9, keywords: ['web', 'search'] };
+  }
+
+  // 4. File reading (read-only tools)
+  if (hasReadKeywords(contentLower) && !hasWriteKeywords(contentLower)) {
+    return { type: 'file_reading', confidence: 0.8, keywords: ['read'] };
+  }
+
+  // 5. File modification (full I/O tools)
+  if (hasWriteKeywords(contentLower) || hasEditKeywords(contentLower)) {
+    return { type: 'file_modification', confidence: 0.85, keywords: ['write', 'edit'] };
+  }
+
+  // 6. Execution/Testing (execution tools)
+  if (hasExecutionKeywords(contentLower)) {
+    return { type: 'code_execution', confidence: 0.8, keywords: ['execution'] };
+  }
+
+  // 7. Complex task (all tools)
+  if (hasComplexKeywords(contentLower)) {
+    return { type: 'complex_task', confidence: 0.75, keywords: ['complex'] };
+  }
+
+  // Long conversations likely need more tools
+  if (messageCount > 10) {
+    return { type: 'complex_task', confidence: 0.7, keywords: ['long_conversation'] };
+  }
+
+  // Default: coding (core tools)
+  return { type: 'coding', confidence: 0.6, keywords: ['default'] };
+}
+
+/**
+ * Estimate token count for tools (rough approximation)
+ */
+function estimateToolTokens(tools) {
+  if (!Array.isArray(tools)) return 0;
+
+  // Average: ~175 tokens per tool (based on STANDARD_TOOLS analysis)
+  return tools.length * 175;
+}
+
+/**
+ * Select relevant tools based on classification
+ *
+ * @param {Array} tools - Available tools
+ * @param {Object} classification - Classification result from classifyRequestType
+ * @param {Object} options - Selection options (provider, tokenBudget, config)
+ * @returns {Array} Filtered list of relevant tools
+ */
+function selectToolsSmartly(tools, classification, options = {}) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return tools;
+  }
+
+  const { provider = 'databricks', tokenBudget = 2500, config = {} } = options;
+  const requestType = classification.type || 'coding';
+
+  // Get relevant tool names for this request type
+  const relevantToolNames = TOOL_SELECTION_MAP[requestType] || TOOL_SELECTION_MAP.coding;
+
+  logger.debug({
+    requestType,
+    confidence: classification.confidence,
+    relevantToolNames,
+    mode: config.mode
+  }, 'Selecting tools for request type');
+
+  // Filter to relevant tools only
+  let selectedTools = tools.filter(tool => relevantToolNames.includes(tool.name));
+
+  // Mode-specific adjustments
+  if (config.mode === 'aggressive') {
+    // Aggressive: Further reduce tools for ambiguous cases
+    if (classification.confidence < 0.7 && selectedTools.length > 4) {
+      selectedTools = selectedTools.slice(0, 4);
+    }
+  } else if (config.mode === 'conservative') {
+    // Conservative: Include one extra tier of tools for safety
+    if (requestType === 'file_reading' && !relevantToolNames.includes('Bash')) {
+      const bashTool = tools.find(t => t.name === 'Bash');
+      if (bashTool) selectedTools.push(bashTool);
+    }
+  }
+
+  // Provider-specific limits
+  if (provider === 'ollama' && selectedTools.length > 8) {
+    logger.debug({
+      originalCount: selectedTools.length,
+      limit: 8
+    }, 'Limiting tools for Ollama provider');
+    selectedTools = selectedTools.slice(0, 8);
+  }
+
+  // Token budget enforcement
+  const estimatedTokens = estimateToolTokens(selectedTools);
+  if (estimatedTokens > tokenBudget) {
+    const targetCount = Math.floor(tokenBudget / 175);
+    logger.debug({
+      estimatedTokens,
+      tokenBudget,
+      targetCount
+    }, 'Enforcing token budget on tools');
+    selectedTools = selectedTools.slice(0, Math.max(targetCount, 0));
+  }
+
+  // Minimal mode override (if configured)
+  if (config.minimalMode) {
+    const minimalTools = ['Read', 'Write', 'Edit', 'Bash'];
+    selectedTools = selectedTools.filter(t => minimalTools.includes(t.name));
+  }
+
+  logger.info({
+    requestType,
+    originalToolCount: tools.length,
+    selectedToolCount: selectedTools.length,
+    removedToolCount: tools.length - selectedTools.length,
+    estimatedTokenSavings: estimateToolTokens(tools) - estimateToolTokens(selectedTools)
+  }, 'Smart tool selection completed');
+
+  return selectedTools;
+}
+
+module.exports = {
+  classifyRequestType,
+  selectToolsSmartly,
+  estimateToolTokens,
+  TOOL_SELECTION_MAP
+};