@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-GI5M67YA.js

@@ -0,0 +1,735 @@
+import {
+  classifyExplicitNoEdit,
+  maskNegatedEditPhrases
+} from "./chunk-PPHXX4W7.js";
+import {
+  hasExplicitFileTargets,
+  stripBuildContextBlocks
+} from "./chunk-KUEWV2JH.js";
+
+// src/analytics/analyze-verb-noun.ts
+var GOVERNING_EXECUTE_VERB_PATTERN = /\b(add|make|implement|fix|refactor|optimi[sz]e|improve|build|create|write)\b/i;
+var NOUN_CONTEXT_PATTERN = /(?:\b(?:a|an|the|another|one|some|new)\s+(?:[\w-]+\s+)?|[a-z]-)$/i;
+var DANGLING_NEGATION_PATTERN = /\b(?:not|never|no|cannot|don['’]t|without|avoid)\s*$/i;
+function maskNegatedEditPhrasesPerInstruction(text) {
+  const instructions = [];
+  for (const line of text.split("\n")) {
+    const previous = instructions[instructions.length - 1];
+    if (previous !== void 0 && DANGLING_NEGATION_PATTERN.test(previous)) {
+      instructions[instructions.length - 1] = `${previous} ${line.trimStart()}`;
+      continue;
+    }
+    instructions.push(line);
+  }
+  return instructions.map((instruction) => maskNegatedEditPhrases(instruction)).join("\n");
+}
+function isAnalyzeVerbUsedAsNoun(prompt, matchIndex) {
+  const preceding = prompt.slice(0, matchIndex);
+  if (!NOUN_CONTEXT_PATTERN.test(preceding)) return false;
+  return GOVERNING_EXECUTE_VERB_PATTERN.test(maskNegatedEditPhrasesPerInstruction(preceding));
+}
+
+// src/analytics/intent-classifier.ts
+var DEFAULT_CATEGORY_ACTIVITY_MAP = {
+  execute: "development",
+  // Code execution tasks default to development
+  review: "design",
+  // Code review focuses on design quality
+  analyze: "planning",
+  // Analysis tasks default to planning (research requires explicit framing)
+  test: "development",
+  // Test writing is development work
+  document: "design",
+  // Documentation is design communication
+  unknown: "planning"
+  // Ambiguous tasks should route through caller-side disambiguation
+};
+function getDefaultActivityForCategory(category) {
+  return DEFAULT_CATEGORY_ACTIVITY_MAP[category];
+}
+function inferActivity(prompt, category) {
+  const lower = prompt.toLowerCase();
+  const titleEnd = lower.indexOf("\n\n");
+  const leadEnd = titleEnd >= 0 ? Math.min(titleEnd + 200, lower.length) : Math.min(200, lower.length);
+  const lead = lower.slice(0, leadEnd);
+  const archLeadEnd = titleEnd >= 0 ? Math.min(titleEnd + 60, lower.length) : Math.min(60, lower.length);
+  const archLead = lower.slice(0, archLeadEnd);
+  if (lead.includes("debug") || lead.includes("fix bug") || lead.includes("troubleshoot")) {
+    return "debugging";
+  }
+  if (archLead.includes("architecture") || archLead.includes("system design") || archLead.includes("high-level")) {
+    return "architecture";
+  }
+  if (lower.includes("design") || lower.includes("api design") || lower.includes("interface")) {
+    return "design";
+  }
+  if (lower.includes("research") || lower.includes("investigate") || lower.includes("explore options")) {
+    return "research";
+  }
+  if (lower.includes("plan") || lower.includes("roadmap") || lower.includes("strategy") || lower.includes("approach")) {
+    return "planning";
+  }
+  if (lower.includes("implement") || lower.includes("develop") || lower.includes("build") || lower.includes("create")) {
+    return "development";
+  }
+  return getDefaultActivityForCategory(category);
+}
+var COMPOUND_NOUN_PATTERNS = [
+  // Test compounds (should not trigger testing intent)
+  /\btest\s+(criteria|plan|data|suite|environment|cases?|scenarios?|conditions|requirements)\b/i,
+  // Review compounds (context-dependent)
+  /\breview\s+(board|process|cycle|meeting|period)\b/i,
+  // Code compounds (neutral context)
+  /\bcode\s+(review|coverage|quality|analysis)\b/i
+];
+var VERB_CATEGORY_MAP = {
+  // Execute verbs
+  fix: "execute",
+  debug: "execute",
+  troubleshoot: "execute",
+  emit: "execute",
+  log: "execute",
+  record: "execute",
+  track: "execute",
+  wire: "execute",
+  add: (prompt) => {
+    const testPattern = /\b(unit|integration|e2e)\s*test(?:s?)?\b/i;
+    const documentPattern = /\b(inline\s*comments?|doc(?:umentation)?)\b/i;
+    if (testPattern.test(prompt)) return "test";
+    if (documentPattern.test(prompt)) return "document";
+    return "execute";
+  },
+  implement: (prompt) => {
+    const testPattern = /\b(tests?|coverage)\b/i;
+    const documentPattern = /\b(doc(?:umentation)?)\b/i;
+    if (testPattern.test(prompt)) return "test";
+    if (documentPattern.test(prompt)) return "document";
+    return "execute";
+  },
+  create: (prompt) => {
+    const testPattern = /\b(unit|integration|e2e)\s*test(?:s?)?\b/i;
+    const documentPattern = /\b(doc(?:umentation)?|reference)\b/i;
+    if (testPattern.test(prompt)) return "test";
+    if (documentPattern.test(prompt)) return "document";
+    return "execute";
+  },
+  update: "execute",
+  refactor: "execute",
+  remove: "execute",
+  delete: "execute",
+  change: "execute",
+  modify: "execute",
+  build: "execute",
+  develop: "execute",
+  integrate: "execute",
+  improve: "execute",
+  rework: "execute",
+  clarify: "execute",
+  stabilize: "execute",
+  harden: "execute",
+  // Preventive/protective verbs that imply code changes
+  prevent: "execute",
+  secure: "execute",
+  enforce: "execute",
+  protect: "execute",
+  guard: "execute",
+  // Specific handling for writing/tests to differentiate
+  write: (prompt) => {
+    const testPattern = /\b(test|coverage|unit\s+tests?|integration\s+tests?|e2e\s+tests?)\b/i;
+    const documentPattern = /\b(doc(?:umentation)?|reference)\b/i;
+    if (testPattern.test(prompt)) return "test";
+    if (documentPattern.test(prompt)) return "document";
+    return "execute";
+  },
+  // Analyze verbs
+  analyze: "analyze",
+  evaluate: "analyze",
+  assess: "analyze",
+  investigate: "analyze",
+  examine: "analyze",
+  compare: "analyze",
+  benchmark: "analyze",
+  contrast: "analyze",
+  study: "analyze",
+  research: "analyze",
+  explore: "analyze",
+  review: "analyze",
+  // Default review to analyze
+  // Test verbs (when used as action)
+  test: "test",
+  cover: "test",
+  validate: "test",
+  verify: "test",
+  "add tests": "test",
+  "write tests": "test",
+  "create tests": "test",
+  "implement tests": "test",
+  "run tests": "test",
+  // Document verbs
+  document: "document",
+  describe: "document",
+  explain: "document",
+  summarize: "document",
+  outline: "document",
+  // Review verbs (code quality focus)
+  audit: "analyze",
+  inspect: "analyze"
+};
+var KEYWORD_CLUSTERS = {
+  execute: [
+    "bug",
+    "bugfix",
+    "error",
+    "crash",
+    "issue",
+    "problem",
+    "feature",
+    "functionality",
+    "behavior",
+    "logic",
+    "refactor",
+    "optimization",
+    "performance",
+    "implementation",
+    "code change",
+    "modify",
+    "update"
+  ],
+  analyze: [
+    "investigation",
+    "analysis",
+    "evaluation",
+    "assessment",
+    "compare",
+    "benchmark",
+    "contrast",
+    "trade-off",
+    "approach",
+    "option",
+    "architecture",
+    "design",
+    "pattern",
+    "strategy",
+    "why",
+    "how",
+    "what",
+    "which",
+    "when",
+    "criteria",
+    "requirements",
+    "considerations",
+    "versus",
+    "vs"
+  ],
+  test: [
+    "unit test",
+    "integration test",
+    "e2e test",
+    "test coverage",
+    "test suite",
+    "test case",
+    "testing",
+    "validation",
+    "verification",
+    "create test",
+    "create tests",
+    "write test",
+    "write tests",
+    "implement test",
+    "implement tests",
+    "add test",
+    "add tests",
+    "run tests",
+    "complete test suite",
+    "improve test coverage"
+  ],
+  document: [
+    "documentation",
+    "readme",
+    "api doc",
+    "comment",
+    "guide",
+    "tutorial",
+    "example",
+    "usage",
+    "specification",
+    "reference",
+    "describe",
+    "summary",
+    "summarize",
+    "outline"
+  ],
+  review: [
+    "code review",
+    "quality",
+    "security audit",
+    "audit",
+    "compliance",
+    "best practices",
+    "standards",
+    "conventions",
+    "vulnerability",
+    "smell",
+    "anti-pattern"
+  ]
+};
+var QUESTION_WORDS = [
+  "what",
+  "why",
+  "how",
+  "which",
+  "when",
+  "where",
+  "who",
+  "should",
+  "can",
+  "could",
+  "would"
+];
+var ANALYSIS_OVERRIDE_PATTERN = /\b(proposal|propose|recommendation|recommend|analysis|analyze|evaluation|evaluate|assess|review|audit|plan|design doc|rfc)\b/i;
+var STRUCTURE_PATTERNS = {
+  successCriteria: /(?:success\s+if|test\s+criteria|acceptance\s+criteria|success\s+criteria):/gi,
+  fileSpec: /\bFILES?:/im,
+  question: new RegExp(`^\\s*(?:${QUESTION_WORDS.join("|")})\\b`, "i"),
+  imperative: new RegExp(`^\\s*(?:${Object.keys(VERB_CATEGORY_MAP).join("|")})\\b`, "i")
+};
+var FILES_LIST_SECTION_PATTERN = /\bFILES?:\s*\n\s*[-*]\s*`?\S+/im;
+function getFirstNonEmptyNonFileSpecLine(prompt) {
+  const lines = prompt.split(/\r?\n/);
+  let inFilesList = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^FILES:\s*/i.test(trimmed)) {
+      inFilesList = true;
+      continue;
+    }
+    if (/^FILE:\s*/i.test(trimmed)) {
+      continue;
+    }
+    if (inFilesList && /^[-*]\s+/.test(trimmed)) {
+      continue;
+    }
+    return trimmed;
+  }
+  return null;
+}
+function extractStructureSignals(prompt) {
+  const signals = [];
+  const hasFileLineSpec = hasExplicitFileTargets(prompt);
+  const hasScopedFileTargets = hasExplicitFileTargets(prompt, { includeScopedSections: true });
+  const hasFilesListSection = FILES_LIST_SECTION_PATTERN.test(prompt);
+  if (hasScopedFileTargets || hasFilesListSection) {
+    const signalKind = hasFileLineSpec ? "hasFileSpec" : hasFilesListSection ? "hasFilesList" : "hasScopedFileTargets";
+    signals.push({
+      signal: signalKind,
+      weight: hasFileLineSpec ? 0.6 : hasFilesListSection ? 0.25 : 0.3,
+      category: "execute",
+      explanation: hasFileLineSpec ? "Contains FILE: directive (targeted code change)" : hasFilesListSection ? "Contains FILES: list (scoped code context)" : "Contains scoped source-path list (targeted code context)"
+    });
+    if (ANALYSIS_OVERRIDE_PATTERN.test(prompt) && classifyExplicitNoEdit(prompt)) {
+      signals.push({
+        signal: "fileSpecWithAnalysisNouns",
+        weight: 0.45,
+        category: "analyze",
+        explanation: "FILE targets present but prompt is framed as proposals/analysis/review"
+      });
+    }
+  }
+  if (STRUCTURE_PATTERNS.question.test(prompt)) {
+    signals.push({
+      signal: "isQuestion",
+      weight: 0.35,
+      category: "analyze",
+      explanation: "Starts with question word (investigation intent)"
+    });
+  }
+  const imperativeMatch = prompt.match(STRUCTURE_PATTERNS.imperative);
+  if (imperativeMatch) {
+    const matchIndex = imperativeMatch.index ?? 0;
+    if (!isCompoundNoun(prompt, matchIndex)) {
+      const verb = imperativeMatch[0].trim().toLowerCase();
+      const handler = VERB_CATEGORY_MAP[verb];
+      const category = typeof handler === "function" ? handler(prompt) : handler ?? "execute";
+      signals.push({
+        signal: "isImperative",
+        weight: 0.3,
+        category,
+        explanation: `Starts with action verb "${verb}" (${category} intent)`
+      });
+    }
+  }
+  return signals;
+}
+function extractVerbPhraseSignals(prompt) {
+  const signals = [];
+  const promptLower = prompt.toLowerCase();
+  const reviewThenExecutePattern = /^\s*(review|audit|inspect)\b[\s\S]{0,120}\b(implement|fix|refactor|build|develop|integrate|create|update|modify|change)\b/i;
+  if (reviewThenExecutePattern.test(promptLower)) {
+    signals.push({
+      signal: "reviewThenExecute",
+      weight: 0.38,
+      category: "execute",
+      explanation: "Review followed by an execute verb (implies implementation work)"
+    });
+    return signals;
+  }
+  const specialPatterns = [
+    {
+      pattern: /\b(add|create|write|implement|run)\s+(unit|integration|e2e)?\s*tests?\b/i,
+      category: "test",
+      weight: 0.4
+    },
+    {
+      pattern: /\b(add|create|write|implement|run|improve|increase)\b[\s\S]{0,40}\btest\s+coverage\b/i,
+      category: "test",
+      weight: 0.4
+    },
+    {
+      pattern: /\b(write\s+documentation|create\s+api\s+reference|add\s+inline\s+comments?)\b/i,
+      category: "document",
+      weight: 0.4
+    },
+    {
+      pattern: /\b(develop|integrate|refactor|implement)\s+(payment|api|service|module)\b/i,
+      category: "execute",
+      weight: 0.35
+    }
+  ];
+  for (const { pattern, category, weight } of specialPatterns) {
+    if (pattern.test(promptLower)) {
+      signals.push({
+        signal: `special_context:${category}`,
+        weight,
+        category,
+        explanation: `Specialized verb pattern for ${category} task`
+      });
+      return signals;
+    }
+  }
+  const beginning = promptLower.slice(0, 150);
+  const verbPriority = [
+    { verbs: ["develop", "integrate"], category: "execute", weight: 0.35 },
+    { verbs: ["review", "audit", "inspect"], category: "analyze", weight: 0.3 },
+    { verbs: ["document", "write"], category: "document", weight: 0.35 }
+  ];
+  for (const { verbs, category, weight } of verbPriority) {
+    for (const verb of verbs) {
+      const verbPattern = new RegExp(`\\b${verb}\\b`, "i");
+      const priorityMatch = verbPattern.exec(beginning);
+      if (priorityMatch) {
+        if (category === "analyze" && isAnalyzeVerbUsedAsNoun(prompt, priorityMatch.index)) {
+          continue;
+        }
+        signals.push({
+          signal: `verb:${verb}`,
+          weight,
+          category,
+          explanation: `Primary verb "${verb}" indicates ${category} task`
+        });
+        return signals;
+      }
+    }
+  }
+  const verbOrder = ["test", "document", "analyze", "review", "execute"];
+  for (const verb of verbOrder) {
+    const verbEntries = Object.entries(VERB_CATEGORY_MAP).filter(
+      ([, cat]) => cat === verb || typeof cat === "function" && cat(prompt) === verb
+    );
+    for (const [verbStr, handler] of verbEntries) {
+      const verbPattern = verbStr === "test" ? /(^\s*test\b|\btest\b\s+(?:the|this|these)\b)/i : new RegExp(`\\b${verbStr}\\b`, "i");
+      const match = verbPattern.exec(beginning);
+      if (match) {
+        if (isCompoundNoun(prompt, match.index ?? 0)) {
+          continue;
+        }
+        if (verb === "analyze" && isAnalyzeVerbUsedAsNoun(prompt, match.index ?? 0)) {
+          continue;
+        }
+        const category = typeof handler === "function" ? handler(prompt) : handler;
+        signals.push({
+          signal: `verb:${verbStr}`,
+          weight: 0.3,
+          category,
+          explanation: `Primary verb "${verbStr}" indicates ${category} task`
+        });
+        return signals;
+      }
+    }
+  }
+  return signals;
+}
+function calculatePositionWeight(position, totalLength) {
+  const normalizedPosition = position / totalLength;
+  return 1 - normalizedPosition * 0.5;
+}
+function isCompoundNoun(prompt, matchIndex) {
+  const contextWindow = prompt.slice(Math.max(0, matchIndex - 20), matchIndex + 50);
+  for (const pattern of COMPOUND_NOUN_PATTERNS) {
+    if (pattern.test(contextWindow)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractKeywordSignals(prompt) {
+  const signals = [];
+  const promptLower = prompt.toLowerCase();
+  const promptLength = prompt.length;
+  for (const [category, keywords] of Object.entries(KEYWORD_CLUSTERS)) {
+    let categoryScore = 0;
+    let matchCount = 0;
+    const matchedKeywords = [];
+    for (const keyword of keywords) {
+      const regex = new RegExp(`\\b${keyword.replace(/\s+/g, "\\s+")}\\b`, "gi");
+      let match = regex.exec(promptLower);
+      while (match !== null) {
+        if (category === "test" && isCompoundNoun(prompt, match.index)) {
+          match = regex.exec(promptLower);
+          continue;
+        }
+        const positionWeight = calculatePositionWeight(match.index, promptLength);
+        categoryScore += positionWeight;
+        matchCount++;
+        if (!matchedKeywords.includes(keyword)) {
+          matchedKeywords.push(keyword);
+        }
+        match = regex.exec(promptLower);
+      }
+    }
+    if (matchCount > 0) {
+      signals.push({
+        signal: `keywords:${category}`,
+        weight: Math.min(categoryScore * 0.2, 0.2),
+        // Cap at 20% of total weight
+        category,
+        explanation: `Matched ${matchCount} ${category} keywords: ${matchedKeywords.slice(0, 3).join(", ")}${matchedKeywords.length > 3 ? "..." : ""}`
+      });
+    }
+  }
+  return signals;
+}
+function extractContextSignals(prompt) {
+  const signals = [];
+  const fileMatches = prompt.match(/(?:FILE:|FILES:|\.\w+\s|\/[\w-]+\/[\w.-]+)/gi);
+  if (fileMatches && fileMatches.length > 2) {
+    signals.push({
+      signal: "multipleFiles",
+      weight: 0.08,
+      category: "execute",
+      explanation: `References ${fileMatches.length} files (likely code changes)`
+    });
+  }
+  if (/```|`\w+`|^\s{4,}\w+/m.test(prompt)) {
+    signals.push({
+      signal: "hasCodeSnippets",
+      weight: 0.06,
+      category: "execute",
+      explanation: "Contains code snippets (likely implementation)"
+    });
+  }
+  return signals;
+}
+function checkFastPath(prompt) {
+  const hasAnalysisOverride = ANALYSIS_OVERRIDE_PATTERN.test(prompt);
+  const hasExplicitNoEdits = classifyExplicitNoEdit(prompt);
+  const hasFileLineSpec = hasExplicitFileTargets(prompt);
+  const hasScopedFileTargets = hasExplicitFileTargets(prompt, { includeScopedSections: true });
+  const hasFilesListSection = FILES_LIST_SECTION_PATTERN.test(prompt);
+  const hasCodeDeliverable = /\b(full\s+implementation|implementation code|code change|apply(?:ing)?\s+changes|provide\s+code|code snippet|before\/after)\b/i.test(
+    prompt
+  );
+  const hasFileList = hasFilesListSection;
+  const testSectionPattern = /(^|\n)\s*(?:#{1,6}\s*)?test\s+(criteria|plan|suite|coverage|requirements)\b\s*:?\s*(\n|$)/i;
+  const executeActionVerbPattern = /^\s*(fix|add|implement|create|update|refactor|remove|delete|change|modify|build|develop|integrate|improve|rework|clarify|stabilize|harden)\b/i;
+  const hasActionVerbAtStart = executeActionVerbPattern.test(prompt);
+  const firstNonFileLine = getFirstNonEmptyNonFileSpecLine(prompt);
+  const hasActionVerbInBody = firstNonFileLine !== null && executeActionVerbPattern.test(firstNonFileLine);
+  const testPromptPattern = /^\s*(add|write|create|implement|run|improve|increase)\b[\s\S]{0,40}\b(?:tests?|test\s+coverage)\b/i;
+  if (testPromptPattern.test(prompt)) {
+    if (!(hasFileLineSpec && /\b(fix|refactor|implement|build|develop|integrate)\b/i.test(prompt))) {
+      return {
+        category: "test",
+        confidence: 0.93,
+        rule: "Explicit test verb with test context"
+      };
+    }
+  }
+  const startsWithFileSpec = /^\s*FILE:\s*\S+/i.test(prompt);
+  if (startsWithFileSpec && hasFileLineSpec && (hasActionVerbAtStart || hasActionVerbInBody) && !hasExplicitNoEdits) {
+    return {
+      category: "execute",
+      confidence: 0.95,
+      rule: "FILE: specification with action verb"
+    };
+  }
+  if (hasFileLineSpec && hasCodeDeliverable && !hasExplicitNoEdits) {
+    return {
+      category: "execute",
+      confidence: 0.93,
+      rule: "FILE: specification with explicit code deliverable"
+    };
+  }
+  if (hasFileList && (hasActionVerbAtStart || hasActionVerbInBody) && !hasExplicitNoEdits) {
+    return {
+      category: "execute",
+      confidence: 0.92,
+      rule: "FILES: section with explicit path list"
+    };
+  }
+  if (hasScopedFileTargets && !hasFileLineSpec && !hasFileList && (hasActionVerbAtStart || hasActionVerbInBody) && !hasExplicitNoEdits) {
+    return {
+      category: "execute",
+      confidence: 0.91,
+      rule: "Scoped source-path list with action verb"
+    };
+  }
+  if (testSectionPattern.test(prompt)) {
+    return {
+      category: "analyze",
+      confidence: 0.9,
+      rule: "Contains test plan/suite/coverage section"
+    };
+  }
+  if (STRUCTURE_PATTERNS.question.test(prompt) && !hasFileLineSpec) {
+    const investigationVerbs = [
+      "analyze",
+      "evaluate",
+      "assess",
+      "investigate",
+      "examine",
+      "compare"
+    ];
+    for (const verb of investigationVerbs) {
+      if (new RegExp(`\\b${verb}\\b`, "i").test(prompt.slice(0, 150))) {
+        return {
+          category: "analyze",
+          confidence: 0.88,
+          rule: `Question with investigation verb "${verb}"`
+        };
+      }
+    }
+  }
+  if (STRUCTURE_PATTERNS.fileSpec.test(prompt) && hasAnalysisOverride && hasExplicitNoEdits) {
+    return {
+      category: "analyze",
+      confidence: 0.78,
+      rule: "FILE specification but framed as proposals/review/analysis"
+    };
+  }
+  return null;
+}
+function calculateConfidence(scores, winner, signalCount) {
+  const sortedScores = Object.entries(scores).sort(([, a], [, b]) => b - a).map(([cat, score]) => ({ category: cat, score }));
+  const winnerScore = sortedScores[0]?.score ?? 0;
+  const runnerUpScore = sortedScores[1]?.score || 0;
+  const separation = winnerScore - runnerUpScore;
+  let confidence = Math.min(separation * 2, 0.95);
+  if (signalCount >= 3) {
+    confidence = Math.min(confidence + 0.05, 0.98);
+  }
+  if (winner === "test" || winner === "document" && signalCount > 1) {
+    confidence = Math.min(confidence * 1.2, 0.98);
+  }
+  if (signalCount === 1) {
+    confidence *= 0.8;
+  }
+  confidence = Math.max(confidence, signalCount > 0 ? 0.5 : 0.3);
+  return confidence;
+}
+function classifyIntent(prompt) {
+  const startTime = performance.now();
+  const cleanPrompt = stripBuildContextBlocks(prompt);
+  const fastPath = checkFastPath(cleanPrompt);
+  if (fastPath) {
+    return {
+      category: fastPath.category,
+      confidence: fastPath.confidence,
+      signals: [
+        {
+          signal: "fastPath",
+          weight: 1,
+          category: fastPath.category,
+          explanation: `Fast path: ${fastPath.rule}`
+        }
+      ],
+      alternatives: [],
+      fastPathUsed: fastPath.rule,
+      classificationTimeMs: performance.now() - startTime,
+      activity: inferActivity(cleanPrompt, fastPath.category)
+    };
+  }
+  const allSignals = [
+    ...extractStructureSignals(cleanPrompt),
+    ...extractVerbPhraseSignals(cleanPrompt),
+    ...extractKeywordSignals(cleanPrompt),
+    ...extractContextSignals(cleanPrompt)
+  ];
+  const categoryScores = {
+    execute: 0,
+    review: 0,
+    analyze: 0,
+    test: 0,
+    document: 0
+  };
+  for (const signal of allSignals) {
+    if (signal.category !== "unknown") {
+      categoryScores[signal.category] += signal.weight;
+    }
+  }
+  const sortedCategories = Object.entries(categoryScores).sort(([, a], [, b]) => b - a).map(([cat, score]) => ({ category: cat, confidence: score }));
+  const winner = sortedCategories[0]?.category ?? "analyze";
+  const confidence = calculateConfidence(categoryScores, winner, allSignals.length);
+  const hasFileLineSpec = hasExplicitFileTargets(cleanPrompt);
+  const hasScopedFileTargets = hasExplicitFileTargets(cleanPrompt, { includeScopedSections: true });
+  const hasExplicitNoEdits = classifyExplicitNoEdit(cleanPrompt);
+  const isKnowledgeIntent = winner === "analyze" || winner === "review";
+  let finalCategory = allSignals.length === 0 || confidence < 0.5 && !isKnowledgeIntent ? "unknown" : winner;
+  const hasFilesListSection = FILES_LIST_SECTION_PATTERN.test(cleanPrompt);
+  if ((hasFileLineSpec || hasFilesListSection || hasScopedFileTargets) && !hasExplicitNoEdits) {
+    finalCategory = "execute";
+  }
+  let alternatives = sortedCategories.filter(({ category }) => category !== finalCategory).filter(({ confidence: score }) => score > 0).slice(0, 3).map(({ category, confidence: score }) => ({
+    category,
+    confidence: Math.min(score, confidence)
+  }));
+  if (alternatives.length === 0 && confidence < 0.5) {
+    const fallbackConfidence = Math.max(Math.min(confidence, 0.15), 0.05);
+    alternatives = ["analyze", "test", "document"].filter((category) => category !== finalCategory).slice(0, 3).map((category) => ({ category, confidence: fallbackConfidence }));
+  }
+  const activity = inferActivity(cleanPrompt, finalCategory);
+  const trimmed = cleanPrompt.trim();
+  const wordCount = trimmed ? trimmed.split(/\s+/).length : 0;
+  let finalConfidence = confidence;
+  if (trimmed.length <= 12 || wordCount <= 2) {
+    finalConfidence = Math.min(finalConfidence, 0.65);
+  }
+  if (STRUCTURE_PATTERNS.question.test(trimmed) && finalCategory === "analyze") {
+    finalConfidence = Math.max(finalConfidence, 0.75);
+  }
+  if (wordCount <= 3) {
+    finalConfidence = Math.min(finalConfidence, 0.84);
+  }
+  if (alternatives.length === 0 && finalConfidence < 0.85) {
+    const fallbackConfidence = Math.max(Math.min(finalConfidence, 0.2), 0.05);
+    alternatives = ["analyze", "test", "document"].filter((category) => category !== finalCategory).slice(0, 3).map((category) => ({ category, confidence: fallbackConfidence }));
+  }
+  return {
+    category: finalCategory,
+    confidence: finalConfidence,
+    signals: allSignals,
+    alternatives: alternatives.map((alt) => ({
+      ...alt,
+      confidence: Math.min(alt.confidence, finalConfidence)
+    })),
+    classificationTimeMs: performance.now() - startTime,
+    activity
+  };
+}
+
+export {
+  getDefaultActivityForCategory,
+  inferActivity,
+  classifyIntent
+};
+//# sourceMappingURL=chunk-GI5M67YA.js.map