init

utils/diff.ts

@@ -0,0 +1,177 @@
+import { type StructuredPatchHunk, structuredPatch } from 'diff'
+import { logEvent } from 'src/services/analytics/index.js'
+import { getLocCounter } from '../bootstrap/state.js'
+import { addToTotalLinesChanged } from '../cost-tracker.js'
+import type { FileEdit } from '../tools/FileEditTool/types.js'
+import { count } from './array.js'
+import { convertLeadingTabsToSpaces } from './file.js'
+
+export const CONTEXT_LINES = 3
+export const DIFF_TIMEOUT_MS = 5_000
+
+/**
+ * Shifts hunk line numbers by offset. Use when getPatchForDisplay received
+ * a slice of the file (e.g. readEditContext) rather than the whole file —
+ * callers pass `ctx.lineOffset - 1` to convert slice-relative to file-relative.
+ */
+export function adjustHunkLineNumbers(
+  hunks: StructuredPatchHunk[],
+  offset: number,
+): StructuredPatchHunk[] {
+  if (offset === 0) return hunks
+  return hunks.map(h => ({
+    ...h,
+    oldStart: h.oldStart + offset,
+    newStart: h.newStart + offset,
+  }))
+}
+
+// For some reason, & confuses the diff library, so we replace it with a token,
+// then substitute it back in after the diff is computed.
+const AMPERSAND_TOKEN = '<<:AMPERSAND_TOKEN:>>'
+
+const DOLLAR_TOKEN = '<<:DOLLAR_TOKEN:>>'
+
+function escapeForDiff(s: string): string {
+  return s.replaceAll('&', AMPERSAND_TOKEN).replaceAll('$', DOLLAR_TOKEN)
+}
+
+function unescapeFromDiff(s: string): string {
+  return s.replaceAll(AMPERSAND_TOKEN, '&').replaceAll(DOLLAR_TOKEN, '$')
+}
+
+/**
+ * Count lines added and removed in a patch and update the total
+ * For new files, pass the content string as the second parameter
+ * @param patch Array of diff hunks
+ * @param newFileContent Optional content string for new files
+ */
+export function countLinesChanged(
+  patch: StructuredPatchHunk[],
+  newFileContent?: string,
+): void {
+  let numAdditions = 0
+  let numRemovals = 0
+
+  if (patch.length === 0 && newFileContent) {
+    // For new files, count all lines as additions
+    numAdditions = newFileContent.split(/\r?\n/).length
+  } else {
+    numAdditions = patch.reduce(
+      (acc, hunk) => acc + count(hunk.lines, _ => _.startsWith('+')),
+      0,
+    )
+    numRemovals = patch.reduce(
+      (acc, hunk) => acc + count(hunk.lines, _ => _.startsWith('-')),
+      0,
+    )
+  }
+
+  addToTotalLinesChanged(numAdditions, numRemovals)
+
+  getLocCounter()?.add(numAdditions, { type: 'added' })
+  getLocCounter()?.add(numRemovals, { type: 'removed' })
+
+  logEvent('tengu_file_changed', {
+    lines_added: numAdditions,
+    lines_removed: numRemovals,
+  })
+}
+
+export function getPatchFromContents({
+  filePath,
+  oldContent,
+  newContent,
+  ignoreWhitespace = false,
+  singleHunk = false,
+}: {
+  filePath: string
+  oldContent: string
+  newContent: string
+  ignoreWhitespace?: boolean
+  singleHunk?: boolean
+}): StructuredPatchHunk[] {
+  const result = structuredPatch(
+    filePath,
+    filePath,
+    escapeForDiff(oldContent),
+    escapeForDiff(newContent),
+    undefined,
+    undefined,
+    {
+      ignoreWhitespace,
+      context: singleHunk ? 100_000 : CONTEXT_LINES,
+      timeout: DIFF_TIMEOUT_MS,
+    },
+  )
+  if (!result) {
+    return []
+  }
+  return result.hunks.map(_ => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff),
+  }))
+}
+
+/**
+ * Get a patch for display with edits applied
+ * @param filePath The path to the file
+ * @param fileContents The contents of the file
+ * @param edits An array of edits to apply to the file
+ * @param ignoreWhitespace Whether to ignore whitespace changes
+ * @returns An array of hunks representing the diff
+ *
+ * NOTE: This function will return the diff with all leading tabs
+ * rendered as spaces for display
+ */
+
+export function getPatchForDisplay({
+  filePath,
+  fileContents,
+  edits,
+  ignoreWhitespace = false,
+}: {
+  filePath: string
+  fileContents: string
+  edits: FileEdit[]
+  ignoreWhitespace?: boolean
+}): StructuredPatchHunk[] {
+  const preparedFileContents = escapeForDiff(
+    convertLeadingTabsToSpaces(fileContents),
+  )
+  const result = structuredPatch(
+    filePath,
+    filePath,
+    preparedFileContents,
+    edits.reduce((p, edit) => {
+      const { old_string, new_string } = edit
+      const replace_all = 'replace_all' in edit ? edit.replace_all : false
+      const escapedOldString = escapeForDiff(
+        convertLeadingTabsToSpaces(old_string),
+      )
+      const escapedNewString = escapeForDiff(
+        convertLeadingTabsToSpaces(new_string),
+      )
+
+      if (replace_all) {
+        return p.replaceAll(escapedOldString, () => escapedNewString)
+      } else {
+        return p.replace(escapedOldString, () => escapedNewString)
+      }
+    }, preparedFileContents),
+    undefined,
+    undefined,
+    {
+      context: CONTEXT_LINES,
+      ignoreWhitespace,
+      timeout: DIFF_TIMEOUT_MS,
+    },
+  )
+  if (!result) {
+    return []
+  }
+  return result.hunks.map(_ => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff),
+  }))
+}