@ryuenn3123/agentic-senior-core 4.1.0 → 4.2.1

package/lib/cli/adaptive-context.mjs

@@ -0,0 +1,365 @@
+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';
+
+const CONTEXT_BUDGET_POLICY = Object.freeze({
+  maxRecommendedRuleCount: 5,
+  maxFallbackRuleCount: 7,
+});
+
+export function getRuleFamilyCatalog() {
+  return RULE_FAMILY_CATALOG.map((ruleFamily) => ({ ...ruleFamily }));
+}
+
+export function normalizeRequestText(requestText) {
+  return String(requestText || '')
+    .trim()
+    .toLowerCase()
+    .replace(/\s+/g, ' ');
+}
+
+function findMatchedTriggers(normalizedRequestText, triggers) {
+  return triggers.filter((triggerText) => triggerMatchesRequest(normalizedRequestText, triggerText));
+}
+
+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);
+  }
+}
+
+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 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) {
+  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
+  );
+  let status = 'within-budget';
+
+  if (overFallbackRuleCount > 0) {
+    status = 'fallback-required';
+  } else if (overRecommendedRuleCount > 0) {
+    status = 'wide-context';
+  }
+
+  return {
+    status,
+    selectedRuleCount,
+    evidenceSignalCount,
+    maxRecommendedRuleCount: CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount,
+    maxFallbackRuleCount: CONTEXT_BUDGET_POLICY.maxFallbackRuleCount,
+    overRecommendedRuleCount,
+    overFallbackRuleCount,
+  };
+}
+
+export function buildSelectedContextManifest(options = {}) {
+  const {
+    contextFiles = [],
+    requestId = 'adhoc-request',
+    requestText = '',
+  } = options;
+
+  const normalizedRequestText = normalizeRequestText(requestText);
+  const normalizedContextFiles = normalizeContextFiles(contextFiles);
+  const ruleEntryMap = createRuleEntryMap();
+
+  applyDirectTextSignals(ruleEntryMap, normalizedRequestText);
+  applyContextFileSignals(ruleEntryMap, normalizedContextFiles);
+  applyImplicationSignals(ruleEntryMap, normalizedRequestText);
+
+  const matchedRuleEntries = getMatchedRuleEntries(ruleEntryMap);
+
+  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);
+
+  return {
+    schemaVersion: 'adaptive-context-manifest-v1',
+    requestId,
+    contextFiles: normalizedContextFiles,
+    labels,
+    selectedRules,
+    selectedPrompts: collectPromptsForRequest(normalizedRequestText, labels),
+    selectedDocs: collectDocsForLabels(labels),
+    selectedState: collectStateForLabels(labels),
+    skippedRules,
+    uncertainty,
+    budget,
+    fallbackRequired: uncertainty === 'high' || budget.status === 'fallback-required',
+    evidence: evidenceEntries,
+  };
+}
+
+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);
+
+    return {
+      id: fixtureEntry.id,
+      passed: missedRequiredLabels.length === 0,
+      missedRequiredLabels,
+      extraLabels,
+      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;
+
+  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,
+    budgetSummary: {
+      maxSelectedRuleCount,
+      averageSelectedRuleCount: fixtureResults.length === 0
+        ? 0
+        : Number((totalSelectedRuleCount / fixtureResults.length).toFixed(2)),
+      overRecommendedFixtureCount,
+      fallbackFixtureCount,
+      maxRecommendedRuleCount: CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount,
+      maxFallbackRuleCount: CONTEXT_BUDGET_POLICY.maxFallbackRuleCount,
+    },
+    results: fixtureResults,
+  };
+}

package/lib/cli/ascx/adapters/git-diff.mjs

