@jmoyers/harness 0.1.10 → 0.1.20

package/src/diff-ui/finder.ts

@@ -0,0 +1,94 @@
+import type { DiffUiFinderResult, DiffUiModel } from './types.ts';
+
+function filePathFromModel(model: DiffUiModel, fileIndex: number): string {
+  const file = model.diff.files[fileIndex]!;
+  return file.newPath ?? file.oldPath ?? file.fileId;
+}
+
+export function scoreFinderPath(query: string, path: string): number {
+  const trimmedQuery = query.trim().toLowerCase();
+  if (trimmedQuery.length === 0) {
+    return 0;
+  }
+
+  const candidate = path.toLowerCase();
+  let queryIndex = 0;
+  let score = 0;
+  let streak = 0;
+  let firstMatchIndex = -1;
+
+  for (let candidateIndex = 0; candidateIndex < candidate.length; candidateIndex += 1) {
+    if (queryIndex >= trimmedQuery.length) {
+      break;
+    }
+
+    const current = candidate[candidateIndex]!;
+    if (current !== trimmedQuery[queryIndex]) {
+      streak = 0;
+      continue;
+    }
+
+    if (firstMatchIndex < 0) {
+      firstMatchIndex = candidateIndex;
+    }
+    streak += 1;
+    score += 10 + streak * 4;
+
+    const prev = candidateIndex > 0 ? candidate[candidateIndex - 1] : '/';
+    if (prev === '/' || prev === '-' || prev === '_' || prev === '.') {
+      score += 6;
+    }
+
+    queryIndex += 1;
+  }
+
+  if (queryIndex !== trimmedQuery.length) {
+    return Number.NEGATIVE_INFINITY;
+  }
+
+  if (firstMatchIndex === 0) {
+    score += 12;
+  } else if (firstMatchIndex > 0) {
+    score += Math.max(0, 8 - firstMatchIndex);
+  }
+
+  score -= Math.floor(candidate.length / 8);
+  return score;
+}
+
+export function buildFinderResults(
+  model: DiffUiModel,
+  query: string,
+  maxResults = 200,
+): readonly DiffUiFinderResult[] {
+  const trimmedQuery = query.trim();
+  const results: DiffUiFinderResult[] = [];
+
+  for (let fileIndex = 0; fileIndex < model.diff.files.length; fileIndex += 1) {
+    const file = model.diff.files[fileIndex]!;
+    const path = filePathFromModel(model, fileIndex);
+    const score = trimmedQuery.length === 0 ? 0 : scoreFinderPath(trimmedQuery, path);
+    if (score === Number.NEGATIVE_INFINITY) {
+      continue;
+    }
+    results.push({
+      fileIndex,
+      fileId: file.fileId,
+      path,
+      score,
+    });
+  }
+
+  results.sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    const pathCompare = left.path.localeCompare(right.path);
+    if (pathCompare !== 0) {
+      return pathCompare;
+    }
+    return left.fileIndex - right.fileIndex;
+  });
+
+  return results.slice(0, Math.max(1, Math.floor(maxResults)));
+}

package/src/diff-ui/highlight.ts

