@ryuenn3123/agentic-senior-core 4.3.14 → 4.4.0

package/lib/cli/adaptive-context.mjs

@@ -1,9 +1,4 @@
-import {
-  DOCS_BY_LABEL,
-  PROMPT_CATALOG,
-  RULE_FAMILY_CATALOG,
-  STATE_BY_LABEL,
-} from './adaptive-context/catalog.mjs';
+import { DOCS_BY_LABEL, PROMPT_CATALOG, RULE_FAMILY_CATALOG, STATE_BY_LABEL } from './adaptive-context/catalog.mjs';
 import { CONTEXT_FILE_CATALOG } from './adaptive-context/file-signals.mjs';
 import { IMPLICATION_CATALOG } from './adaptive-context/implications.mjs';
 
@@ -17,217 +12,33 @@ export function getRuleFamilyCatalog() {
 }
 
 export function normalizeRequestText(requestText) {
-  return String(requestText || '')
-    .trim()
-    .toLowerCase()
-    .replace(/\s+/g, ' ');
+  return String(requestText || '').trim().toLowerCase().replace(/\s+/g, ' ');
 }
 
-function findMatchedTriggers(normalizedRequestText, triggers) {
-  return triggers.filter((triggerText) => triggerMatchesRequest(normalizedRequestText, triggerText));
+function triggerMatchesRequest(text, trigger) {
+  if (!text || !trigger) return false;
+  return /^[a-z0-9 ]+$/.test(trigger)
+    ? new RegExp(`(^|[^a-z0-9])${trigger.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9]|$)`).test(text)
+    : text.includes(trigger);
 }
 
-function escapeRegExp(rawText) {
-  return rawText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function triggerMatchesRequest(normalizedRequestText, triggerText) {
-  if (!normalizedRequestText || !triggerText) {
-    return false;
-  }
-
-  if (/^[a-z0-9 ]+$/.test(triggerText)) {
-    const triggerPattern = new RegExp(`(^|[^a-z0-9])${escapeRegExp(triggerText)}([^a-z0-9]|$)`);
-    return triggerPattern.test(normalizedRequestText);
-  }
-
-  return normalizedRequestText.includes(triggerText);
-}
-
-function compareCatalogEntries(leftEntry, rightEntry) {
-  return leftEntry.priority - rightEntry.priority || leftEntry.label.localeCompare(rightEntry.label);
-}
-
-function normalizeContextFilePath(contextFilePath) {
-  return String(contextFilePath || '')
-    .trim()
-    .replace(/\\/g, '/')
-    .replace(/\/+/g, '/')
-    .toLowerCase();
-}
-
-function normalizeContextFiles(contextFiles) {
-  if (!Array.isArray(contextFiles)) {
-    return [];
-  }
-
-  return contextFiles
-    .map(normalizeContextFilePath)
-    .filter(Boolean);
-}
-
-function uniqueSortedValues(values) {
-  return Array.from(new Set(values)).sort((leftValue, rightValue) => leftValue.localeCompare(rightValue));
-}
-
-function collectDocsForLabels(labels) {
-  const selectedDocs = ['docs/doc-index.md'];
-
-  for (const label of labels) {
-    selectedDocs.push(...(DOCS_BY_LABEL[label] || []));
-  }
-
-  return uniqueSortedValues(selectedDocs);
-}
-
-function collectStateForLabels(labels) {
-  const selectedState = ['.agent-context/state/onboarding-report.json'];
-
-  for (const label of labels) {
-    selectedState.push(...(STATE_BY_LABEL[label] || []));
-  }
-
-  return uniqueSortedValues(selectedState);
-}
-
-function collectPromptsForRequest(normalizedRequestText, labels) {
-  const selectedPrompts = [];
-
-  for (const promptEntry of PROMPT_CATALOG) {
-    const labelMatched = Array.isArray(promptEntry.labels)
-      && promptEntry.labels.some((label) => labels.includes(label));
-    const triggerMatched = findMatchedTriggers(normalizedRequestText, promptEntry.triggers).length > 0;
-
-    if (labelMatched || triggerMatched) {
-      selectedPrompts.push(promptEntry.promptPath);
-    }
-  }
-
-  return uniqueSortedValues(selectedPrompts);
-}
-
-function createRuleEntryMap() {
-  const ruleEntryMap = new Map();
-
-  for (const ruleFamily of RULE_FAMILY_CATALOG) {
-    ruleEntryMap.set(ruleFamily.label, {
-      ...ruleFamily,
-      matchedTriggers: [],
-      matchedFiles: [],
-      matchedImplications: [],
-    });
-  }
-
-  return ruleEntryMap;
-}
-
-function getMatchedRuleEntries(ruleEntryMap) {
-  return Array.from(ruleEntryMap.values())
-    .filter((ruleFamily) => {
-      return ruleFamily.matchedTriggers.length > 0
-        || ruleFamily.matchedFiles.length > 0
-        || ruleFamily.matchedImplications.length > 0;
-    })
-    .sort(compareCatalogEntries);
-}
-
-function pushUniqueSignal(values, nextValue) {
-  if (nextValue && !values.includes(nextValue)) {
-    values.push(nextValue);
-  }
-}
+const uniqueSorted = (arr) => Array.from(new Set(arr)).sort((a, b) => a.localeCompare(b));
 
-function applyDirectTextSignals(ruleEntryMap, normalizedRequestText) {
-  for (const ruleFamily of RULE_FAMILY_CATALOG) {
-    const matchedTriggers = findMatchedTriggers(normalizedRequestText, ruleFamily.triggers);
-    const targetRuleEntry = ruleEntryMap.get(ruleFamily.label);
-
-    for (const matchedTrigger of matchedTriggers) {
-      pushUniqueSignal(targetRuleEntry.matchedTriggers, matchedTrigger);
-    }
-  }
-}
-
-function applyContextFileSignals(ruleEntryMap, normalizedContextFiles) {
-  for (const contextFilePath of normalizedContextFiles) {
-    for (const fileSignal of CONTEXT_FILE_CATALOG) {
-      if (!fileSignal.patterns.some((filePattern) => filePattern.test(contextFilePath))) {
-        continue;
-      }
-
-      const targetRuleEntry = ruleEntryMap.get(fileSignal.label);
-      pushUniqueSignal(targetRuleEntry.matchedFiles, contextFilePath);
-    }
-  }
+function resolveUncertainty(labels, evidence, text) {
+  if (!text || !labels.length) return 'high';
+  const hasSparseEvidence = evidence.some(e => (e.matchedTriggers.length + e.matchedFiles.length + e.matchedImplications.length) === 1);
+  return (labels.length >= 6 || hasSparseEvidence) ? 'medium' : 'low';
 }
 
-function applyImplicationSignals(ruleEntryMap, normalizedRequestText) {
-  const matchedLabelSet = new Set(getMatchedRuleEntries(ruleEntryMap).map((ruleFamily) => ruleFamily.label));
-
-  for (const implicationRule of IMPLICATION_CATALOG) {
-    const hasRequiredLabel = implicationRule.requiresAnyLabel.some((label) => matchedLabelSet.has(label));
-    if (!hasRequiredLabel) {
-      continue;
-    }
-
-    const matchedTriggers = findMatchedTriggers(normalizedRequestText, implicationRule.triggers);
-    if (matchedTriggers.length === 0) {
-      continue;
-    }
-
-    const targetRuleEntry = ruleEntryMap.get(implicationRule.label);
-    const implicationDetail = `${implicationRule.reason}: ${matchedTriggers.join(', ')}`;
-    pushUniqueSignal(targetRuleEntry.matchedImplications, implicationDetail);
-    matchedLabelSet.add(implicationRule.label);
-  }
-}
-
-function countEvidenceSignals(evidenceEntry) {
-  return evidenceEntry.matchedTriggers.length
-    + evidenceEntry.matchedFiles.length
-    + evidenceEntry.matchedImplications.length;
-}
-
-function resolveUncertainty(labels, evidenceEntries, normalizedRequestText) {
-  if (!normalizedRequestText) {
-    return 'high';
-  }
-
-  if (labels.length === 0) {
-    return 'high';
-  }
-
-  const hasSparseEvidence = evidenceEntries.some((evidenceEntry) => countEvidenceSignals(evidenceEntry) === 1);
-  const hasManyLabels = labels.length >= 6;
-
-  if (hasManyLabels || hasSparseEvidence) {
-    return 'medium';
-  }
-
-  return 'low';
-}
-
-function buildContextBudget(labels, evidenceEntries) {
+function buildContextBudget(labels, evidence) {
   const selectedRuleCount = labels.length;
-  const evidenceSignalCount = evidenceEntries.reduce(
-    (totalCount, evidenceEntry) => totalCount + countEvidenceSignals(evidenceEntry),
-    0
-  );
-  const overRecommendedRuleCount = Math.max(
-    0,
-    selectedRuleCount - CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount
-  );
-  const overFallbackRuleCount = Math.max(
-    0,
-    selectedRuleCount - CONTEXT_BUDGET_POLICY.maxFallbackRuleCount
-  );
+  const evidenceSignalCount = evidence.reduce((sum, e) => sum + e.matchedTriggers.length + e.matchedFiles.length + e.matchedImplications.length, 0);
+  const overRecommendedRuleCount = Math.max(0, selectedRuleCount - CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount);
+  const overFallbackRuleCount = Math.max(0, selectedRuleCount - CONTEXT_BUDGET_POLICY.maxFallbackRuleCount);
+  
   let status = 'within-budget';
-
-  if (overFallbackRuleCount > 0) {
-    status = 'fallback-required';
-  } else if (overRecommendedRuleCount > 0) {
-    status = 'wide-context';
-  }
+  if (overFallbackRuleCount > 0) status = 'fallback-required';
+  else if (overRecommendedRuleCount > 0) status = 'wide-context';
 
   return {
     status,
@@ -240,126 +51,101 @@ function buildContextBudget(labels, evidenceEntries) {
   };
 }
 
-export function buildSelectedContextManifest(options = {}) {
-  const {
-    contextFiles = [],
-    requestId = 'adhoc-request',
-    requestText = '',
-  } = options;
+export function buildSelectedContextManifest({ contextFiles = [], requestId = 'adhoc-request', requestText = '' } = {}) {
+  const normText = normalizeRequestText(requestText);
+  const normFiles = (Array.isArray(contextFiles) ? contextFiles : [])
+    .map(f => String(f || '').trim().replace(/\\/g, '/').replace(/\/+/g, '/').toLowerCase())
+    .filter(Boolean);
+
+  const matchedEntries = RULE_FAMILY_CATALOG.map(rule => {
+    const matchedTriggers = rule.triggers.filter(t => triggerMatchesRequest(normText, t));
+    const filePatterns = CONTEXT_FILE_CATALOG.find(c => c.label === rule.label)?.patterns || [];
+    const matchedFiles = normFiles.filter(f => filePatterns.some(p => p.test(f)));
+    return { ...rule, matchedTriggers, matchedFiles, matchedImplications: [] };
+  });
+
+  const matchedLabelSet = new Set(matchedEntries.filter(e => e.matchedTriggers.length || e.matchedFiles.length).map(e => e.label));
+
+  for (const imp of IMPLICATION_CATALOG) {
+    if (imp.requiresAnyLabel.some(l => matchedLabelSet.has(l))) {
+      const triggers = imp.triggers.filter(t => triggerMatchesRequest(normText, t));
+      if (triggers.length) {
+        const target = matchedEntries.find(e => e.label === imp.label);
+        if (target) {
+          const detail = `${imp.reason}: ${triggers.join(', ')}`;
+          if (!target.matchedImplications.includes(detail)) target.matchedImplications.push(detail);
+          matchedLabelSet.add(imp.label);
+        }
+      }
+    }
+  }
 
-  const normalizedRequestText = normalizeRequestText(requestText);
-  const normalizedContextFiles = normalizeContextFiles(contextFiles);
-  const ruleEntryMap = createRuleEntryMap();
+  const matchedRuleEntries = matchedEntries
+    .filter(e => e.matchedTriggers.length || e.matchedFiles.length || e.matchedImplications.length)
+    .sort((a, b) => a.priority - b.priority || a.label.localeCompare(b.label));
 
-  applyDirectTextSignals(ruleEntryMap, normalizedRequestText);
-  applyContextFileSignals(ruleEntryMap, normalizedContextFiles);
-  applyImplicationSignals(ruleEntryMap, normalizedRequestText);
+  const labels = matchedRuleEntries.map(e => e.label);
+  const evidence = matchedRuleEntries.map(({ label, matchedTriggers, matchedFiles, matchedImplications }) => ({ label, matchedTriggers, matchedFiles, matchedImplications }));
+  const uncertainty = resolveUncertainty(labels, evidence, normText);
+  const budget = buildContextBudget(labels, evidence);
 
-  const matchedRuleEntries = getMatchedRuleEntries(ruleEntryMap);
+  const selectedRuleSet = new Set(matchedRuleEntries.map(e => e.rulePath));
 
-  const labels = matchedRuleEntries.map((ruleFamily) => ruleFamily.label);
-  const selectedRules = matchedRuleEntries.map((ruleFamily) => ruleFamily.rulePath);
-  const selectedRuleSet = new Set(selectedRules);
-  const skippedRules = RULE_FAMILY_CATALOG
-    .map((ruleFamily) => ruleFamily.rulePath)
-    .filter((rulePath) => !selectedRuleSet.has(rulePath))
-    .sort((leftPath, rightPath) => leftPath.localeCompare(rightPath));
-  const evidenceEntries = matchedRuleEntries.map((ruleFamily) => ({
-    label: ruleFamily.label,
-    matchedTriggers: ruleFamily.matchedTriggers,
-    matchedFiles: ruleFamily.matchedFiles,
-    matchedImplications: ruleFamily.matchedImplications,
-  }));
-  const uncertainty = resolveUncertainty(labels, evidenceEntries, normalizedRequestText);
-  const budget = buildContextBudget(labels, evidenceEntries);
+  const selectedPrompts = PROMPT_CATALOG
+    .filter(p => (Array.isArray(p.labels) && p.labels.some(l => labels.includes(l))) || p.triggers.some(t => triggerMatchesRequest(normText, t)))
+    .map(p => p.promptPath);
 
   return {
     schemaVersion: 'adaptive-context-manifest-v1',
     requestId,
-    contextFiles: normalizedContextFiles,
+    contextFiles: normFiles,
     labels,
-    selectedRules,
-    selectedPrompts: collectPromptsForRequest(normalizedRequestText, labels),
-    selectedDocs: collectDocsForLabels(labels),
-    selectedState: collectStateForLabels(labels),
-    skippedRules,
+    selectedRules: matchedRuleEntries.map(e => e.rulePath),
+    selectedPrompts: uniqueSorted(selectedPrompts),
+    selectedDocs: uniqueSorted(['docs/doc-index.md', ...labels.flatMap(l => DOCS_BY_LABEL[l] || [])]),
+    selectedState: uniqueSorted(['.agent-context/state/onboarding-report.json', ...labels.flatMap(l => STATE_BY_LABEL[l] || [])]),
+    skippedRules: RULE_FAMILY_CATALOG.map(r => r.rulePath).filter(r => !selectedRuleSet.has(r)).sort((a, b) => a.localeCompare(b)),
     uncertainty,
     budget,
     fallbackRequired: uncertainty === 'high' || budget.status === 'fallback-required',
-    evidence: evidenceEntries,
+    evidence,
   };
 }
 
-function compareRequiredLabels(requiredLabels, actualLabels) {
-  const actualLabelSet = new Set(actualLabels);
-
-  return requiredLabels.filter((requiredLabel) => !actualLabelSet.has(requiredLabel));
-}
-
-function compareExtraLabels(expectedLabels, actualLabels) {
-  const expectedLabelSet = new Set(expectedLabels);
-
-  return actualLabels.filter((actualLabel) => !expectedLabelSet.has(actualLabel));
-}
-
 export function evaluateAdaptiveContextFixtures(fixtures) {
-  const fixtureResults = fixtures.map((fixtureEntry) => {
-    const manifest = buildSelectedContextManifest({
-      requestId: fixtureEntry.id,
-      requestText: fixtureEntry.requestText,
-    });
-    const missedRequiredLabels = compareRequiredLabels(fixtureEntry.requiredLabels, manifest.labels);
-    const extraLabels = compareExtraLabels(fixtureEntry.allowedLabels || fixtureEntry.requiredLabels, manifest.labels);
-
+  const results = fixtures.map(fixture => {
+    const manifest = buildSelectedContextManifest({ requestId: fixture.id, requestText: fixture.requestText });
+    const reqSet = new Set(fixture.requiredLabels);
+    const allowSet = new Set(fixture.allowedLabels || fixture.requiredLabels);
     return {
-      id: fixtureEntry.id,
-      passed: missedRequiredLabels.length === 0,
-      missedRequiredLabels,
-      extraLabels,
+      id: fixture.id,
+      passed: fixture.requiredLabels.every(l => manifest.labels.includes(l)),
+      missedRequiredLabels: fixture.requiredLabels.filter(l => !manifest.labels.includes(l)),
+      extraLabels: manifest.labels.filter(l => !allowSet.has(l)),
       manifest,
     };
   });
-  const failedFixtures = fixtureResults.filter((fixtureResult) => !fixtureResult.passed);
-  const missedRequiredLabelCount = fixtureResults.reduce(
-    (totalCount, fixtureResult) => totalCount + fixtureResult.missedRequiredLabels.length,
-    0
-  );
-  const extraLabelCount = fixtureResults.reduce(
-    (totalCount, fixtureResult) => totalCount + fixtureResult.extraLabels.length,
-    0
-  );
-  const selectedRuleCounts = fixtureResults.map((fixtureResult) => fixtureResult.manifest.budget.selectedRuleCount);
-  const maxSelectedRuleCount = Math.max(...selectedRuleCounts, 0);
-  const totalSelectedRuleCount = selectedRuleCounts.reduce(
-    (totalCount, selectedRuleCount) => totalCount + selectedRuleCount,
-    0
-  );
-  const overRecommendedFixtureCount = fixtureResults.filter((fixtureResult) => {
-    return fixtureResult.manifest.budget.status !== 'within-budget';
-  }).length;
-  const fallbackFixtureCount = fixtureResults.filter((fixtureResult) => {
-    return fixtureResult.manifest.fallbackRequired;
-  }).length;
+
+  const failed = results.filter(r => !r.passed);
+  const selectedRuleCounts = results.map(r => r.manifest.budget.selectedRuleCount);
 
   return {
     reportName: 'adaptive-context-benchmark',
     generatedAt: new Date().toISOString(),
-    fixtureCount: fixtureResults.length,
-    passed: failedFixtures.length === 0,
-    passedCount: fixtureResults.length - failedFixtures.length,
-    failedCount: failedFixtures.length,
-    missedRequiredLabelCount,
-    extraLabelCount,
+    fixtureCount: results.length,
+    passed: failed.length === 0,
+    passedCount: results.length - failed.length,
+    failedCount: failed.length,
+    missedRequiredLabelCount: results.reduce((sum, r) => sum + r.missedRequiredLabels.length, 0),
+    extraLabelCount: results.reduce((sum, r) => sum + r.extraLabels.length, 0),
     budgetSummary: {
-      maxSelectedRuleCount,
-      averageSelectedRuleCount: fixtureResults.length === 0
-        ? 0
-        : Number((totalSelectedRuleCount / fixtureResults.length).toFixed(2)),
-      overRecommendedFixtureCount,
-      fallbackFixtureCount,
+      maxSelectedRuleCount: Math.max(0, ...selectedRuleCounts),
+      averageSelectedRuleCount: results.length ? Number((selectedRuleCounts.reduce((a, b) => a + b, 0) / results.length).toFixed(2)) : 0,
+      overRecommendedFixtureCount: results.filter(r => r.manifest.budget.status !== 'within-budget').length,
+      fallbackFixtureCount: results.filter(r => r.manifest.fallbackRequired).length,
       maxRecommendedRuleCount: CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount,
       maxFallbackRuleCount: CONTEXT_BUDGET_POLICY.maxFallbackRuleCount,
     },
-    results: fixtureResults,
+    results,
   };
 }