@ryuenn3123/agentic-senior-core 4.1.0 → 4.2.0

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-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/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,46 @@
+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 }) {
+  return exitCode !== 0
+    || adapterResult.truncated === true
+    || adapterResult.confident === false
+    || reductionPercent >= HIGH_RISK_REDUCTION_PERCENT;
+}

package/lib/cli/ascx/lexer.mjs

@@ -0,0 +1,113 @@
+const SHELL_OPERATOR_TOKENS = new Set([
+  '|',
+  '||',
+  '&',
+  '&&',
+  ';',
+  '>',
+  '>>',
+  '<',
+  '2>',
+  '2>>',
+]);
+
+function isEnvironmentAssignment(argumentValue) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.+$/u.test(argumentValue);
+}
+
+function hasCommandSubstitution(argumentValue) {
+  return argumentValue.includes('$(') || argumentValue.includes('`');
+}
+
+function hasRedirectToken(argumentValue) {
+  return /^(?:[12]?>|[12]?>>|<)/u.test(argumentValue);
+}
+
+export function parseAscxCommand(commandArguments = []) {
+  const rawArguments = commandArguments.map((argumentValue) => String(argumentValue));
+  const unsafeTokens = rawArguments.filter((argumentValue) => {
+    return SHELL_OPERATOR_TOKENS.has(argumentValue)
+      || hasCommandSubstitution(argumentValue)
+      || hasRedirectToken(argumentValue);
+  });
+  const environment = [];
+  let executableIndex = 0;
+
+  while (
+    executableIndex < rawArguments.length
+    && isEnvironmentAssignment(rawArguments[executableIndex])
+  ) {
+    environment.push(rawArguments[executableIndex]);
+    executableIndex += 1;
+  }
+
+  const executable = rawArguments[executableIndex] || '';
+  const args = executable ? rawArguments.slice(executableIndex + 1) : [];
+
+  return {
+    rawArguments,
+    commandText: rawArguments.join(' '),
+    environment,
+    executable,
+    args,
+    unsafeTokens,
+    hasShellSyntax: unsafeTokens.length > 0,
+    hasEnvironmentPrefix: environment.length > 0,
+  };
+}
+
+export function classifyAscxInvocation(parsedCommand) {
+  if (!parsedCommand.executable) {
+    return {
+      kind: 'passthrough',
+      adapterName: null,
+      reason: 'missing executable',
+    };
+  }
+
+  if (parsedCommand.hasShellSyntax) {
+    return {
+      kind: 'unsafe-for-compression',
+      adapterName: null,
+      reason: `shell syntax detected: ${parsedCommand.unsafeTokens.join(', ')}`,
+    };
+  }
+
+  if (parsedCommand.hasEnvironmentPrefix) {
+    return {
+      kind: 'passthrough',
+      adapterName: null,
+      reason: 'environment prefix detected',
+    };
+  }
+
+  if (parsedCommand.executable === 'git' && parsedCommand.args[0] === 'status') {
+    return {
+      kind: 'compressible',
+      adapterName: 'git-status',
+      reason: 'supported git status adapter',
+    };
+  }
+
+  if (parsedCommand.executable === 'git' && parsedCommand.args[0] === 'diff') {
+    return {
+      kind: 'compressible',
+      adapterName: 'git-diff',
+      reason: 'supported git diff adapter',
+    };
+  }
+
+  if (parsedCommand.executable === 'npm' && parsedCommand.args[0] === 'test') {
+    return {
+      kind: 'compressible',
+      adapterName: 'npm-test',
+      reason: 'supported npm test adapter',
+    };
+  }
+
+  return {
+    kind: 'passthrough',
+    adapterName: null,
+    reason: 'unsupported command',
+  };
+}