@jmoyers/harness 0.1.10 → 0.1.20

package/src/diff/git-parse.ts

@@ -0,0 +1,472 @@
+import { computeDiffFileId, computeDiffHunkId, serializeHunkLinesForHash } from './hash.ts';
+import {
+  inferLanguageFromPath,
+  isGeneratedPath,
+  normalizeDiffPath,
+  resolveFileChangeType,
+} from './normalize.ts';
+import type { DiffBudgetTracker } from './budget.ts';
+import type {
+  DiffCoverageReason,
+  DiffFile,
+  DiffHunk,
+  DiffLine,
+  DiffTotals,
+  FileChangeType,
+} from './types.ts';
+
+interface MutableHunk {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  header: string;
+  lines: DiffLine[];
+  addCount: number;
+  delCount: number;
+  oldCursor: number;
+  newCursor: number;
+}
+
+interface MutableFile {
+  changeTypeHint: FileChangeType | null;
+  oldPath: string | null;
+  newPath: string | null;
+  isBinary: boolean;
+  isGenerated: boolean;
+  isTooLarge: boolean;
+  hunks: MutableHunk[];
+}
+
+function parseHunkHeader(line: string): {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  header: string;
+} | null {
+  const matched = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/u.exec(line);
+  if (matched === null) {
+    return null;
+  }
+  const oldStart = Number.parseInt(matched[1]!, 10);
+  const oldCount = Number.parseInt(matched[2] ?? '1', 10);
+  const newStart = Number.parseInt(matched[3]!, 10);
+  const newCount = Number.parseInt(matched[4] ?? '1', 10);
+  const suffix = matched[5] ?? '';
+  return {
+    oldStart,
+    oldCount,
+    newStart,
+    newCount,
+    header: `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@${suffix}`,
+  };
+}
+
+function parseTokenList(raw: string): readonly string[] {
+  const tokens: string[] = [];
+  let index = 0;
+  while (index < raw.length) {
+    while (index < raw.length && raw[index] === ' ') {
+      index += 1;
+    }
+    if (index >= raw.length) {
+      break;
+    }
+    if (raw[index] === '"') {
+      index += 1;
+      let token = '';
+      while (index < raw.length) {
+        const char = raw[index]!;
+        if (char === '\\') {
+          const next = raw[index + 1] ?? '';
+          if (next.length > 0) {
+            token += next;
+            index += 2;
+            continue;
+          }
+        }
+        if (char === '"') {
+          index += 1;
+          break;
+        }
+        token += char;
+        index += 1;
+      }
+      tokens.push(token);
+      continue;
+    }
+    let token = '';
+    while (index < raw.length && raw[index] !== ' ') {
+      token += raw[index]!;
+      index += 1;
+    }
+    tokens.push(token);
+  }
+  return tokens;
+}
+
+function stripGitPrefix(value: string, prefix: 'a/' | 'b/'): string {
+  if (value.startsWith(prefix)) {
+    return value.slice(prefix.length);
+  }
+  return value;
+}
+
+function parseDiffGitPaths(
+  line: string,
+): { oldPath: string | null; newPath: string | null } | null {
+  const prefix = 'diff --git ';
+  if (!line.startsWith(prefix)) {
+    return null;
+  }
+  const tokens = parseTokenList(line.slice(prefix.length));
+  if (tokens.length < 2) {
+    return null;
+  }
+  const oldToken = tokens[0]!;
+  const newToken = tokens[1]!;
+  return {
+    oldPath: normalizeDiffPath(stripGitPrefix(oldToken, 'a/')),
+    newPath: normalizeDiffPath(stripGitPrefix(newToken, 'b/')),
+  };
+}
+
+function parsePatchPathLine(line: string, marker: '--- ' | '+++ '): string | null | undefined {
+  if (!line.startsWith(marker)) {
+    return undefined;
+  }
+  const raw = line.slice(marker.length).split('\t')[0] ?? '';
+  if (raw === '/dev/null') {
+    return null;
+  }
+  if (raw.startsWith('a/')) {
+    return raw.slice(2);
+  }
+  if (raw.startsWith('b/')) {
+    return raw.slice(2);
+  }
+  return raw;
+}
+
+interface GitDiffPatchParserOptions {
+  readonly includeGenerated: boolean;
+  readonly includeBinary: boolean;
+  readonly budget: DiffBudgetTracker;
+  readonly onFile?: (file: DiffFile) => void;
+  readonly onHunk?: (fileId: string, hunk: DiffHunk) => void;
+}
+
+interface GitDiffPatchParserResult {
+  readonly files: readonly DiffFile[];
+  readonly totals: DiffTotals;
+  readonly warnings: readonly string[];
+  readonly skippedFiles: number;
+  readonly truncatedFiles: number;
+  readonly limitReason: DiffCoverageReason;
+}
+
+export class GitDiffPatchParser {
+  private currentFile: MutableFile | null = null;
+  private currentHunk: MutableHunk | null = null;
+  private readonly files: DiffFile[] = [];
+  private readonly warnings: string[] = [];
+  private skippedFiles = 0;
+  private truncatedFiles = 0;
+  private halted = false;
+
+  constructor(private readonly options: GitDiffPatchParserOptions) {}
+
+  pushLine(line: string): boolean {
+    if (this.halted) {
+      return false;
+    }
+    const runtimeCheck = this.options.budget.checkRuntime();
+    if (!runtimeCheck.allowed) {
+      this.halted = true;
+      this.markTruncatedCurrentFile();
+      return false;
+    }
+
+    const parsedPaths = parseDiffGitPaths(line);
+    if (parsedPaths !== null) {
+      this.finalizeCurrentFile();
+      const generated = isGeneratedPath(parsedPaths.newPath ?? parsedPaths.oldPath);
+      this.currentFile = {
+        changeTypeHint: null,
+        oldPath: parsedPaths.oldPath,
+        newPath: parsedPaths.newPath,
+        isBinary: false,
+        isGenerated: generated,
+        isTooLarge: false,
+        hunks: [],
+      };
+      this.currentHunk = null;
+      if (generated && !this.options.includeGenerated) {
+        this.skippedFiles += 1;
+      } else {
+        const tookFile = this.options.budget.takeFile();
+        if (!tookFile.allowed) {
+          this.markTruncatedCurrentFile();
+          this.halted = true;
+          return false;
+        }
+      }
+      return true;
+    }
+
+    if (this.currentFile === null) {
+      return true;
+    }
+    if (this.shouldSkipCurrentFile()) {
+      return true;
+    }
+
+    const oldPathPatch = parsePatchPathLine(line, '--- ');
+    if (oldPathPatch !== undefined) {
+      this.currentFile.oldPath = normalizeDiffPath(oldPathPatch);
+      return true;
+    }
+    const newPathPatch = parsePatchPathLine(line, '+++ ');
+    if (newPathPatch !== undefined) {
+      this.currentFile.newPath = normalizeDiffPath(newPathPatch);
+      return true;
+    }
+
+    if (line.startsWith('new file mode ')) {
+      this.currentFile.changeTypeHint = 'added';
+      return true;
+    }
+    if (line.startsWith('deleted file mode ')) {
+      this.currentFile.changeTypeHint = 'deleted';
+      return true;
+    }
+    if (line.startsWith('rename from ')) {
+      this.currentFile.changeTypeHint = 'renamed';
+      this.currentFile.oldPath = normalizeDiffPath(line.slice('rename from '.length));
+      return true;
+    }
+    if (line.startsWith('rename to ')) {
+      this.currentFile.changeTypeHint = 'renamed';
+      this.currentFile.newPath = normalizeDiffPath(line.slice('rename to '.length));
+      return true;
+    }
+    if (line.startsWith('copy from ')) {
+      this.currentFile.changeTypeHint = 'copied';
+      this.currentFile.oldPath = normalizeDiffPath(line.slice('copy from '.length));
+      return true;
+    }
+    if (line.startsWith('copy to ')) {
+      this.currentFile.changeTypeHint = 'copied';
+      this.currentFile.newPath = normalizeDiffPath(line.slice('copy to '.length));
+      return true;
+    }
+    if (line.startsWith('similarity index ')) {
+      return true;
+    }
+    if (line.startsWith('dissimilarity index ')) {
+      return true;
+    }
+    if (line.startsWith('Binary files ') || line === 'GIT binary patch') {
+      this.currentFile.isBinary = true;
+      this.currentFile.changeTypeHint = 'binary';
+      if (!this.options.includeBinary) {
+        this.skippedFiles += 1;
+      }
+      return true;
+    }
+    if (line.startsWith('old mode ') || line.startsWith('new mode ')) {
+      if (
+        this.currentFile.changeTypeHint === null ||
+        this.currentFile.changeTypeHint === 'unknown' ||
+        this.currentFile.changeTypeHint === 'modified'
+      ) {
+        this.currentFile.changeTypeHint = 'type-change';
+      }
+      return true;
+    }
+
+    const parsedHunk = parseHunkHeader(line);
+    if (parsedHunk !== null) {
+      const tookHunk = this.options.budget.takeHunk();
+      if (!tookHunk.allowed) {
+        this.markTruncatedCurrentFile();
+        this.halted = true;
+        return false;
+      }
+      this.finalizeCurrentHunk();
+      this.currentHunk = {
+        oldStart: parsedHunk.oldStart,
+        oldCount: parsedHunk.oldCount,
+        newStart: parsedHunk.newStart,
+        newCount: parsedHunk.newCount,
+        header: parsedHunk.header,
+        lines: [],
+        addCount: 0,
+        delCount: 0,
+        oldCursor: parsedHunk.oldStart,
+        newCursor: parsedHunk.newStart,
+      };
+      return true;
+    }
+
+    if (this.currentHunk !== null) {
+      if (line.startsWith('\')) {
+        return true;
+      }
+      const first = line[0] ?? '';
+      if (first !== ' ' && first !== '+' && first !== '-') {
+        return true;
+      }
+      const tookLine = this.options.budget.takeLine();
+      if (!tookLine.allowed) {
+        this.markTruncatedCurrentFile();
+        this.halted = true;
+        return false;
+      }
+      const normalizedText = line.slice(1);
+      let normalizedLine: DiffLine;
+      if (first === '+') {
+        normalizedLine = {
+          kind: 'add',
+          oldLine: null,
+          newLine: this.currentHunk.newCursor,
+          text: normalizedText,
+        };
+        this.currentHunk.addCount += 1;
+        this.currentHunk.newCursor += 1;
+      } else if (first === '-') {
+        normalizedLine = {
+          kind: 'del',
+          oldLine: this.currentHunk.oldCursor,
+          newLine: null,
+          text: normalizedText,
+        };
+        this.currentHunk.delCount += 1;
+        this.currentHunk.oldCursor += 1;
+      } else {
+        normalizedLine = {
+          kind: 'context',
+          oldLine: this.currentHunk.oldCursor,
+          newLine: this.currentHunk.newCursor,
+          text: normalizedText,
+        };
+        this.currentHunk.oldCursor += 1;
+        this.currentHunk.newCursor += 1;
+      }
+      this.currentHunk.lines.push(normalizedLine);
+    }
+    return true;
+  }
+
+  finish(): GitDiffPatchParserResult {
+    this.finalizeCurrentFile();
+    const totals: DiffTotals = {
+      filesChanged: this.files.length,
+      additions: this.files.reduce((sum, file) => sum + file.additions, 0),
+      deletions: this.files.reduce((sum, file) => sum + file.deletions, 0),
+      binaryFiles: this.files.reduce((sum, file) => sum + (file.isBinary ? 1 : 0), 0),
+      generatedFiles: this.files.reduce((sum, file) => sum + (file.isGenerated ? 1 : 0), 0),
+      hunks: this.files.reduce((sum, file) => sum + file.hunks.length, 0),
+      lines: this.files.reduce(
+        (sum, file) => sum + file.hunks.reduce((hunkSum, hunk) => hunkSum + hunk.lineCount, 0),
+        0,
+      ),
+    };
+    return {
+      files: this.files,
+      totals,
+      warnings: this.warnings,
+      skippedFiles: this.skippedFiles,
+      truncatedFiles: this.truncatedFiles,
+      limitReason: this.options.budget.limitReason(),
+    };
+  }
+
+  private shouldSkipCurrentFile(): boolean {
+    if (this.currentFile === null) {
+      return false;
+    }
+    if (this.currentFile.isGenerated && !this.options.includeGenerated) {
+      return true;
+    }
+    if (this.currentFile.isBinary && !this.options.includeBinary) {
+      return true;
+    }
+    return false;
+  }
+
+  private markTruncatedCurrentFile(): void {
+    if (this.currentFile === null) {
+      return;
+    }
+    this.currentFile.isTooLarge = true;
+    this.truncatedFiles += 1;
+  }
+
+  private finalizeCurrentHunk(): void {
+    if (this.currentFile === null || this.currentHunk === null) {
+      return;
+    }
+    this.currentFile.hunks.push(this.currentHunk);
+    this.currentHunk = null;
+  }
+
+  private finalizeCurrentFile(): void {
+    if (this.currentFile === null) {
+      return;
+    }
+    this.finalizeCurrentHunk();
+    if (this.shouldSkipCurrentFile()) {
+      this.currentFile = null;
+      return;
+    }
+    const resolvedOldPath = normalizeDiffPath(this.currentFile.oldPath);
+    const resolvedNewPath = normalizeDiffPath(this.currentFile.newPath);
+    const changeType = resolveFileChangeType({
+      fromHeader: this.currentFile.changeTypeHint,
+      oldPath: resolvedOldPath,
+      newPath: resolvedNewPath,
+      isBinary: this.currentFile.isBinary,
+    });
+    const fileId = computeDiffFileId(changeType, resolvedOldPath, resolvedNewPath);
+    const finalHunks: DiffHunk[] = [];
+    for (const hunk of this.currentFile.hunks) {
+      const diffHunk: DiffHunk = {
+        hunkId: computeDiffHunkId(fileId, hunk.header, serializeHunkLinesForHash(hunk.lines)),
+        oldStart: hunk.oldStart,
+        oldCount: hunk.oldCount,
+        newStart: hunk.newStart,
+        newCount: hunk.newCount,
+        header: hunk.header,
+        lines: hunk.lines,
+        lineCount: hunk.lines.length,
+        addCount: hunk.addCount,
+        delCount: hunk.delCount,
+      };
+      finalHunks.push(diffHunk);
+      this.options.onHunk?.(fileId, diffHunk);
+    }
+    if (resolvedOldPath === null && resolvedNewPath === null) {
+      this.warnings.push('skipped file record with null oldPath/newPath');
+      this.currentFile = null;
+      return;
+    }
+    const diffFile: DiffFile = {
+      fileId,
+      changeType,
+      oldPath: resolvedOldPath,
+      newPath: resolvedNewPath,
+      language: inferLanguageFromPath(resolvedNewPath ?? resolvedOldPath),
+      isBinary: this.currentFile.isBinary,
+      isGenerated: this.currentFile.isGenerated,
+      isTooLarge: this.currentFile.isTooLarge,
+      additions: finalHunks.reduce((sum, hunk) => sum + hunk.addCount, 0),
+      deletions: finalHunks.reduce((sum, hunk) => sum + hunk.delCount, 0),
+      hunks: finalHunks,
+    };
+    this.files.push(diffFile);
+    this.options.onFile?.(diffFile);
+    this.currentFile = null;
+  }
+}

package/src/diff/hash.ts

@@ -0,0 +1,70 @@
+import { createHash } from 'node:crypto';
+import type { DiffFile, DiffHunk, DiffMode } from './types.ts';
+
+function hashStrings(prefix: string, parts: readonly string[]): string {
+  const hash = createHash('sha256');
+  hash.update(prefix);
+  hash.update('\n');
+  for (const part of parts) {
+    hash.update(part);
+    hash.update('\n');
+  }
+  return hash.digest('hex');
+}
+
+function normalized(value: string | null): string {
+  return value ?? '';
+}
+
+export function computeDiffFileId(
+  changeType: string,
+  oldPath: string | null,
+  newPath: string | null,
+): string {
+  return hashStrings('diff-file', [changeType, normalized(oldPath), normalized(newPath)]);
+}
+
+export function computeDiffHunkId(
+  fileId: string,
+  header: string,
+  serializedLines: readonly string[],
+): string {
+  return hashStrings('diff-hunk', [fileId, header, ...serializedLines]);
+}
+
+export function serializeHunkLinesForHash(lines: DiffHunk['lines']): readonly string[] {
+  const serialized: string[] = [];
+  for (const line of lines) {
+    serialized.push(
+      `${line.kind}:${String(line.oldLine ?? '')}:${String(line.newLine ?? '')}:${line.text}`,
+    );
+  }
+  return serialized;
+}
+
+export function computeDiffId(
+  mode: DiffMode,
+  baseRef: string | null,
+  headRef: string | null,
+  files: readonly DiffFile[],
+): string {
+  const parts: string[] = [mode, normalized(baseRef), normalized(headRef)];
+  for (const file of files) {
+    parts.push(
+      `${file.fileId}:${file.changeType}:${normalized(file.oldPath)}:${normalized(file.newPath)}`,
+    );
+    for (const hunk of file.hunks) {
+      parts.push(hunk.hunkId);
+    }
+  }
+  return hashStrings('diff', parts);
+}
+
+export function computeDiffChunkId(
+  fileId: string,
+  sequence: number,
+  hunkIds: readonly string[],
+  policySignature: string,
+): string {
+  return hashStrings('diff-chunk', [fileId, String(sequence), policySignature, ...hunkIds]);
+}

package/src/diff/index.ts

@@ -0,0 +1,24 @@
+export { createDiffBuilder } from './build.ts';
+export { createDiffChunker } from './chunker.ts';
+export { DEFAULT_CHUNK_POLICY, DEFAULT_DIFF_BUDGET } from './types.ts';
+export type {
+  ChunkPolicy,
+  DiffBudget,
+  DiffBuildDiagnostics,
+  DiffBuildOptions,
+  DiffBuildResult,
+  DiffBuilder,
+  DiffChunk,
+  DiffChunker,
+  DiffCoverage,
+  DiffCoverageReason,
+  DiffFile,
+  DiffHunk,
+  DiffLine,
+  DiffMode,
+  DiffSpec,
+  DiffStreamEvent,
+  DiffTotals,
+  FileChangeType,
+  NormalizedDiff,
+} from './types.ts';

package/src/diff/normalize.ts

@@ -0,0 +1,134 @@
+import type { FileChangeType } from './types.ts';
+
+function trimToNull(value: string | null): string | null {
+  if (value === null) {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+
+export function normalizeDiffPath(value: string | null): string | null {
+  const trimmed = trimToNull(value);
+  if (trimmed === null || trimmed === '/dev/null') {
+    return null;
+  }
+  return trimmed;
+}
+
+export function inferLanguageFromPath(path: string | null): string | null {
+  if (path === null) {
+    return null;
+  }
+  const lower = path.toLowerCase();
+  if (lower.endsWith('.ts') || lower.endsWith('.tsx')) {
+    return 'typescript';
+  }
+  if (lower.endsWith('.js') || lower.endsWith('.jsx') || lower.endsWith('.mjs')) {
+    return 'javascript';
+  }
+  if (lower.endsWith('.rs')) {
+    return 'rust';
+  }
+  if (lower.endsWith('.go')) {
+    return 'go';
+  }
+  if (lower.endsWith('.py')) {
+    return 'python';
+  }
+  if (lower.endsWith('.java')) {
+    return 'java';
+  }
+  if (lower.endsWith('.kt')) {
+    return 'kotlin';
+  }
+  if (lower.endsWith('.rb')) {
+    return 'ruby';
+  }
+  if (lower.endsWith('.c') || lower.endsWith('.h')) {
+    return 'c';
+  }
+  if (lower.endsWith('.cc') || lower.endsWith('.cpp') || lower.endsWith('.hpp')) {
+    return 'cpp';
+  }
+  if (lower.endsWith('.json')) {
+    return 'json';
+  }
+  if (lower.endsWith('.jsonc')) {
+    return 'jsonc';
+  }
+  if (lower.endsWith('.md')) {
+    return 'markdown';
+  }
+  if (lower.endsWith('.yaml') || lower.endsWith('.yml')) {
+    return 'yaml';
+  }
+  if (lower.endsWith('.toml')) {
+    return 'toml';
+  }
+  if (lower.endsWith('.sh') || lower.endsWith('.bash') || lower.endsWith('.zsh')) {
+    return 'shell';
+  }
+  if (lower.endsWith('.sql')) {
+    return 'sql';
+  }
+  return null;
+}
+
+function hasGeneratedSegment(path: string): boolean {
+  const lower = path.toLowerCase();
+  return (
+    lower.startsWith('dist/') ||
+    lower.startsWith('build/') ||
+    lower.startsWith('coverage/') ||
+    lower.startsWith('.next/') ||
+    lower.startsWith('out/') ||
+    lower.startsWith('vendor/') ||
+    lower.startsWith('node_modules/') ||
+    lower.includes('/dist/') ||
+    lower.includes('/build/') ||
+    lower.includes('/coverage/') ||
+    lower.includes('/.next/') ||
+    lower.includes('/out/') ||
+    lower.includes('/vendor/') ||
+    lower.includes('/node_modules/')
+  );
+}
+
+export function isGeneratedPath(path: string | null): boolean {
+  if (path === null) {
+    return false;
+  }
+  const lower = path.toLowerCase();
+  return (
+    hasGeneratedSegment(path) ||
+    lower.endsWith('.min.js') ||
+    lower.endsWith('.min.css') ||
+    lower.endsWith('.lock') ||
+    lower === 'package-lock.json' ||
+    lower === 'bun.lock' ||
+    lower.endsWith('.generated.ts') ||
+    lower.endsWith('.gen.ts')
+  );
+}
+
+export function resolveFileChangeType(input: {
+  fromHeader: FileChangeType | null;
+  oldPath: string | null;
+  newPath: string | null;
+  isBinary: boolean;
+}): FileChangeType {
+  if (input.isBinary) {
+    return 'binary';
+  }
+  if (input.fromHeader !== null && input.fromHeader !== 'unknown') {
+    return input.fromHeader;
+  }
+  if (input.oldPath === null && input.newPath !== null) {
+    return 'added';
+  }
+  if (input.oldPath !== null && input.newPath === null) {
+    return 'deleted';
+  }
+  return 'modified';
+}