@@ -0,0 +1,223 @@
+const MAX_VISIBLE_FILES = 12;
+const MAX_VISIBLE_HUNKS_PER_FILE = 3;
+const MAX_VISIBLE_CHANGE_LINES_PER_HUNK = 6;
+
+function normalizeDiffPath(rawPath) {
+  return String(rawPath || '')
+    .replace(/^a\//u, '')
+    .replace(/^b\//u, '')
+    .trim();
+}
+
+function pushUnique(lines, nextLine) {
+  const normalizedLine = String(nextLine || '').trimEnd();
+  if (normalizedLine && !lines.includes(normalizedLine)) {
+    lines.push(normalizedLine);
+  }
+}
+
+function createDiffFile(rawHeaderLine) {
+  const headerMatch = rawHeaderLine.match(/^diff --git\s+(.+?)\s+(.+)$/u);
+  const oldPath = normalizeDiffPath(headerMatch?.[1] || '');
+  const newPath = normalizeDiffPath(headerMatch?.[2] || oldPath);
+
+  return {
+    path: newPath || oldPath || 'unknown',
+    oldPath,
+    additions: 0,
+    deletions: 0,
+    hunks: [],
+    markers: [],
+    isGeneratedLike: false,
+  };
+}
+
+function isGeneratedLikePath(filePath) {
+  return /(?:package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|dist\/|build\/|coverage\/|\.min\.(?:js|css)|\.snap$|generated)/iu.test(filePath);
+}
+
+function currentHunk(diffFile) {
+  return diffFile.hunks[diffFile.hunks.length - 1] || null;
+}
+
+function parseDiffFiles(lines) {
+  const diffFiles = [];
+  let activeFile = null;
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git ')) {
+      activeFile = createDiffFile(line);
+      activeFile.isGeneratedLike = isGeneratedLikePath(activeFile.path);
+      diffFiles.push(activeFile);
+      continue;
+    }
+
+    if (!activeFile) {
+      continue;
+    }
+
+    if (line.startsWith('new file mode')) {
+      pushUnique(activeFile.markers, 'new file');
+      continue;
+    }
+
+    if (line.startsWith('deleted file mode')) {
+      pushUnique(activeFile.markers, 'deleted file');
+      continue;
+    }
+
+    if (line.startsWith('rename from ')) {
+      pushUnique(activeFile.markers, `rename from ${line.slice('rename from '.length).trim()}`);
+      continue;
+    }
+
+    if (line.startsWith('rename to ')) {
+      const renamedPath = line.slice('rename to '.length).trim();
+      activeFile.path = renamedPath || activeFile.path;
+      activeFile.isGeneratedLike = isGeneratedLikePath(activeFile.path);
+      pushUnique(activeFile.markers, `rename to ${renamedPath}`);
+      continue;
+    }
+
+    if (line.startsWith('Binary files ') || line.startsWith('GIT binary patch')) {
+      pushUnique(activeFile.markers, 'binary file changed');
+      continue;
+    }
+
+    if (line.startsWith('@@ ')) {
+      activeFile.hunks.push({
+        header: line.trim(),
+        changeLines: [],
+      });
+      continue;
+    }
+
+    if (line.startsWith('+++ ') || line.startsWith('--- ')) {
+      continue;
+    }
+
+    if (line.startsWith('+')) {
+      activeFile.additions += 1;
+      const hunk = currentHunk(activeFile);
+      if (hunk && !activeFile.isGeneratedLike) {
+        pushUnique(hunk.changeLines, line);
+      }
+      continue;
+    }
+
+    if (line.startsWith('-')) {
+      activeFile.deletions += 1;
+      const hunk = currentHunk(activeFile);
+      if (hunk && !activeFile.isGeneratedLike) {
+        pushUnique(hunk.changeLines, line);
+      }
+    }
+  }
+
+  return diffFiles;
+}
+
+function formatDiffFile(diffFile) {
+  const outputLines = [];
+  let truncated = false;
+  const markers = diffFile.markers.length > 0
+    ? ` [${diffFile.markers.join(', ')}]`
+    : '';
+  const generatedMarker = diffFile.isGeneratedLike ? ' [generated/noisy path]' : '';
+
+  outputLines.push(`- ${diffFile.path} (+${diffFile.additions} -${diffFile.deletions})${markers}${generatedMarker}`);
+
+  if (diffFile.isGeneratedLike) {
+    outputLines.push('  detail: omitted generated/noisy diff; raw tee required for exact lines');
+    return { outputLines, truncated: true };
+  }
+
+  const visibleHunks = diffFile.hunks.slice(0, MAX_VISIBLE_HUNKS_PER_FILE);
+  for (const hunk of visibleHunks) {
+    outputLines.push(`  ${hunk.header}`);
+    const visibleChangeLines = hunk.changeLines.slice(0, MAX_VISIBLE_CHANGE_LINES_PER_HUNK);
+    for (const changeLine of visibleChangeLines) {
+      outputLines.push(`  ${changeLine}`);
+    }
+
+    if (hunk.changeLines.length > visibleChangeLines.length) {
+      truncated = true;
+      outputLines.push(`  ... truncated ${hunk.changeLines.length - visibleChangeLines.length} more changed lines in hunk`);
+    }
+  }
+
+  if (diffFile.hunks.length > visibleHunks.length) {
+    truncated = true;
+    outputLines.push(`  ... truncated ${diffFile.hunks.length - visibleHunks.length} more hunks`);
+  }
+
+  if (diffFile.hunks.length === 0 && diffFile.markers.length === 0) {
+    outputLines.push('  detail: no parseable hunks; raw tee required for exact diff');
+    truncated = true;
+  }
+
+  return { outputLines, truncated };
+}
+
+export function compressGitDiffOutput({ stdout, stderr, exitCode }) {
+  const rawOutput = [stdout, stderr].filter(Boolean).join('\n');
+
+  if (exitCode === 0 && rawOutput.trim() === '') {
+    return {
+      filterName: 'git-diff-summary',
+      confident: true,
+      truncated: false,
+      output: 'git diff: no changes',
+      preservedFields: {
+        changedFileList: true,
+      },
+    };
+  }
+
+  const lines = rawOutput.split(/\r?\n/u);
+  const diffFiles = parseDiffFiles(lines);
+
+  if (diffFiles.length === 0) {
+    return {
+      filterName: 'git-diff-raw-parse-uncertain',
+      confident: false,
+      truncated: false,
+      output: rawOutput,
+      preservedFields: {},
+    };
+  }
+
+  const outputLines = [
+    'git diff summary:',
+    `files: ${diffFiles.length}`,
+  ];
+  let truncated = false;
+  const visibleFiles = diffFiles.slice(0, MAX_VISIBLE_FILES);
+
+  for (const diffFile of visibleFiles) {
+    const formattedFile = formatDiffFile(diffFile);
+    outputLines.push(...formattedFile.outputLines);
+    truncated = truncated || formattedFile.truncated;
+  }
+
+  if (diffFiles.length > visibleFiles.length) {
+    truncated = true;
+    outputLines.push(`... truncated ${diffFiles.length - visibleFiles.length} more files`);
+  }
+
+  if (truncated) {
+    outputLines.push('truncation: raw diff available in tee output');
+  }
+
+  return {
+    filterName: 'git-diff-summary',
+    confident: true,
+    truncated,
+    output: outputLines.join('\n'),
+    preservedFields: {
+      changedFileList: true,
+      hunkHeaders: diffFiles.some((diffFile) => diffFile.hunks.length > 0),
+      binaryMarker: diffFiles.some((diffFile) => diffFile.markers.includes('binary file changed')),
+    },
+  };
+}