@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/scripts/lib/intent-classifier.js

@@ -0,0 +1,1075 @@
+/**
+ * Intent Classifier - Semantic Intent Detection for Prompt Routing
+ *
+ * Detects user intent from natural language prompts and returns
+ * confidence scores for routing to appropriate commands/agents.
+ *
+ * Performance Target: <10ms per classification
+ *
+ * @module intent-classifier
+ */
+
+/**
+ * Intent types supported by the classifier
+ */
+const INTENT_TYPES = {
+  PLANNING: 'PLANNING',
+  TESTING: 'TESTING',
+  REVIEW: 'REVIEW',
+  SECURITY: 'SECURITY',
+  COMPLIANCE: 'COMPLIANCE',
+  ZOHO: 'ZOHO',
+  DEPLOY: 'DEPLOY',
+  REFACTOR: 'REFACTOR',
+  DEBUG: 'DEBUG',
+  // New intent types for full documentation alignment
+  LEARNING: 'LEARNING',
+  SETUP: 'SETUP',
+  HANDOFF: 'HANDOFF',
+  E2E: 'E2E',
+  DOCUMENTATION: 'DOCUMENTATION',
+  UNKNOWN: 'UNKNOWN',
+};
+
+/**
+ * Confidence thresholds
+ */
+const THRESHOLDS = {
+  AUTO_CONVERT: 0.75, // High confidence - auto-convert without asking (lowered for better UX)
+  SUGGEST: 0.5, // Medium confidence - suggest but ask
+  MINIMUM: 0.25, // Below this, classify as UNKNOWN (lowered to support single-typo matches)
+};
+
+/**
+ * Intent patterns with weighted keywords and phrases
+ *
+ * Structure:
+ * - keywords: Single words that indicate intent (lower weight)
+ * - phrases: Multi-word patterns that strongly indicate intent (higher weight)
+ * - priority: Used for tie-breaking when multiple intents match
+ */
+const INTENT_PATTERNS = {
+  PLANNING: {
+    keywords: [
+      'plan',
+      'design',
+      'architect',
+      'approach',
+      'strategy',
+      'structure',
+      'organize',
+      'figure',
+      'think',
+      // Development verbs - critical for feature requests
+      'create',
+      'implement',
+      'build',
+      'develop',
+      'make',
+      'add',
+      'integrate',
+      'feature',
+      'module',
+      'component',
+    ],
+    phrases: [
+      /\b(how should|what's the best way|best approach)\b/i,
+      /\b(plan (for|the|this|a|an))\b/i,
+      /\b(need to plan)\b/i,
+      /\b(design (the|a|an))\b/i,
+      /\b(architect (a|an|the))\b/i,
+      /\b(help me (plan|design|architect))\b/i,
+      /\b(implementation strategy)\b/i,
+      /\b(figure out (how|the))\b/i,
+      /\bapproach (for|this|the)\b/i,
+      /\blets plan\b/i,
+      /\bwant to architect\b/i,
+      // Development verb phrases - critical for feature requests
+      /\b(add\s+(a\s+)?(feature|functionality|capability|endpoint|module|component))\b/i,
+      /\b(add\s+(a\s+)?(new\s+)?[a-z]+\s+(feature|to))\b/i,
+      /\b(create\s+(a|an|the|new))\b/i,
+      /\b(implement\s+(the|a|an|new))\b/i,
+      /\b(build\s+(the|a|an|new))\b/i,
+      /\b(develop\s+(the|a|an))\b/i,
+      /\b(integrate\s+(with|the|a))\b/i,
+      /\b(need\s+to\s+(create|build|implement|add|develop))\b/i,
+      /\b(help\s+me\s+(create|build|implement|add|develop))\b/i,
+      /\b(want\s+to\s+(create|build|implement|add|develop))\b/i,
+      /\bnew\s+(module|feature|system|api|endpoint|service|component)\b/i,
+    ],
+    priority: 3,
+  },
+
+  TESTING: {
+    keywords: [
+      'test',
+      'tests',
+      'testing',
+      'coverage',
+      'tdd',
+      'unit',
+      'integration',
+      'spec',
+      'jest',
+      'vitest',
+      // Technical synonyms
+      'validate',
+      'validation',
+      'verify',
+      'verification',
+      'assert',
+      'assertions',
+      'suite',
+      'specs',
+      'mocha',
+      'ava',
+      'pytest',
+      'qa',
+      'mock',
+      'stub',
+      'fixture',
+    ],
+    phrases: [
+      /\b(write tests?)\b/i,
+      /\b(test (the|this|a|an))\b/i,
+      /\b(add (test )?coverage)\b/i,
+      /\b(help (me )?(with )?tdd)\b/i,
+      /\b(unit tests?)\b/i,
+      /\b(integration tests?)\b/i,
+      /\b(test coverage)\b/i,
+      /\bhelp me test\b/i,
+      /\btest.*class\b/i,
+      /\btest.*endpoint\b/i,
+      /\btest.*api\b/i,
+      // Technical synonym phrases
+      /\b(test suite)\b/i,
+      /\b(run (the )?tests?)\b/i,
+      /\b(validation (tests?|suite|logic))\b/i,
+      /\b(verify (the|this|that))\b/i,
+      /\b(quality (check|assurance))\b/i,
+    ],
+    priority: 3,
+  },
+
+  REVIEW: {
+    keywords: [
+      'review',
+      'check',
+      'look',
+      'examine',
+      'audit',
+      'inspect',
+      'pr',
+      // Technical synonyms
+      'critique',
+      'evaluate',
+      'assess',
+      'analyze',
+      'feedback',
+      'approval',
+      'lgtm',
+    ],
+    phrases: [
+      /\b(review (this|the|my))\b/i,
+      /\b(check (this|the|my))\b/i,
+      /\b(look at (this|the|these))\b/i,
+      /\b(audit (this|the))\b/i,
+      /\b(review my pr)\b/i,
+      /\b(code review)\b/i,
+      /\breview.*code\b/i,
+      /\bcheck.*implementation\b/i,
+      /\baudit.*file\b/i,
+      // Technical synonym phrases
+      /\b(give (me )?feedback)\b/i,
+      /\b(need (your )?approval)\b/i,
+      /\b(pull request)\b/i,
+    ],
+    priority: 2,
+  },
+
+  SECURITY: {
+    keywords: [
+      'security',
+      'vulnerability',
+      'vulnerabilities',
+      'xss',
+      'injection',
+      'auth',
+      'authentication',
+      'credential',
+      'credentials',
+      'owasp',
+      'secure',
+    ],
+    phrases: [
+      /\b(security (check|review|audit|scan|vulnerabilit))\b/i,
+      /\b(check for (security|vulnerabilit))\b/i,
+      /\bxss\b/i,
+      /\bsql injection\b/i,
+      /\bowasp\b/i,
+      /\b(credential (handling|management))\b/i,
+      /\b(authentication (code|logic|flow))\b/i,
+      /\bvalidate.*credential\b/i,
+    ],
+    priority: 4,
+  },
+
+  COMPLIANCE: {
+    keywords: ['hipaa', 'soc2', 'pci', 'compliance', 'compliant', 'phi', 'ephi'],
+    phrases: [
+      /\bhipaa\b/i,
+      /\bsoc ?2\b/i,
+      /\bpci(-dss)?\b/i,
+      /\b(ensure|check|audit).*compliance\b/i,
+      /\bcompliance (check|audit|review|violation)\b/i,
+      /\bphi (handling|data)\b/i,
+      /\bpci compliant\b/i,
+    ],
+    priority: 5, // Highest priority - compliance is critical
+  },
+
+  ZOHO: {
+    keywords: ['zoho', 'creator', 'catalyst', 'deluge', 'crm', 'books', 'analytics'],
+    phrases: [
+      /\bzoho\b/i,
+      /\b(zoho )?(creator|catalyst)\b/i,
+      /\bdeluge\b/i,
+      /\b(creator (app|form|report))\b/i,
+      /\b(catalyst (function|deploy))\b/i,
+      /\bcrm (workflow|automation)\b/i,
+      /\bzoho books\b/i,
+    ],
+    priority: 4,
+  },
+
+  DEPLOY: {
+    keywords: [
+      'deploy',
+      'deployment',
+      'release',
+      'ship',
+      'production',
+      'prod',
+      'publish',
+      'live',
+      // Technical synonyms
+      'launch',
+      'rollout',
+      'staging',
+      'promote',
+      'ci',
+      'cd',
+      'pipeline',
+    ],
+    phrases: [
+      /\bdeploy (to|this|the)\b/i,
+      /\bpush to prod(uction)?\b/i,
+      /\brelease (the|a|this|new)\b/i,
+      /\bship (this|the|it)\b/i,
+      /\bgo live\b/i,
+      /\bto production\b/i,
+      // Technical synonym phrases
+      /\b(launch (the|this|to))\b/i,
+      /\b(roll ?out)\b/i,
+      /\b(promote to (prod|production|staging))\b/i,
+      /\b(ci.?cd pipeline)\b/i,
+    ],
+    priority: 3,
+  },
+
+  REFACTOR: {
+    keywords: [
+      'refactor',
+      'cleanup',
+      'clean',
+      'consolidate',
+      'simplify',
+      'remove',
+      'dead',
+      'unused',
+      'duplicate',
+    ],
+    phrases: [
+      /\brefactor\b/i,
+      /\bclean ?up\b/i,
+      /\bdead code\b/i,
+      /\bunused (import|code|variable|function)\b/i,
+      /\bremove (unused|dead|duplicate)\b/i,
+      /\bconsolidate\b/i,
+    ],
+    priority: 2,
+  },
+
+  DEBUG: {
+    keywords: [
+      'fix',
+      'bug',
+      'error',
+      'issue',
+      'problem',
+      'broken',
+      'failing',
+      'debug',
+      'investigate',
+      'wrong',
+      'crash',
+      'fail',
+      // Technical synonyms
+      'troubleshoot',
+      'diagnose',
+      'trace',
+      'stacktrace',
+      'exception',
+      'regression',
+      'hotfix',
+      'patch',
+    ],
+    phrases: [
+      /\bfix (this|the|a)?\s*(bug|error|issue)?\b/i,
+      /\bbug\b/i,
+      /\bnot working\b/i,
+      /\bkeeps? (failing|crashing|erroring|happening)\b/i,
+      /\bdebug\b/i,
+      /\binvestigate\b/i,
+      /\berror\b/i,
+      /\bbroken\b/i,
+      /\bfailing\b/i,
+      // Technical synonym phrases
+      /\b(troubleshoot (this|the))\b/i,
+      /\b(diagnose (this|the))\b/i,
+      /\b(root cause)\b/i,
+      /\b(stack trace)\b/i,
+      /\b(regression in)\b/i,
+    ],
+    priority: 2,
+  },
+
+  // New intent types for full documentation alignment
+
+  LEARNING: {
+    keywords: [
+      'learn',
+      'extract',
+      'pattern',
+      'patterns',
+      'reusable',
+      'insight',
+      'capture',
+      'knowledge',
+    ],
+    phrases: [
+      /\b(learn from|extract patterns?|capture (this|the) patterns?)\b/i,
+      /\b(make.*reusable)\b/i,
+      /\b(extract (a|the|this) patterns?)\b/i,
+      /\b(save.*for.*future)\b/i,
+      /\b(reusable patterns?)\b/i,
+      /\b(patterns?\s+from\s+(this|the))\b/i,
+    ],
+    priority: 2,
+  },
+
+  SETUP: {
+    keywords: ['setup', 'configure', 'install', 'initialize', 'onboard', 'bootstrap', 'init'],
+    phrases: [
+      /\b(set up|setup)\s+(the|a|an|new|my)?\b/i,
+      /\b(configure\s+(the|for|my))\b/i,
+      /\b(initialize\s+(the|a|new|my))\b/i,
+      /\b(install\s+(the|dependencies|packages|all))\b/i,
+      /\b(bootstrap\s+(the|a|new))\b/i,
+      /\b(get.*started)\b/i,
+      /\b(initial setup)\b/i,
+    ],
+    priority: 2,
+  },
+
+  HANDOFF: {
+    keywords: ['handoff', 'transfer', 'deliverable', 'handover', 'transition', 'turnover'],
+    phrases: [
+      /\b(hand ?off|handover)\b/i,
+      /\b(transfer to|transition to)\b/i,
+      /\b(create deliverable)\b/i,
+      /\b(client (handoff|documentation|delivery))\b/i,
+      /\b(prepare.*for.*handoff)\b/i,
+      /\b(deliverable.*for.*client)\b/i,
+    ],
+    priority: 2,
+  },
+
+  E2E: {
+    keywords: ['e2e', 'playwright', 'cypress', 'selenium', 'journey', 'puppeteer'],
+    phrases: [
+      /\b(e2e|end[- ]to[- ]end)\b/i,
+      /\b(playwright|cypress|selenium|puppeteer)\b/i,
+      /\b(user (flow|journey))\b/i,
+      /\b(browser test)\b/i,
+      /\b(e2e test)\b/i,
+      /\b(functional test)\b/i,
+      /\b(acceptance test)\b/i,
+    ],
+    priority: 3,
+  },
+
+  DOCUMENTATION: {
+    keywords: ['docs', 'document', 'documentation', 'readme', 'contributing', 'jsdoc', 'wiki'],
+    phrases: [
+      /\b(update|write|generate)\s+(docs|documentation|readme)\b/i,
+      /\b(document (the|this|a))\b/i,
+      /\b(add.*documentation)\b/i,
+      /\b(update.*readme)\b/i,
+      /\b(generate.*docs)\b/i,
+      /\b(write.*docs)\b/i,
+    ],
+    priority: 2,
+  },
+};
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * Used for typo tolerance in keyword matching
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} Edit distance
+ */
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+
+  // Early bailout for very different lengths
+  if (Math.abs(a.length - b.length) > 3) return Math.max(a.length, b.length);
+
+  const matrix = [];
+
+  // Initialize matrix
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  // Fill in the rest
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1, // insertion
+          matrix[i - 1][j] + 1 // deletion
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+/**
+ * Check if a word is a typo of a keyword
+ * @param {string} word - Word to check
+ * @param {string} keyword - Target keyword
+ * @returns {boolean} True if word is likely a typo of keyword
+ */
+function isTypoMatch(word, keyword) {
+  if (!word || !keyword) return false;
+
+  const a = word.toLowerCase();
+  const b = keyword.toLowerCase();
+
+  // Exact match
+  if (a === b) return true;
+
+  // No typo tolerance for short words (< 4 chars)
+  if (b.length < 4) return a === b;
+
+  const distance = levenshteinDistance(a, b);
+
+  // Allow up to 2 edits for longer words, 1 edit for medium words
+  const maxAllowed = b.length >= 6 ? 2 : 1;
+
+  return distance <= maxAllowed;
+}
+
+/**
+ * Common typos for critical keywords (optimization)
+ */
+const COMMON_TYPOS = {
+  test: ['tets', 'tset', 'testt', 'tet', 'teast'],
+  deploy: ['deplay', 'deplyo', 'delpoy', 'depoly'],
+  review: ['reveiw', 'reviw', 'revew', 'reivew'],
+  plan: ['pln', 'paln', 'plna', 'plaan'],
+  security: ['secuirty', 'securty', 'secutiry', 'securtiy'],
+  refactor: ['refacter', 'refacor', 'refactr', 'refactro'],
+  build: ['biuld', 'buld', 'buidl', 'bulid'],
+  create: ['craete', 'creat', 'cerate', 'cereate'],
+};
+
+/**
+ * Find typo matches for a word against a list of keywords
+ * @param {string} word - Word to check
+ * @param {string[]} keywords - List of keywords to match against
+ * @returns {string|null} Matched keyword or null
+ */
+function findTypoMatch(word, keywords) {
+  const lowerWord = word.toLowerCase();
+
+  // First check common typos dictionary (fast path)
+  for (const [keyword, typos] of Object.entries(COMMON_TYPOS)) {
+    if (keywords.includes(keyword) && typos.includes(lowerWord)) {
+      return keyword;
+    }
+  }
+
+  // Fallback to Levenshtein for other typos
+  for (const keyword of keywords) {
+    if (isTypoMatch(lowerWord, keyword)) {
+      return keyword;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Negation words that negate intent when preceding keywords
+ */
+const NEGATION_PATTERNS = {
+  // Explicit negation words
+  words: /\b(don'?t|do not|no|never|skip|avoid|without|not|isn'?t|won'?t|cannot|can'?t|shouldn'?t|wouldn'?t|exclude|stop|halt|cease|prevent)\b/i,
+  // Negation phrases (more specific patterns)
+  phrases: [
+    /\b(don'?t|do not)\s+\w*\s*(test|deploy|review|plan|build|create|refactor)/i,
+    /\b(skip|avoid|no)\s+(the\s+)?(test|deploy|security|review|plan)/i,
+    /\b(not\s+(for|ready|to|going))\s+/i,
+    /\bnot\s+yet\b/i,
+    /\bno\s+need\s+(to|for)\b/i,
+  ],
+};
+
+/**
+ * Check if a keyword is negated in the prompt
+ * @param {string} prompt - Full prompt
+ * @param {string} keyword - Keyword to check
+ * @returns {boolean} True if keyword appears to be negated
+ */
+function isKeywordNegated(prompt, keyword) {
+  const lowerPrompt = prompt.toLowerCase();
+  const keywordRegex = new RegExp(`\\b${keyword}\\b`, 'gi');
+  let match;
+
+  while ((match = keywordRegex.exec(lowerPrompt)) !== null) {
+    // Check the 50 characters before the keyword for negation
+    const beforeKeyword = lowerPrompt.slice(Math.max(0, match.index - 50), match.index);
+
+    // Look for negation words within 3 words of the keyword
+    const words = beforeKeyword.trim().split(/\s+/).slice(-4); // Last 4 words
+    const nearbyText = words.join(' ');
+
+    if (NEGATION_PATTERNS.words.test(nearbyText)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detect all negated intents in a prompt
+ * @param {string} prompt - User prompt
+ * @returns {string[]} Array of negated intent types
+ */
+function detectNegatedIntents(prompt) {
+  const negatedIntents = [];
+  const lowerPrompt = prompt.toLowerCase();
+
+  // Check each intent's keywords for negation
+  for (const [intentType, patterns] of Object.entries(INTENT_PATTERNS)) {
+    for (const keyword of patterns.keywords) {
+      if (lowerPrompt.includes(keyword) && isKeywordNegated(prompt, keyword)) {
+        if (!negatedIntents.includes(intentType)) {
+          negatedIntents.push(intentType);
+        }
+        break; // One negated keyword is enough
+      }
+    }
+  }
+
+  return negatedIntents;
+}
+
+/**
+ * Sentence type constants
+ */
+const SENTENCE_TYPES = {
+  QUESTION: 'QUESTION',
+  COMMAND: 'COMMAND',
+  STATEMENT: 'STATEMENT',
+};
+
+/**
+ * Question word patterns for detecting inquiries
+ */
+const QUESTION_PATTERNS = {
+  // Question words at start of sentence
+  startWords: /^(should|would|could|can|is|are|do|does|will|what|how|why|when|where|which|who|whom|whose|shall|may|might|has|have|had|was|were)\s/i,
+  // Question mark at end
+  endMark: /\?\s*$/,
+  // Conditional/hypothetical patterns
+  conditional: /^(if|whether)\s/i,
+};
+
+/**
+ * Detect if prompt is a question (inquiry) vs command/statement
+ * @param {string} prompt - User prompt
+ * @returns {object} { isQuestion: boolean, sentenceType: string }
+ */
+function detectSentenceType(prompt) {
+  if (!prompt) return { isQuestion: false, sentenceType: SENTENCE_TYPES.STATEMENT };
+
+  const trimmed = prompt.trim();
+
+  // Check for question mark
+  if (QUESTION_PATTERNS.endMark.test(trimmed)) {
+    return { isQuestion: true, sentenceType: SENTENCE_TYPES.QUESTION };
+  }
+
+  // Check for question words at start
+  if (QUESTION_PATTERNS.startWords.test(trimmed)) {
+    return { isQuestion: true, sentenceType: SENTENCE_TYPES.QUESTION };
+  }
+
+  // Check for conditional/hypothetical
+  if (QUESTION_PATTERNS.conditional.test(trimmed)) {
+    return { isQuestion: true, sentenceType: SENTENCE_TYPES.QUESTION };
+  }
+
+  // Check for command words at start (imperative)
+  if (/^(please|let's|lets|let me|let us|help me|can you|could you|would you)\s/i.test(trimmed)) {
+    return { isQuestion: false, sentenceType: SENTENCE_TYPES.COMMAND };
+  }
+
+  return { isQuestion: false, sentenceType: SENTENCE_TYPES.STATEMENT };
+}
+
+/**
+ * Check if prompt is primarily non-ASCII (likely non-English)
+ * @param {string} prompt - User prompt
+ * @returns {boolean} True if majority is non-ASCII
+ */
+function isNonAscii(prompt) {
+  if (!prompt) return false;
+  // Count printable ASCII characters (space to tilde)
+  const asciiChars = (prompt.match(/[\x20-\x7E]/g) || []).length;
+  const totalChars = prompt.replace(/\s/g, '').length; // Exclude whitespace
+  if (totalChars === 0) return false;
+  const ratio = asciiChars / totalChars;
+  return ratio < 0.5; // Less than 50% ASCII
+}
+
+/**
+ * Check if prompt starts with an explicit slash command
+ * @param {string} prompt - User prompt
+ * @returns {boolean} True if starts with /command
+ */
+function isExplicitCommand(prompt) {
+  if (!prompt) return false;
+  return /^\/\w+/.test(prompt.trim());
+}
+
+/**
+ * Contextual reference patterns (pronouns, anaphora)
+ * These indicate the user is referring to something from prior context
+ */
+const CONTEXTUAL_REFERENCE_PATTERNS = [
+  /\b(that|this|it|those|these|the same)\b/i,
+  /\b(do (it|that|the same|this))\b/i,
+  /\b(proceed|continue|go ahead|yes|okay|ok|sure)\b/i,
+  /\b(what (we|I) (said|discussed|mentioned))\b/i,
+  /\b(as (mentioned|discussed|before))\b/i,
+  /\b(like (before|last time))\b/i,
+  /\b(same (thing|as|approach))\b/i,
+];
+
+/**
+ * Check if prompt contains contextual references requiring prior context
+ * @param {string} prompt - User prompt
+ * @returns {boolean} True if prompt has contextual references
+ */
+function hasContextualReference(prompt) {
+  if (!prompt) return false;
+  return CONTEXTUAL_REFERENCE_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+
+/**
+ * Prompt length limits for performance
+ */
+const PROMPT_LIMITS = {
+  MAX_CHARS: 2000, // Truncate after this
+  PRIORITY_WINDOW: 500, // First N chars have highest weight
+  TAIL_WINDOW: 500, // Last N chars to keep
+};
+
+/**
+ * Intelligently truncate long prompts for classification
+ * Keeps beginning (likely has intent) and end (may have clarifications)
+ * @param {string} prompt - Original prompt
+ * @returns {object} { text: string, wasTruncated: boolean }
+ */
+function truncateForClassification(prompt) {
+  if (!prompt || prompt.length <= PROMPT_LIMITS.MAX_CHARS) {
+    return { text: prompt || '', wasTruncated: false };
+  }
+
+  // Keep first 500 chars (likely contains intent)
+  const start = prompt.slice(0, PROMPT_LIMITS.PRIORITY_WINDOW);
+
+  // Keep last 500 chars (may contain clarifications/specifics)
+  const end = prompt.slice(-PROMPT_LIMITS.TAIL_WINDOW);
+
+  // Combine with indicator
+  return {
+    text: `${start} ... ${end}`,
+    wasTruncated: true,
+  };
+}
+
+/**
+ * Calculate match score for a single intent
+ * @param {string} prompt - Normalized prompt
+ * @param {object} patterns - Intent pattern config
+ * @param {string[]} negatedIntents - Intents that are negated in the prompt
+ * @param {string} intentType - The intent type being scored
+ * @returns {object} Score and match details
+ */
+function calculateIntentScore(prompt, patterns, negatedIntents = [], intentType = '') {
+  let score = 0;
+  const matches = [];
+  const normalizedPrompt = prompt.toLowerCase();
+  let hasTypoMatch = false;
+
+  // If this intent is negated, return zero score
+  if (negatedIntents.includes(intentType)) {
+    return { score: 0, matches: [], priority: patterns.priority, isNegated: true, typoMatch: false };
+  }
+
+  // Check keywords (weight: 0.2 each, max contribution 0.6 - raised cap for better multi-keyword scoring)
+  let keywordScore = 0;
+  const matchedKeywords = new Set();
+
+  // First pass: exact keyword matches
+  for (const keyword of patterns.keywords) {
+    const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+    if (regex.test(normalizedPrompt)) {
+      // Skip keywords that are individually negated
+      if (!isKeywordNegated(prompt, keyword)) {
+        keywordScore += 0.2;
+        matches.push({ type: 'keyword', match: keyword });
+        matchedKeywords.add(keyword);
+      }
+    }
+  }
+
+  // Second pass: typo matching (only for words not already matched, with reduced weight)
+  const words = normalizedPrompt.split(/\s+/);
+  for (const word of words) {
+    // Skip very short words and already matched words
+    if (word.length < 3) continue;
+
+    const typoKeyword = findTypoMatch(word, patterns.keywords);
+    if (typoKeyword && !matchedKeywords.has(typoKeyword)) {
+      // Check negation for the original typo word too
+      if (!isKeywordNegated(prompt, word)) {
+        keywordScore += 0.2; // Same as keyword weight (typo info tracked in match type)
+        matches.push({ type: 'typo', match: word, correctedTo: typoKeyword });
+        matchedKeywords.add(typoKeyword);
+        hasTypoMatch = true;
+      }
+    }
+  }
+
+  score += Math.min(keywordScore, 0.6);
+
+  // Check phrases (higher weight: 0.35 each, max 3 phrases count)
+  let phraseCount = 0;
+  for (const phrase of patterns.phrases) {
+    if (phrase.test(normalizedPrompt)) {
+      if (phraseCount < 3) {
+        score += 0.35;
+        phraseCount++;
+      }
+      matches.push({ type: 'phrase', match: phrase.toString() });
+    }
+  }
+
+  // Apply priority weight (normalize to keep score in 0-1 range)
+  const priorityBoost = (patterns.priority - 1) * 0.05;
+  score = Math.min(score + priorityBoost, 1.0);
+
+  return { score, matches, priority: patterns.priority, isNegated: false, typoMatch: hasTypoMatch };
+}
+
+/**
+ * Classify user intent from natural language prompt
+ *
+ * @param {string} prompt - User prompt to classify
+ * @param {object} context - Optional context for enhanced detection
+ * @param {string[]} context.technologies - Detected technologies in session
+ * @param {string} context.complianceMode - Active compliance mode (hipaa/soc2/pci-dss)
+ * @param {string[]} context.recentFiles - Recently accessed files
+ * @param {string} context.lastClassifiedIntent - Last classified intent from session
+ * @param {number} context.conversationTurn - Current conversation turn number
+ * @returns {object} Classification result
+ */
+function classifyIntent(prompt, context = {}) {
+  const { lastClassifiedIntent = null } = context;
+  // Handle null/undefined/empty input
+  if (!prompt || typeof prompt !== 'string' || prompt.trim().length === 0) {
+    return {
+      primaryIntent: INTENT_TYPES.UNKNOWN,
+      confidence: 0,
+      secondaryIntents: [],
+      negatedIntents: [],
+      autoConvert: false,
+      suggestOnly: false,
+      ambiguous: false,
+      isInquiry: false,
+      sentenceType: SENTENCE_TYPES.STATEMENT,
+      wasTruncated: false,
+      skipRouting: false,
+      reason: 'empty_input',
+    };
+  }
+
+  const trimmedPrompt = prompt.trim();
+
+  // Truncate very long prompts for performance
+  const { text: normalizedPrompt, wasTruncated } = truncateForClassification(trimmedPrompt);
+
+  // Check for explicit slash commands first
+  if (isExplicitCommand(normalizedPrompt)) {
+    return {
+      primaryIntent: INTENT_TYPES.UNKNOWN,
+      confidence: 0,
+      secondaryIntents: [],
+      negatedIntents: [],
+      autoConvert: false,
+      suggestOnly: false,
+      ambiguous: false,
+      isInquiry: false,
+      sentenceType: SENTENCE_TYPES.COMMAND,
+      wasTruncated,
+      skipRouting: true,
+      reason: 'explicit_command',
+    };
+  }
+
+  // Check for non-ASCII (likely non-English) before length check
+  if (isNonAscii(normalizedPrompt)) {
+    return {
+      primaryIntent: INTENT_TYPES.UNKNOWN,
+      confidence: 0,
+      secondaryIntents: [],
+      negatedIntents: [],
+      autoConvert: false,
+      suggestOnly: false,
+      ambiguous: false,
+      isInquiry: false,
+      sentenceType: SENTENCE_TYPES.STATEMENT,
+      wasTruncated,
+      skipRouting: true,
+      reason: 'non_ascii',
+    };
+  }
+
+  // Check for contextual references (requires session context)
+  const hasContextRef = hasContextualReference(normalizedPrompt);
+
+  // If prompt is primarily contextual reference (short and refers to prior context)
+  // and we have session context, inherit intent
+  if (hasContextRef && lastClassifiedIntent && INTENT_TYPES[lastClassifiedIntent]) {
+    // Check if prompt has NO strong intent keywords (is purely contextual)
+    const explicitIntentKeywords =
+      /\b(plan|test|review|design|fix|deploy|refactor|build|create|add|setup|e2e|docs|handoff|learn|security|compliance)\b/i;
+
+    if (!explicitIntentKeywords.test(normalizedPrompt)) {
+      return {
+        primaryIntent: lastClassifiedIntent,
+        confidence: 0.6, // Reduced confidence for inherited intent
+        secondaryIntents: [],
+        negatedIntents: [],
+        autoConvert: false, // Don't auto-convert inherited intents
+        suggestOnly: true,
+        ambiguous: false,
+        isInquiry: false,
+        sentenceType: SENTENCE_TYPES.STATEMENT,
+        wasTruncated,
+        requiresContext: true, // Flag that this was context-dependent
+        inheritedFrom: 'session', // Mark as inherited
+        skipRouting: false,
+        reason: null,
+      };
+    }
+  }
+
+  // Check for very short prompts - but allow if explicit intent keyword found
+  if (normalizedPrompt.length < 10) {
+    // Allow short prompts with explicit high-confidence intent keywords
+    const explicitIntentKeywords =
+      /\b(plan|test|review|design|fix|deploy|refactor|build|create|add|setup|e2e|docs|handoff|learn)\b/i;
+
+    if (!explicitIntentKeywords.test(normalizedPrompt)) {
+      return {
+        primaryIntent: INTENT_TYPES.UNKNOWN,
+        confidence: 0.2,
+        secondaryIntents: [],
+        negatedIntents: [],
+        autoConvert: false,
+        suggestOnly: false,
+        ambiguous: false,
+        isInquiry: false,
+        sentenceType: SENTENCE_TYPES.STATEMENT,
+        wasTruncated: false,
+        requiresContext: hasContextRef, // Flag if context would help
+        skipRouting: false,
+        reason: 'too_short',
+      };
+    }
+    // Continue to classification for short prompts with explicit intent keywords
+  }
+
+  // Detect negated intents first
+  const negatedIntents = detectNegatedIntents(normalizedPrompt);
+
+  // Detect sentence type (question vs command)
+  const { isQuestion, sentenceType } = detectSentenceType(normalizedPrompt);
+
+  // Calculate scores for all intents
+  const scores = [];
+  for (const [intentType, patterns] of Object.entries(INTENT_PATTERNS)) {
+    const result = calculateIntentScore(normalizedPrompt, patterns, negatedIntents, intentType);
+    if (result.score > 0) {
+      scores.push({
+        intent: intentType,
+        score: result.score,
+        matches: result.matches,
+        priority: result.priority,
+      });
+    }
+  }
+
+  // Apply context boosts
+  if (context.complianceMode) {
+    const complianceScore = scores.find((s) => s.intent === 'COMPLIANCE');
+    if (complianceScore) {
+      complianceScore.score = Math.min(complianceScore.score + 0.2, 1.0);
+    } else {
+      // Check if prompt mentions data handling in compliance context
+      if (/\b(data|patient|user|customer|handling|export|import)\b/i.test(normalizedPrompt)) {
+        scores.push({
+          intent: 'COMPLIANCE',
+          score: 0.5,
+          matches: [{ type: 'context', match: 'compliance_mode_active' }],
+          priority: 5,
+        });
+      }
+    }
+  }
+
+  if (context.technologies) {
+    // Boost Zoho if Zoho technologies detected
+    if (context.technologies.some((t) => /zoho|creator|catalyst|deluge/i.test(t))) {
+      const zohoScore = scores.find((s) => s.intent === 'ZOHO');
+      if (zohoScore) {
+        zohoScore.score = Math.min(zohoScore.score + 0.15, 1.0);
+      }
+    }
+  }
+
+  // Sort by score (descending), then by priority (descending)
+  scores.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return b.priority - a.priority;
+  });
+
+  // No matches found
+  if (scores.length === 0 || scores[0].score < THRESHOLDS.MINIMUM) {
+    return {
+      primaryIntent: INTENT_TYPES.UNKNOWN,
+      confidence: scores.length > 0 ? scores[0].score : 0,
+      secondaryIntents: [],
+      negatedIntents,
+      autoConvert: false,
+      suggestOnly: false,
+      ambiguous: true,
+      isInquiry: isQuestion,
+      sentenceType,
+      wasTruncated,
+      skipRouting: false,
+      reason: 'no_strong_match',
+    };
+  }
+
+  const primaryResult = scores[0];
+  const secondaryIntents = scores
+    .slice(1)
+    .filter((s) => s.score >= THRESHOLDS.MINIMUM)
+    .map((s) => s.intent);
+
+  // Check for ambiguity (top two scores very close)
+  const isAmbiguous =
+    scores.length > 1 &&
+    Math.abs(primaryResult.score - scores[1].score) < 0.1 &&
+    primaryResult.score < THRESHOLDS.AUTO_CONVERT;
+
+  // For questions, don't auto-convert - user is asking, not commanding
+  const effectiveAutoConvert = !isQuestion && primaryResult.score >= THRESHOLDS.AUTO_CONVERT;
+
+  return {
+    primaryIntent: primaryResult.intent,
+    confidence: primaryResult.score,
+    secondaryIntents,
+    negatedIntents, // NEW: Intents that user explicitly wants to avoid
+    matches: primaryResult.matches,
+    autoConvert: effectiveAutoConvert,
+    suggestOnly:
+      primaryResult.score >= THRESHOLDS.SUGGEST && primaryResult.score < THRESHOLDS.AUTO_CONVERT,
+    ambiguous: isAmbiguous,
+    isInquiry: isQuestion, // NEW: User is asking about this, not commanding
+    sentenceType, // NEW: QUESTION, COMMAND, or STATEMENT
+    wasTruncated, // NEW: True if prompt was truncated for performance
+    requiresContext: hasContextRef && primaryResult.score < THRESHOLDS.SUGGEST, // NEW: Context would help
+    skipRouting: false,
+    reason: null,
+  };
+}
+
+module.exports = {
+  classifyIntent,
+  INTENT_TYPES,
+  THRESHOLDS,
+  // Exported for testing
+  isNonAscii,
+  isExplicitCommand,
+  calculateIntentScore,
+  INTENT_PATTERNS,
+  // Negation detection exports
+  isKeywordNegated,
+  detectNegatedIntents,
+  NEGATION_PATTERNS,
+  // Typo tolerance exports
+  levenshteinDistance,
+  isTypoMatch,
+  findTypoMatch,
+  COMMON_TYPOS,
+  // Question detection exports
+  detectSentenceType,
+  SENTENCE_TYPES,
+  QUESTION_PATTERNS,
+  // Long prompt handling exports
+  truncateForClassification,
+  PROMPT_LIMITS,
+  // Session context exports
+  hasContextualReference,
+  CONTEXTUAL_REFERENCE_PATTERNS,
+};