@hassangameryt/freeflow 0.2.0 → 0.4.0

package/router/dist/routing/parsers.js

@@ -0,0 +1,521 @@
+import {
+  DEFAULT_MAX_IMPORTANT_LINES,
+  assembleImportantLines,
+  lineEntries,
+  nonEmptyLineEntries,
+  splitLines,
+} from "../evidence/evidence.js";
+const MAX_IMPORTANT_LINES = DEFAULT_MAX_IMPORTANT_LINES;
+const COMMAND_PARSERS = [
+  { name: "test-runner", parse: parseTestRunnerOutput },
+  { name: "typescript-lint", parse: parseTypeScriptOrLintOutput },
+  { name: "git-status-diffstat", parse: parseGitOutput },
+  { name: "build-toolchain", parse: parseBuildOutput },
+];
+export function parseCommandOutput(input) {
+  for (const parser of COMMAND_PARSERS) {
+    const parsed = parser.parse(input);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  return parseGenericOutput(input);
+}
+function parseTestRunnerOutput(input) {
+  const command = commandText(input.command);
+  const combined = input.combined;
+  const commandLooksLikeTest = commandLooksLikeTestRunner(command);
+  const summaryEvidence = testSummaryEvidence(combined);
+  if (!commandLooksLikeTest) {
+    return null;
+  }
+  const evidenceBlocks = [];
+  const failureBlock =
+    firstFailureBlock(input.stderr, "stderr") ??
+    firstFailureBlock(input.stdout, "stdout") ??
+    firstFailureBlock(input.combined, "combined");
+  if (failureBlock) {
+    evidenceBlocks.push(failureBlock);
+  }
+  if (summaryEvidence) {
+    evidenceBlocks.push(summaryEvidence);
+  }
+  const selected = selectEvidenceLines(evidenceBlocks, 2);
+  if (selected.importantLines.length === 0) {
+    return null;
+  }
+  const counts = testCounts(input.combined);
+  return {
+    parser: {
+      name: "test-runner",
+      confidence: 0.92,
+      fidelity: selected.fidelity,
+      compressed: selected.compressed,
+      counts,
+    },
+    summary: testSummaryText(counts, input.executionStatus, input.exitCode),
+    importantLines: selected.importantLines,
+  };
+}
+function parseTypeScriptOrLintOutput(input) {
+  const command = commandText(input.command);
+  if (!commandLooksLikeTypeScriptOrLint(command)) {
+    return null;
+  }
+  const streams = [
+    { stream: "stderr", text: input.stderr },
+    { stream: "stdout", text: input.stdout },
+    { stream: "combined", text: input.combined },
+  ];
+  for (const { stream, text } of streams) {
+    const entries = lineEntries(text);
+    const matches = diagnosticMatches(entries);
+    if (matches.length === 0) {
+      continue;
+    }
+    const references = matches.map((match) => match.reference);
+    const importantEntries = diagnosticImportantEntries(matches).slice(0, MAX_IMPORTANT_LINES);
+    const evidence = assembleImportantLines({ stream, entries: importantEntries, sourceText: text });
+    if (evidence.importantLines.length === 0) {
+      continue;
+    }
+    const counts = diagnosticCounts(references);
+    return {
+      parser: {
+        name: "typescript-lint",
+        confidence: 0.88,
+        fidelity: evidence.fidelity,
+        compressed: evidence.compressed,
+        counts,
+        references: references.slice(0, 10),
+      },
+      summary: `Detected ${counts.errors ?? 0} error(s) and ${counts.warnings ?? 0} warning(s) in TypeScript/lint diagnostics.`,
+      importantLines: evidence.importantLines,
+    };
+  }
+  return null;
+}
+function parseGitOutput(input) {
+  const command = commandText(input.command);
+  const text = input.combined;
+  const commandLooksLikeStatusOrDiffstat = /^\s*git\s+(status\b|diff\b.*--stat|show\b.*--stat|diffstat\b)/i.test(
+    command,
+  );
+  if (!commandLooksLikeStatusOrDiffstat) {
+    return null;
+  }
+  const entries = lineEntries(text).filter((entry) => isGitEvidenceLine(entry.line));
+  const selected = entries.length > 0 ? entries : nonEmptyLineEntries(text).slice(0, MAX_IMPORTANT_LINES);
+  const selectedForEvidence = selected.slice(0, MAX_IMPORTANT_LINES);
+  const evidence = assembleImportantLines({ stream: "combined", entries: selectedForEvidence, sourceText: text });
+  if (evidence.importantLines.length === 0) {
+    return null;
+  }
+  const counts = gitCounts(text);
+  return {
+    parser: {
+      name: "git-status-diffstat",
+      confidence: 0.76,
+      fidelity: evidence.fidelity,
+      compressed: evidence.compressed,
+      counts,
+    },
+    summary: "Detected git status/diffstat output.",
+    importantLines: evidence.importantLines,
+  };
+}
+function parseBuildOutput(input) {
+  const text = input.combined;
+  const command = commandText(input.command);
+  const entries = lineEntries(text);
+  const commandLooksLikeBuild = commandLooksLikeBuildTool(command);
+  if (!commandLooksLikeBuild) {
+    return null;
+  }
+  const errorPattern = commandLooksLikeBuild
+    ? /(?:\berror\b|\bfatal\b|failed to compile|build failed|module not found|cannot find module|npm ERR!)/i
+    : /(failed to compile|build failed|npm ERR!)/i;
+  const firstErrorIndex = entries.findIndex((entry) => errorPattern.test(entry.line));
+  if (firstErrorIndex === -1) {
+    return null;
+  }
+  const selected = entries.slice(firstErrorIndex, Math.min(entries.length, firstErrorIndex + MAX_IMPORTANT_LINES));
+  const evidence = assembleImportantLines({ stream: "combined", entries: selected, sourceText: text });
+  if (evidence.importantLines.length === 0) {
+    return null;
+  }
+  const counts = {
+    errors: countMatches(text, /(?:\berror\b|\bfatal\b|npm ERR!)/gi),
+    failed: countMatches(text, /\bfailed\b/gi),
+  };
+  return {
+    parser: {
+      name: "build-toolchain",
+      confidence: 0.66,
+      fidelity: evidence.fidelity,
+      compressed: evidence.compressed,
+      counts,
+    },
+    summary: "Detected build/toolchain error output.",
+    importantLines: evidence.importantLines,
+  };
+}
+function parseGenericOutput(input) {
+  const evidence = selectGenericImportantLines(input);
+  const outputLines = splitLines(input.combined).length;
+  return {
+    parser: {
+      name: "generic",
+      confidence: 0.35,
+      fidelity: evidence.fidelity,
+      compressed: evidence.compressed,
+      counts: { outputLines },
+    },
+    importantLines: evidence.importantLines,
+  };
+}
+function selectGenericImportantLines(input) {
+  if (isVerificationGoal(input.goal)) {
+    const verificationLines = verificationSummaryEvidence(input.combined);
+    if (verificationLines) {
+      return verificationLines;
+    }
+  }
+  if (input.executionStatus !== "success") {
+    const failureLines = firstFailureBlock(input.stderr, "stderr") ?? firstFailureBlock(input.combined, "combined");
+    if (failureLines) {
+      return failureLines;
+    }
+    const stderrLines = firstAndLastNonEmptyImportantLines(input.stderr, "stderr");
+    if (stderrLines) {
+      return stderrLines;
+    }
+  }
+  return firstNonEmptyImportantLine(input.combined, "combined") ?? emptyEvidence(input.combined);
+}
+function firstFailureBlock(text, stream) {
+  const entries = lineEntries(text);
+  const firstFailureIndex = entries.findIndex(
+    (entry) =>
+      /^\s*(FAIL|FAILED|FAILURES)(?:\s|$)/i.test(entry.line) ||
+      /(?:\bAssertionError\b|assertion failed|\bexpected\b|\bExpected\b|\bReceived\b|\bstack\b|\bTraceback\b|\bError:|\bfatal(?:\b|_)|\bpanic\b|\bexception\b)/i.test(
+        entry.line,
+      ),
+  );
+  if (firstFailureIndex === -1) {
+    return null;
+  }
+  const block = entries.slice(firstFailureIndex, Math.min(entries.length, firstFailureIndex + MAX_IMPORTANT_LINES));
+  return assembleImportantLines({ stream, entries: block, sourceText: text });
+}
+function testSummaryEvidence(text) {
+  const matches = lineEntries(text).filter(
+    (entry) =>
+      /\b(Test Suites?:|Tests?:|FAILURES)/i.test(entry.line) ||
+      /^\s*FAILED\s+.+\btests?\b/i.test(entry.line) ||
+      /^\s*(?:\d+\s+(?:failed|passed|skipped|deselected|xfailed|xpassed|errors?)(?:,?\s+|$))+in\s+[\d.]+s\b/i.test(
+        entry.line,
+      ) ||
+      /^\s*(?:ℹ\s*)?(?:tests?|pass|fail|cancelled|skipped|todo)\s+\d+\b/i.test(entry.line),
+  );
+  const evidence = assembleImportantLines({
+    stream: "combined",
+    entries: matches.slice(0, MAX_IMPORTANT_LINES),
+    sourceText: text,
+  });
+  return evidence.importantLines.length > 0 ? evidence : null;
+}
+function verificationSummaryEvidence(text) {
+  const matches = lineEntries(text).filter((entry) =>
+    /\b(Tests?|Test Suites?|passed|failed|total)\b/i.test(entry.line),
+  );
+  const evidence = assembleImportantLines({
+    stream: "combined",
+    entries: matches.slice(0, MAX_IMPORTANT_LINES),
+    sourceText: text,
+  });
+  return evidence.importantLines.length > 0 ? evidence : null;
+}
+function firstNonEmptyImportantLine(text, stream) {
+  const evidence = assembleImportantLines({
+    stream,
+    entries: nonEmptyLineEntries(text).slice(0, MAX_IMPORTANT_LINES),
+    sourceText: text,
+  });
+  return evidence.importantLines.length > 0 ? evidence : null;
+}
+function firstAndLastNonEmptyImportantLines(text, stream) {
+  const entries = nonEmptyLineEntries(text);
+  if (entries.length === 0) {
+    return null;
+  }
+  if (entries.length <= MAX_IMPORTANT_LINES) {
+    return firstNonEmptyImportantLine(text, stream);
+  }
+  const headCount = Math.floor(MAX_IMPORTANT_LINES / 2);
+  const tailCount = MAX_IMPORTANT_LINES - headCount;
+  const selected = [...entries.slice(0, headCount), ...entries.slice(-tailCount)];
+  const evidence = assembleImportantLines({ stream, entries: selected, sourceText: text });
+  return evidence.importantLines.length > 0 ? evidence : null;
+}
+function selectEvidenceLines(evidenceBlocks, maxImportantLines) {
+  const importantLines = [];
+  const seen = new Set();
+  let fidelity = "exact";
+  let compressed = false;
+  for (const evidence of evidenceBlocks) {
+    fidelity = fidelity === "lossy" || evidence.fidelity === "lossy" ? "lossy" : "exact";
+    compressed = compressed || evidence.compressed;
+    for (const line of evidence.importantLines) {
+      const key = `${line.stream}:${line.lines}:${line.excerpt}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      if (importantLines.length >= maxImportantLines) {
+        compressed = true;
+        continue;
+      }
+      importantLines.push(line);
+    }
+  }
+  return { importantLines, fidelity, compressed };
+}
+function emptyEvidence(sourceText) {
+  return {
+    importantLines: [],
+    fidelity: "exact",
+    compressed: false,
+    selectedLineCount: 0,
+    sourceLineCount: splitLines(sourceText).length,
+  };
+}
+function isGitEvidenceLine(line) {
+  return (
+    /\b(On branch|Your branch|Changes to be committed|Changes not staged|Untracked files|modified:|new file:|deleted:|files? changed|insertions?\(\+\)|deletions?\(-\))\b/i.test(
+      line,
+    ) ||
+    /^([ MARCUD?!]{2})\s+/.test(line) ||
+    /\|\s+\d+\s+[+\-]+/.test(line)
+  );
+}
+function gitCounts(text) {
+  const counts = {};
+  addCount(counts, "modified", countMatches(text, /modified:/gi));
+  addCount(counts, "added", countMatches(text, /new file:/gi));
+  addCount(counts, "deleted", countMatches(text, /deleted:/gi));
+  for (const entry of lineEntries(text)) {
+    const porcelain = /^([ MARCUD?!]{2})\s+/.exec(entry.line);
+    if (!porcelain) {
+      continue;
+    }
+    const status = porcelain[1] ?? "";
+    if (status.includes("M")) {
+      addCount(counts, "modified", 1);
+    }
+    if (status.includes("A") || status === "??") {
+      addCount(counts, status === "??" ? "untracked" : "added", 1);
+    }
+    if (status.includes("D")) {
+      addCount(counts, "deleted", 1);
+    }
+    if (status.includes("R")) {
+      addCount(counts, "renamed", 1);
+    }
+  }
+  const diffstat = /\b(\d+)\s+files? changed\b/i.exec(text);
+  if (diffstat?.[1]) {
+    addCount(counts, "filesChanged", Number(diffstat[1]));
+  }
+  return counts;
+}
+function addCount(counts, key, value) {
+  if (value > 0) {
+    counts[key] = (counts[key] ?? 0) + value;
+  }
+}
+function testCounts(text) {
+  const counts = {};
+  const testsLine = /Tests?:\s*(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+passed,?\s*)?(?:(\d+)\s+total)?/i.exec(text);
+  if (testsLine?.[1]) {
+    counts.testsFailed = Number(testsLine[1]);
+  }
+  if (testsLine?.[2]) {
+    counts.testsPassed = Number(testsLine[2]);
+  }
+  if (testsLine?.[3]) {
+    counts.testsTotal = Number(testsLine[3]);
+  }
+  for (const match of text.matchAll(/\b(\d+)\s+(passed|failed|skipped|deselected|xfailed|xpassed|errors?)\b/gi)) {
+    const value = Number(match[1]);
+    const kind = match[2]?.toLowerCase();
+    if (kind === "passed" && counts.testsPassed === undefined) {
+      counts.testsPassed = value;
+    }
+    if ((kind === "failed" || kind === "error" || kind === "errors") && counts.testsFailed === undefined) {
+      counts.testsFailed = value;
+    }
+    if (
+      (kind === "skipped" || kind === "deselected" || kind === "xfailed" || kind === "xpassed") &&
+      counts.testsSkipped === undefined
+    ) {
+      counts.testsSkipped = value;
+    }
+  }
+  for (const match of text.matchAll(/^\s*(?:ℹ\s*)?(tests?|pass|fail|cancelled|skipped|todo)\s+(\d+)\b/gim)) {
+    const kind = match[1]?.toLowerCase();
+    const value = Number(match[2]);
+    if (kind === "test" || kind === "tests") {
+      counts.testsTotal ??= value;
+    }
+    if (kind === "pass") {
+      counts.testsPassed ??= value;
+    }
+    if (kind === "fail") {
+      counts.testsFailed ??= value;
+    }
+    if (kind === "skipped") {
+      counts.testsSkipped ??= value;
+    }
+  }
+  const suitesLine = /Test Suites?:\s*(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+passed,?\s*)?(?:(\d+)\s+total)?/i.exec(text);
+  if (suitesLine?.[1]) {
+    counts.suitesFailed = Number(suitesLine[1]);
+  }
+  if (suitesLine?.[2]) {
+    counts.suitesPassed = Number(suitesLine[2]);
+  }
+  if (suitesLine?.[3]) {
+    counts.suitesTotal = Number(suitesLine[3]);
+  }
+  return counts;
+}
+function testSummaryText(counts, status, exitCode) {
+  const parts = [];
+  if (counts.testsFailed !== undefined) {
+    parts.push(`${counts.testsFailed} failed`);
+  }
+  if (counts.testsPassed !== undefined) {
+    parts.push(`${counts.testsPassed} passed`);
+  }
+  if (counts.testsTotal !== undefined) {
+    parts.push(`${counts.testsTotal} total`);
+  }
+  return parts.length > 0
+    ? `Test runner output parsed (${parts.join(", ")}).`
+    : `Test runner output parsed for command ${status} with exitCode=${exitCode}.`;
+}
+function diagnosticMatches(entries) {
+  const matches = [];
+  let headerEntry;
+  for (const entry of entries) {
+    const directReference = diagnosticReference(entry.line);
+    if (directReference) {
+      matches.push({ entry, reference: directReference });
+      headerEntry = undefined;
+      continue;
+    }
+    const header = /^\s*(.+\.(?:ts|tsx|js|jsx))\s*$/.exec(entry.line);
+    if (header) {
+      headerEntry = entry;
+      continue;
+    }
+    const stylish = /^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)(?:\s{2,}([@\w./-]+))?\s*$/.exec(entry.line);
+    if (stylish && headerEntry) {
+      const reference = {
+        path: headerEntry.line.trim(),
+        line: Number(stylish[1]),
+        column: Number(stylish[2]),
+        severity: stylish[3]?.toLowerCase() ?? "error",
+        message: stylish[4] ?? "",
+      };
+      if (stylish[5] !== undefined) {
+        reference.code = stylish[5];
+      }
+      matches.push({ entry, headerEntry, reference });
+    }
+  }
+  return matches;
+}
+function diagnosticImportantEntries(matches) {
+  const selected = [];
+  const seen = new Set();
+  for (const match of matches) {
+    if (match.headerEntry && !seen.has(match.headerEntry.lineNumber)) {
+      selected.push(match.headerEntry);
+      seen.add(match.headerEntry.lineNumber);
+    }
+    if (!seen.has(match.entry.lineNumber)) {
+      selected.push(match.entry);
+      seen.add(match.entry.lineNumber);
+    }
+  }
+  return selected.sort((a, b) => a.lineNumber - b.lineNumber);
+}
+function diagnosticReference(line) {
+  const tsc = /^(.*?\.(?:ts|tsx|js|jsx))\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/.exec(line);
+  if (tsc) {
+    return {
+      path: tsc[1] ?? "",
+      line: Number(tsc[2]),
+      column: Number(tsc[3]),
+      code: tsc[5] ?? "",
+      severity: tsc[4]?.toLowerCase() ?? "error",
+      message: tsc[6] ?? "",
+    };
+  }
+  const lint = /^(.*?\.(?:ts|tsx|js|jsx)):(\d+):(\d+)\s+(error|warning)\s+(.+?)(?:\s{2,}([@\w./-]+))?$/.exec(line);
+  if (lint) {
+    const reference = {
+      path: lint[1] ?? "",
+      line: Number(lint[2]),
+      column: Number(lint[3]),
+      severity: lint[4]?.toLowerCase() ?? "error",
+      message: lint[5] ?? "",
+    };
+    if (lint[6] !== undefined) {
+      reference.code = lint[6];
+    }
+    return reference;
+  }
+  return null;
+}
+function diagnosticCounts(references) {
+  return {
+    errors: references.filter((reference) => reference.severity === "error").length,
+    warnings: references.filter((reference) => reference.severity === "warning").length,
+  };
+}
+function commandLooksLikeTestRunner(command) {
+  return (
+    /^\s*(?:npm|pnpm|yarn)\s+(?:run\s+)?(?:test|tests)\b/i.test(command) ||
+    /^\s*(?:npx\s+)?(?:jest|vitest|mocha|tap|pytest)\b/i.test(command) ||
+    /(?:^|\s)cargo\s+test\b/i.test(command) ||
+    /(?:^|\s)go\s+test\b/i.test(command) ||
+    /^\s*node\s+--test\b/i.test(command)
+  );
+}
+function commandLooksLikeTypeScriptOrLint(command) {
+  return (
+    /\b(?:tsc|typecheck|eslint|biome|lint)\b/i.test(command) ||
+    /^\s*(?:npm|pnpm|yarn)\s+(?:run\s+)?(?:build|typecheck|lint)\b/i.test(command)
+  );
+}
+function commandLooksLikeBuildTool(command) {
+  return (
+    /^\s*(?:npm|pnpm|yarn)\s+(?:run\s+)?(?:build|install|ci)\b/i.test(command) ||
+    /^\s*(?:npx\s+)?(?:webpack|rollup|vite|esbuild|babel)\b/i.test(command) ||
+    /^\s*(?:build|compile)\b/i.test(command) ||
+    /(?:^|\s)cargo\s+build\b/i.test(command) ||
+    /(?:^|\s)go\s+build\b/i.test(command)
+  );
+}
+function isVerificationGoal(goal) {
+  return Boolean(goal && /\b(verify|verification|test|tests|check|ci)\b/i.test(goal));
+}
+function countMatches(text, pattern) {
+  return Array.from(text.matchAll(pattern)).length;
+}
+function commandText(command) {
+  return typeof command === "string" ? command : command.join(" ");
+}

package/router/dist/routing/run-filters.d.ts

@@ -0,0 +1,60 @@
+import { type BoundedEvidence } from "../evidence/evidence.js";
+import type { ImportantLine, RunOutputFilterMetadata } from "../config/types.js";
+export type { RunOutputFilterMetadata } from "../config/types.js";
+export declare const RUN_FILTER_STREAMS: readonly ["stdout", "stderr", "combined"];
+export type RunFilterStream = (typeof RUN_FILTER_STREAMS)[number];
+export interface RunOutputFiltersInput {
+  stream?: RunFilterStream;
+  include?: string | readonly string[];
+  exclude?: string | readonly string[];
+  flags?: string;
+  head?: number;
+  tail?: number;
+  maxLines?: number;
+  maxBytes?: number;
+}
+export interface NormalizedRunOutputFilters {
+  stream?: RunFilterStream;
+  include: string[];
+  exclude: string[];
+  flags: string;
+  head?: number;
+  tail?: number;
+  maxLines?: number;
+  maxBytes?: number;
+}
+export interface RunOutputFilterResult {
+  stream: RunFilterStream;
+  evidence: BoundedEvidence;
+  metadata: RunOutputFilterMetadata;
+  description: string;
+}
+export type RunOutputFilterValidationResult =
+  | {
+      ok: true;
+      filters?: NormalizedRunOutputFilters;
+    }
+  | {
+      ok: false;
+      message: string;
+      path: string;
+    };
+export declare function normalizeRunOutputFilters(input: unknown): RunOutputFilterValidationResult;
+export declare function hasRunOutputFilters(
+  filters: NormalizedRunOutputFilters | undefined,
+): filters is NormalizedRunOutputFilters;
+export declare function applyRunOutputFilters(options: {
+  filters: NormalizedRunOutputFilters;
+  defaultStream: RunFilterStream;
+  stdout: string;
+  stderr: string;
+  combined: string;
+  fallbackImportantLines?: readonly ImportantLine[];
+  preserveFallbackFailureEvidence?: boolean;
+  caps?: {
+    maxLines?: number;
+    maxExcerptBytes?: number;
+    maxLineBytes?: number;
+  };
+}): RunOutputFilterResult;
+export declare function describeRunOutputFilters(metadata: RunOutputFilterMetadata): string;