@@ -0,0 +1,127 @@
+import type { DiffUiRenderTheme } from './types.ts';
+
+type DiffUiSyntaxTokenRole = 'keyword' | 'string' | 'comment' | 'number';
+
+interface DiffUiSyntaxToken {
+  readonly start: number;
+  readonly end: number;
+  readonly role: DiffUiSyntaxTokenRole;
+}
+
+const JAVASCRIPT_LIKE_LANGUAGES = new Set(['javascript', 'typescript', 'tsx', 'jsx', 'mjs', 'cjs']);
+
+const KEYWORD_PATTERN =
+  /\b(async|await|break|case|catch|class|const|continue|default|else|export|extends|finally|for|function|if|import|interface|let|new|return|switch|throw|try|type|var|while)\b/gu;
+const NUMBER_PATTERN = /\b\d+(?:\.\d+)?\b/gu;
+const STRING_PATTERN = /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`/gu;
+const COMMENT_PATTERN = /\/\/.*$/u;
+
+function hasOverlap(tokens: readonly DiffUiSyntaxToken[], start: number, end: number): boolean {
+  for (const token of tokens) {
+    if (start < token.end && end > token.start) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function collectRegexMatches(
+  line: string,
+  regex: RegExp,
+  role: DiffUiSyntaxTokenRole,
+  tokens: DiffUiSyntaxToken[],
+): void {
+  const cloned = new RegExp(regex.source, regex.flags);
+  let match = cloned.exec(line);
+  while (match !== null) {
+    const matched = match[0] ?? '';
+    const start = match.index;
+    const end = start + matched.length;
+    if (matched.length > 0 && !hasOverlap(tokens, start, end)) {
+      tokens.push({
+        start,
+        end,
+        role,
+      });
+    }
+    match = cloned.exec(line);
+  }
+}
+
+function isSyntaxLanguage(language: string | null): boolean {
+  if (language === null) {
+    return false;
+  }
+  return JAVASCRIPT_LIKE_LANGUAGES.has(language.toLowerCase());
+}
+
+function tokenizeDiffUiSyntaxLine(
+  line: string,
+  language: string | null,
+): readonly DiffUiSyntaxToken[] {
+  if (!isSyntaxLanguage(language)) {
+    return [];
+  }
+
+  const tokens: DiffUiSyntaxToken[] = [];
+
+  const commentMatch = line.match(COMMENT_PATTERN);
+  if (commentMatch !== null && commentMatch.index !== undefined) {
+    tokens.push({
+      start: commentMatch.index,
+      end: line.length,
+      role: 'comment',
+    });
+  }
+
+  collectRegexMatches(line, STRING_PATTERN, 'string', tokens);
+  collectRegexMatches(line, KEYWORD_PATTERN, 'keyword', tokens);
+  collectRegexMatches(line, NUMBER_PATTERN, 'number', tokens);
+
+  tokens.sort((left, right) => left.start - right.start || left.end - right.end);
+  return tokens;
+}
+
+function ansiForRole(role: DiffUiSyntaxTokenRole, theme: DiffUiRenderTheme): string {
+  if (role === 'keyword') {
+    return theme.syntaxKeywordAnsi;
+  }
+  if (role === 'string') {
+    return theme.syntaxStringAnsi;
+  }
+  if (role === 'comment') {
+    return theme.syntaxCommentAnsi;
+  }
+  return theme.syntaxNumberAnsi;
+}
+
+export function renderSyntaxAnsiLine(input: {
+  readonly line: string;
+  readonly language: string | null;
+  readonly theme: DiffUiRenderTheme;
+  readonly colorEnabled: boolean;
+  readonly baseAnsi: string;
+}): string {
+  if (!input.colorEnabled) {
+    return input.line;
+  }
+
+  const tokens = tokenizeDiffUiSyntaxLine(input.line, input.language);
+  if (tokens.length === 0) {
+    return input.line;
+  }
+
+  let output = '';
+  let cursor = 0;
+  for (const token of tokens) {
+    if (token.start > cursor) {
+      output += input.line.slice(cursor, token.start);
+    }
+    output += `${ansiForRole(token.role, input.theme)}${input.line.slice(token.start, token.end)}${input.baseAnsi}`;
+    cursor = token.end;
+  }
+  if (cursor < input.line.length) {
+    output += input.line.slice(cursor);
+  }
+  return output;
+}

package/src/diff-ui/index.ts

@@ -0,0 +1,2 @@
+export { diffUiUsage } from './args.ts';
+export { runDiffUiCli } from './runtime.ts';

package/src/diff-ui/model.ts

@@ -0,0 +1,141 @@
+import type { DiffFile, DiffHunk, DiffLine, NormalizedDiff } from '../diff/types.ts';
+import type { DiffUiModel, DiffUiRowKind, DiffUiVirtualRow } from './types.ts';
+
+function filePath(file: DiffFile): string {
+  return file.newPath ?? file.oldPath ?? file.fileId;
+}
+
+function lineKindToRowKind(line: DiffLine): DiffUiRowKind {
+  if (line.kind === 'add') {
+    return 'code-add';
+  }
+  if (line.kind === 'del') {
+    return 'code-del';
+  }
+  return 'code-context';
+}
+
+function unifiedPrefix(kind: DiffLine['kind']): string {
+  if (kind === 'add') {
+    return '+';
+  }
+  if (kind === 'del') {
+    return '-';
+  }
+  return ' ';
+}
+
+function buildCodeRow(input: {
+  readonly file: DiffFile;
+  readonly fileIndex: number;
+  readonly hunk: DiffHunk;
+  readonly hunkIndex: number;
+  readonly line: DiffLine;
+}): DiffUiVirtualRow {
+  const rowKind = lineKindToRowKind(input.line);
+  const prefix = unifiedPrefix(input.line.kind);
+  const unified = `${prefix} ${input.line.text}`;
+  const left = input.line.kind === 'add' ? '' : input.line.text;
+  const right = input.line.kind === 'del' ? '' : input.line.text;
+
+  return {
+    kind: rowKind,
+    unified,
+    left,
+    right,
+    fileId: input.file.fileId,
+    hunkId: input.hunk.hunkId,
+    fileIndex: input.fileIndex,
+    hunkIndex: input.hunkIndex,
+    language: input.file.language,
+    oldLine: input.line.oldLine,
+    newLine: input.line.newLine,
+  };
+}
+
+export function buildDiffUiModel(diff: NormalizedDiff): DiffUiModel {
+  const rows: DiffUiVirtualRow[] = [];
+  const fileStartRows: number[] = [];
+  const hunkStartRows: number[] = [];
+
+  let globalHunkIndex = 0;
+
+  for (let fileIndex = 0; fileIndex < diff.files.length; fileIndex += 1) {
+    const file = diff.files[fileIndex]!;
+    fileStartRows.push(rows.length);
+
+    const path = filePath(file);
+    rows.push({
+      kind: 'file-header',
+      unified: `File ${fileIndex + 1}/${diff.files.length}: ${path} (+${file.additions} -${file.deletions})`,
+      left: path,
+      right: `+${file.additions} -${file.deletions}`,
+      fileId: file.fileId,
+      hunkId: null,
+      fileIndex,
+      hunkIndex: null,
+      language: file.language,
+      oldLine: null,
+      newLine: null,
+    });
+
+    for (const hunk of file.hunks) {
+      hunkStartRows.push(rows.length);
+      const hunkIndex = globalHunkIndex;
+      globalHunkIndex += 1;
+      rows.push({
+        kind: 'hunk-header',
+        unified: hunk.header,
+        left: hunk.header,
+        right: hunk.header,
+        fileId: file.fileId,
+        hunkId: hunk.hunkId,
+        fileIndex,
+        hunkIndex,
+        language: file.language,
+        oldLine: hunk.oldStart,
+        newLine: hunk.newStart,
+      });
+
+      for (const line of hunk.lines) {
+        rows.push(
+          buildCodeRow({
+            file,
+            fileIndex,
+            hunk,
+            hunkIndex,
+            line,
+          }),
+        );
+      }
+    }
+  }
+
+  if (diff.coverage.truncated) {
+    rows.push({
+      kind: 'notice',
+      unified: `coverage truncated: reason=${diff.coverage.reason} skipped=${diff.coverage.skippedFiles} truncated=${diff.coverage.truncatedFiles}`,
+      left: '',
+      right: '',
+      fileId: null,
+      hunkId: null,
+      fileIndex: null,
+      hunkIndex: null,
+      language: null,
+      oldLine: null,
+      newLine: null,
+    });
+  }
+
+  return {
+    diff,
+    rows,
+    fileStartRows,
+    hunkStartRows,
+  };
+}
+
+export function maxTopRowForModel(model: DiffUiModel, viewportHeight: number): number {
+  const bodyRows = Math.max(1, viewportHeight - 2);
+  return Math.max(0, model.rows.length - bodyRows);
+}