@ryuenn3123/agentic-senior-core 4.1.0 → 4.2.1

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

@@ -0,0 +1,145 @@
+const MAX_VISIBLE_STATUS_ENTRIES_PER_SECTION = 15;
+
+function cleanStatusLine(line) {
+  return line.trim().replace(/\s+/g, ' ');
+}
+
+function createSection(title) {
+  return {
+    title,
+    entries: [],
+  };
+}
+
+function pushSectionEntry(section, line) {
+  const cleanedLine = cleanStatusLine(line);
+  if (cleanedLine && !section.entries.includes(cleanedLine)) {
+    section.entries.push(cleanedLine);
+  }
+}
+
+function parseLongStatus(lines) {
+  const sections = [];
+  let activeSection = null;
+  let isClean = false;
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine.includes('nothing to commit, working tree clean')) {
+      isClean = true;
+    }
+
+    if (trimmedLine === 'Changes to be committed:') {
+      activeSection = createSection('staged');
+      sections.push(activeSection);
+      continue;
+    }
+
+    if (trimmedLine === 'Changes not staged for commit:') {
+      activeSection = createSection('unstaged');
+      sections.push(activeSection);
+      continue;
+    }
+
+    if (trimmedLine === 'Untracked files:') {
+      activeSection = createSection('untracked');
+      sections.push(activeSection);
+      continue;
+    }
+
+    if (!activeSection || !line.startsWith('\t')) {
+      continue;
+    }
+
+    pushSectionEntry(activeSection, line);
+  }
+
+  return { sections, isClean };
+}
+
+function parseShortStatus(lines) {
+  const shortEntries = lines
+    .map((line) => line.trimEnd())
+    .filter((line) => /^[ MADRCU?!]{1,2}\s+.+/u.test(line));
+
+  if (shortEntries.length === 0) {
+    return [];
+  }
+
+  return [
+    {
+      title: 'short-status',
+      entries: shortEntries,
+    },
+  ];
+}
+
+function formatSections(sections) {
+  const outputLines = [];
+  let truncated = false;
+
+  for (const section of sections) {
+    outputLines.push(`${section.title}: ${section.entries.length}`);
+    const visibleEntries = section.entries.slice(0, MAX_VISIBLE_STATUS_ENTRIES_PER_SECTION);
+
+    for (const entry of visibleEntries) {
+      outputLines.push(`- ${entry}`);
+    }
+
+    if (section.entries.length > visibleEntries.length) {
+      truncated = true;
+      outputLines.push(`... truncated ${section.entries.length - visibleEntries.length} more ${section.title} entries`);
+    }
+  }
+
+  return {
+    outputLines,
+    truncated,
+  };
+}
+
+export function compressGitStatusOutput({ stdout, stderr, exitCode }) {
+  const rawOutput = [stdout, stderr].filter(Boolean).join('\n');
+  const lines = rawOutput.split(/\r?\n/u);
+  const longStatus = parseLongStatus(lines);
+  const shortStatusSections = parseShortStatus(lines);
+  const sections = longStatus.sections.length > 0 ? longStatus.sections : shortStatusSections;
+
+  if (exitCode === 0 && longStatus.isClean) {
+    return {
+      filterName: 'git-status-summary',
+      confident: true,
+      truncated: false,
+      output: 'git status: working tree clean',
+      preservedFields: {
+        changedFileList: true,
+      },
+    };
+  }
+
+  if (sections.length === 0) {
+    return {
+      filterName: 'git-status-raw-parse-uncertain',
+      confident: false,
+      truncated: false,
+      output: rawOutput,
+      preservedFields: {},
+    };
+  }
+
+  const formattedSections = formatSections(sections);
+
+  return {
+    filterName: 'git-status-summary',
+    confident: true,
+    truncated: formattedSections.truncated,
+    output: [
+      'git status summary:',
+      ...formattedSections.outputLines,
+    ].join('\n'),
+    preservedFields: {
+      changedFileList: true,
+    },
+  };
+}

