@hassangameryt/freeflow 0.4.0 → 0.6.0

package/router/dist/routing/parsers.js

@@ -1,521 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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;