package/lib/cli/ascx/adapters/npm-run-build.mjs

@@ -0,0 +1,99 @@
+const FAILURE_LINE_PATTERN = /(?:^Error:|^TypeError:|^SyntaxError|^ReferenceError|^TS\d+:\s|^Failed to compile|Module not found|ERR!|error\b|ERROR\b|×|✖|failure|FAIL\b)/iu;
+const FILE_LINE_PATTERN = /(?:[A-Za-z]:)?[^:\s]+?\.(?:cjs|mjs|js|jsx|ts|tsx|vue|svelte|css|scss|html|json):\d+(?::\d+)?/u;
+
+function pushUniqueLine(lines, nextLine) {
+  const normalizedLine = String(nextLine || '').trimEnd();
+  if (normalizedLine && !lines.includes(normalizedLine)) {
+    lines.push(normalizedLine);
+  }
+}
+
+function extractFailureLines(lines) {
+  const keptLines = [];
+  let contextBuffer = [];
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    // Preserve empty lines in context buffer to maintain readability if we decide to flush it
+    if (!trimmedLine) {
+      if (contextBuffer.length > 0) {
+        contextBuffer.push(line);
+      }
+      continue;
+    }
+
+    const isFailureLine = FAILURE_LINE_PATTERN.test(trimmedLine) || FILE_LINE_PATTERN.test(trimmedLine);
+    
+    if (isFailureLine) {
+      // If we found a failure, flush the preceding short context (e.g., file paths that didn't match the regex but preceded an error)
+      for (const ctxLine of contextBuffer) {
+        pushUniqueLine(keptLines, ctxLine);
+      }
+      contextBuffer = [];
+      pushUniqueLine(keptLines, line);
+    } else {
+      // Keep a small rolling buffer of context lines (max 2) before an error
+      contextBuffer.push(line);
+      if (contextBuffer.length > 2) {
+        contextBuffer.shift();
+      }
+    }
+  }
+
+  return keptLines;
+}
+
+export function compressNpmRunBuildOutput({ stdout, stderr, exitCode }) {
+  const rawOutput = [stdout, stderr].filter(Boolean).join('\n');
+  const lines = rawOutput.split(/\r?\n/u);
+  
+  // If exit code is 0, build probably succeeded, just return a short success message.
+  if (exitCode === 0) {
+    return {
+      filterName: 'npm-run-build-summary',
+      confident: true,
+      truncated: false,
+      output: 'npm run build summary:\nresult: passed',
+      preservedFields: {
+        exitCode: true,
+      },
+    };
+  }
+
+  const failureLines = extractFailureLines(lines);
+  const outputLines = ['npm run build summary:'];
+
+  if (failureLines.length > 0) {
+    outputLines.push('failures:');
+    outputLines.push(...failureLines.slice(0, 100));
+  }
+
+  const truncated = failureLines.length > 100;
+  if (truncated) {
+    outputLines.push(`... truncated ${failureLines.length - 100} more failure evidence lines`);
+  }
+
+  if (failureLines.length === 0) {
+    // We couldn't parse the errors clearly, fallback to raw
+    return {
+      filterName: 'npm-run-build-raw-parse-uncertain',
+      confident: false,
+      truncated: false,
+      output: rawOutput,
+      preservedFields: {},
+    };
+  }
+
+  return {
+    filterName: 'npm-run-build-summary',
+    confident: true,
+    truncated,
+    output: outputLines.join('\n'),
+    preservedFields: {
+      rootError: failureLines.length > 0,
+      filePath: failureLines.some((line) => FILE_LINE_PATTERN.test(line)),
+      exitCode: true,
+    },
+  };
+}

package/lib/cli/ascx/adapters/npm-test.mjs

@@ -0,0 +1,120 @@
+const FAILURE_LINE_PATTERN = /(?:^not ok\b|AssertionError|Error:|TypeError:|ReferenceError|SyntaxError|Expected|Received|actual:|expected:|operator:|ERR!|failed|failure|FAIL\b|✖|×)/iu;
+const FILE_LINE_PATTERN = /(?:[A-Za-z]:)?[^:\s]+?\.(?:cjs|mjs|js|jsx|ts|tsx):\d+(?::\d+)?/u;
+const SUMMARY_LINE_PATTERN = /^#\s+(?:tests|suites|pass|fail|cancelled|skipped|todo|duration_ms)\b/u;
+
+function pushUniqueLine(lines, nextLine) {
+  const normalizedLine = String(nextLine || '').trimEnd();
+  if (normalizedLine && !lines.includes(normalizedLine)) {
+    lines.push(normalizedLine);
+  }
+}
+
+function extractTapSummary(lines) {
+  return lines.filter((line) => SUMMARY_LINE_PATTERN.test(line.trim()));
+}
+
+function extractFailureLines(lines) {
+  const keptLines = [];
+  let lastSubtestLine = '';
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine.startsWith('# Subtest:')) {
+      lastSubtestLine = trimmedLine;
+      continue;
+    }
+
+    if (SUMMARY_LINE_PATTERN.test(trimmedLine)) {
+      continue;
+    }
+
+    const isFailureLine = FAILURE_LINE_PATTERN.test(trimmedLine) || FILE_LINE_PATTERN.test(trimmedLine);
+    if (!isFailureLine) {
+      continue;
+    }
+
+    if (lastSubtestLine) {
+      pushUniqueLine(keptLines, lastSubtestLine);
+    }
+    pushUniqueLine(keptLines, line);
+  }
+
+  return keptLines;
+}
+
+function hasTestSummary(summaryLines) {
+  return summaryLines.some((line) => /^#\s+tests\b/u.test(line.trim()));
+}
+
+function getTapSummaryCount(summaryLines, summaryKey) {
+  const summaryLine = summaryLines.find((line) => {
+    return line.trim().startsWith(`# ${summaryKey} `);
+  });
+  const countMatch = summaryLine?.trim().match(/^#\s+\w+\s+(\d+)$/u);
+
+  return countMatch ? Number.parseInt(countMatch[1], 10) : null;
+}
+
+export function compressNpmTestOutput({ stdout, stderr, exitCode }) {
+  const rawOutput = [stdout, stderr].filter(Boolean).join('\n');
+  const lines = rawOutput.split(/\r?\n/u);
+  const summaryLines = extractTapSummary(lines);
+  const failCount = getTapSummaryCount(summaryLines, 'fail');
+  const shouldPreserveFailureEvidence = exitCode !== 0 || (typeof failCount === 'number' && failCount > 0);
+  const failureLines = shouldPreserveFailureEvidence ? extractFailureLines(lines) : [];
+  const outputLines = ['npm test summary:'];
+
+  if (summaryLines.length > 0) {
+    outputLines.push(...summaryLines);
+  }
+
+  if (failureLines.length > 0) {
+    outputLines.push('failures:');
+    outputLines.push(...failureLines.slice(0, 80));
+  }
+
+  const truncated = failureLines.length > 80;
+  if (truncated) {
+    outputLines.push(`... truncated ${failureLines.length - 80} more failure evidence lines`);
+  }
+
+  if (exitCode === 0 && failureLines.length === 0) {
+    if (!hasTestSummary(summaryLines)) {
+      outputLines.push('result: passed');
+    }
+
+    return {
+      filterName: 'npm-test-summary',
+      confident: true,
+      truncated: false,
+      output: outputLines.join('\n'),
+      preservedFields: {
+        exitCode: true,
+      },
+    };
+  }
+
+  if (failureLines.length === 0 && summaryLines.length === 0) {
+    return {
+      filterName: 'npm-test-raw-parse-uncertain',
+      confident: false,
+      truncated: false,
+      output: rawOutput,
+      preservedFields: {},
+    };
+  }
+
+  return {
+    filterName: 'npm-test-summary',
+    confident: true,
+    truncated,
+    output: outputLines.join('\n'),
+    preservedFields: {
+      rootError: failureLines.length > 0,
+      filePath: failureLines.some((line) => FILE_LINE_PATTERN.test(line)),
+      failingTestName: failureLines.some((line) => line.trim().startsWith('# Subtest:')),
+      assertionMessage: failureLines.some((line) => /AssertionError|Expected|Received|actual:|expected:/iu.test(line)),
+    },
+  };
+}

package/lib/cli/ascx/adapters/rg.mjs

@@ -0,0 +1,39 @@
+export function compressRgOutput({ stdout, stderr, exitCode }) {
+  const rawOutput = [stdout, stderr].filter(Boolean).join('\n');
+  const lines = rawOutput.split(/\r?\n/u);
+  
+  // If exit code is non-zero and no output, rg found nothing or errored
+  if (lines.length === 0 || (lines.length === 1 && lines[0] === '')) {
+    return {
+      filterName: 'rg-summary',
+      confident: true,
+      truncated: false,
+      output: exitCode === 0 ? 'No matches found.' : `ripgrep exited with code ${exitCode}`,
+      preservedFields: {
+        exitCode: true,
+      },
+    };
+  }
+
+  const outputLines = ['ripgrep results:'];
+  const maxLines = 80;
+
+  if (lines.length > maxLines) {
+    outputLines.push(...lines.slice(0, maxLines));
+    outputLines.push(`... truncated ${lines.length - maxLines} more lines of matches`);
+    outputLines.push(`truncation: full search results available in the raw tee output`);
+  } else {
+    outputLines.push(...lines);
+  }
+
+  return {
+    filterName: 'rg-summary',
+    confident: true,
+    truncated: lines.length > maxLines,
+    output: outputLines.join('\n'),
+    preservedFields: {
+      exitCode: true,
+      filePath: true, // We assume rg output contains file paths
+    },
+  };
+}

package/lib/cli/ascx/fixture-evaluator.mjs

@@ -0,0 +1,180 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { runAscx } from './runtime.mjs';
+import { estimateOutputTokens } from './token-estimate.mjs';
+
+function combineOutput(stdout, stderr) {
+  return [stdout, stderr].filter(Boolean).join('\n');
+}
+
+async function fileExists(filePath) {
+  if (!filePath) {
+    return false;
+  }
+
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function buildFakeExecutor(fixtureEntry) {
+  return async () => ({
+    stdout: fixtureEntry.capture.stdout,
+    stderr: fixtureEntry.capture.stderr,
+    exitCode: fixtureEntry.capture.exitCode,
+  });
+}
+
+function evaluateContinuationChecks(fixtureEntry, output, teeExists) {
+  return (fixtureEntry.continuationChecks || []).map((continuationCheck) => {
+    const missingRequiredSubstrings = (continuationCheck.requiredSubstrings || [])
+      .filter((requiredSubstring) => !output.includes(requiredSubstring));
+    const presentForbiddenSubstrings = (continuationCheck.forbiddenSubstrings || [])
+      .filter((forbiddenSubstring) => output.includes(forbiddenSubstring));
+    const teeStateMatched = typeof continuationCheck.expectTee === 'boolean'
+      ? continuationCheck.expectTee === teeExists
+      : true;
+
+    return {
+      id: continuationCheck.id,
+      action: continuationCheck.action,
+      passed: missingRequiredSubstrings.length === 0
+        && presentForbiddenSubstrings.length === 0
+        && teeStateMatched,
+      missingRequiredSubstrings,
+      presentForbiddenSubstrings,
+      expectedTee: continuationCheck.expectTee ?? null,
+      teeStateMatched,
+    };
+  });
+}
+
+async function evaluateFixture(fixtureEntry, options) {
+  const result = await runAscx(fixtureEntry.commandArguments, {
+    cwd: options.cwd,
+    executeCommand: buildFakeExecutor(fixtureEntry),
+    teeDirectoryPath: options.teeDirectoryPath,
+  });
+  const output = combineOutput(result.stdout, result.stderr);
+  const missingRequiredSubstrings = (fixtureEntry.requiredSubstrings || [])
+    .filter((requiredSubstring) => !output.includes(requiredSubstring));
+  const presentForbiddenSubstrings = (fixtureEntry.forbiddenSubstrings || [])
+    .filter((forbiddenSubstring) => output.includes(forbiddenSubstring));
+  const exitCodePreserved = result.exitCode === fixtureEntry.capture.exitCode;
+  const compressionStateMatched = result.compressed === fixtureEntry.expectCompressed;
+  const teeExists = await fileExists(result.rawTeePath);
+  const teeStateMatched = fixtureEntry.expectTee === teeExists;
+  const falseSuccess = fixtureEntry.capture.exitCode !== 0 && result.exitCode === 0;
+  const rawOutput = combineOutput(fixtureEntry.capture.stdout, fixtureEntry.capture.stderr);
+  const rawTokens = estimateOutputTokens(rawOutput);
+  const outputTokens = estimateOutputTokens(output);
+  const continuationChecks = evaluateContinuationChecks(fixtureEntry, output, teeExists);
+  const failedContinuationChecks = continuationChecks.filter((continuationCheck) => {
+    return !continuationCheck.passed;
+  });
+
+  return {
+    id: fixtureEntry.id,
+    passed: missingRequiredSubstrings.length === 0
+      && presentForbiddenSubstrings.length === 0
+      && exitCodePreserved
+      && compressionStateMatched
+      && teeStateMatched
+      && !falseSuccess
+      && failedContinuationChecks.length === 0,
+    command: fixtureEntry.commandArguments.join(' '),
+    classification: result.classification,
+    exitCode: result.exitCode,
+    expectedExitCode: fixtureEntry.capture.exitCode,
+    exitCodePreserved,
+    compressed: result.compressed,
+    expectedCompressed: fixtureEntry.expectCompressed,
+    rawTeePath: result.rawTeePath,
+    teeExists,
+    expectedTee: fixtureEntry.expectTee,
+    missingRequiredSubstrings,
+    requiredSubstringCount: (fixtureEntry.requiredSubstrings || []).length,
+    presentForbiddenSubstrings,
+    forbiddenSubstringCount: (fixtureEntry.forbiddenSubstrings || []).length,
+    falseSuccess,
+    continuationChecks,
+    continuationCheckCount: continuationChecks.length,
+    failedContinuationChecks,
+    rawTokens,
+    outputTokens,
+    reductionPercent: rawTokens === 0
+      ? 0
+      : Number((((rawTokens - outputTokens) / rawTokens) * 100).toFixed(2)),
+  };
+}
+
+export async function evaluateAscxFixtures(fixtures, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const teeDirectoryPath = path.resolve(
+    options.teeDirectoryPath || path.join(cwd, '.agent-context', 'state', 'token-saver', 'tee')
+  );
+  const results = [];
+
+  for (const fixtureEntry of fixtures) {
+    results.push(await evaluateFixture(fixtureEntry, {
+      cwd,
+      teeDirectoryPath,
+    }));
+  }
+
+  const failedResults = results.filter((result) => !result.passed);
+  const evidenceCheckCount = results.reduce((totalCount, result) => {
+    return totalCount
+      + result.requiredSubstringCount
+      + result.forbiddenSubstringCount
+      + 4;
+  }, 0);
+  const failedEvidenceCheckCount = results.reduce((totalCount, result) => {
+    return totalCount
+      + result.missingRequiredSubstrings.length
+      + result.presentForbiddenSubstrings.length
+      + (result.exitCodePreserved ? 0 : 1)
+      + (result.compressed === result.expectedCompressed ? 0 : 1)
+      + (result.teeExists === result.expectedTee ? 0 : 1)
+      + (result.falseSuccess ? 1 : 0);
+  }, 0);
+  const rawTokens = results.reduce((totalCount, result) => totalCount + result.rawTokens, 0);
+  const outputTokens = results.reduce((totalCount, result) => totalCount + result.outputTokens, 0);
+  const continuationCheckCount = results.reduce((totalCount, result) => {
+    return totalCount + result.continuationCheckCount;
+  }, 0);
+  const failedContinuationCheckCount = results.reduce((totalCount, result) => {
+    return totalCount + result.failedContinuationChecks.length;
+  }, 0);
+
+  return {
+    reportName: 'ascx-runtime-token-saver-benchmark',
+    generatedAt: new Date().toISOString(),
+    fixtureCount: results.length,
+    passed: failedResults.length === 0,
+    passedCount: results.length - failedResults.length,
+    failedCount: failedResults.length,
+    summary: {
+      rawTokens,
+      outputTokens,
+      estimatedTokenReductionPercent: rawTokens === 0
+        ? 0
+        : Number((((rawTokens - outputTokens) / rawTokens) * 100).toFixed(2)),
+      evidencePreservationPassRate: evidenceCheckCount === 0
+        ? 1
+        : Number(((evidenceCheckCount - failedEvidenceCheckCount) / evidenceCheckCount).toFixed(4)),
+      falseSuccessCount: results.filter((result) => result.falseSuccess).length,
+      teeWriteFailures: results.filter((result) => result.expectedTee && !result.teeExists).length,
+      continuationPassRate: continuationCheckCount === 0
+        ? 1
+        : Number(((continuationCheckCount - failedContinuationCheckCount) / continuationCheckCount).toFixed(4)),
+      continuationCheckCount,
+      failedContinuationCheckCount,
+    },
+    results,
+  };
+}

package/lib/cli/ascx/formatter.mjs

@@ -0,0 +1,47 @@
+import {
+  calculateReductionPercent,
+  estimateOutputTokens,
+  ASCX_TOKEN_ESTIMATE_METHOD,
+} from './token-estimate.mjs';
+
+export const HIGH_RISK_REDUCTION_PERCENT = 80;
+
+export function buildAscxFooter({
+  classification,
+  commandText,
+  compactOutput,
+  exitCode,
+  filterName,
+  rawOutput,
+  rawTeePath,
+}) {
+  const rawTokens = estimateOutputTokens(rawOutput);
+  const outputTokens = estimateOutputTokens(compactOutput);
+  const reductionPercent = calculateReductionPercent(rawTokens, outputTokens);
+
+  return {
+    rawTokens,
+    outputTokens,
+    reductionPercent,
+    text: [
+      '[ascx]',
+      `command: ${commandText}`,
+      `exit: ${exitCode}`,
+      `classification: ${classification}`,
+      `filter: ${filterName}`,
+      `token_method: ${ASCX_TOKEN_ESTIMATE_METHOD}`,
+      `raw_tokens: ${rawTokens}`,
+      `output_tokens: ${outputTokens}`,
+      `reduction: ${reductionPercent}%`,
+      `raw_output: ${rawTeePath || 'none'}`,
+    ].join('\n'),
+  };
+}
+
+export function shouldWriteSafetyTee({ adapterResult, exitCode, reductionPercent }) {
+  if (exitCode !== 0) return true;
+  if (adapterResult.truncated === true) return true;
+  if (adapterResult.confident === false) return true;
+  if (adapterResult.confident !== true && reductionPercent >= HIGH_RISK_REDUCTION_PERCENT) return true;
+  return false;
+}