diffity 0.1.0

package/packages/git/src/commits.ts

@@ -0,0 +1,28 @@
+import { exec } from './exec.js';
+import type { Commit } from './types.js';
+
+interface CommitQuery {
+  count: number;
+  skip?: number;
+  search?: string;
+}
+
+export function getRecentCommits(query: CommitQuery): Commit[] {
+  const { count, skip = 0, search } = query;
+
+  const args = [`-n ${count}`, `--skip=${skip}`, '--format="%H|%h|%s|%cr"'];
+  if (search) {
+    args.push(`--grep=${search}`, '-i');
+  }
+
+  const output = exec(`git log ${args.join(' ')}`);
+
+  if (!output) {
+    return [];
+  }
+
+  return output.split('\n').map((line) => {
+    const [hash, shortHash, message, relativeDate] = line.split('|');
+    return { hash, shortHash, message, relativeDate };
+  });
+}

package/packages/git/src/diff.ts

@@ -0,0 +1,97 @@
+import { exec, execLarge, execLines, execWithStdin } from './exec.js';
+
+export function getDiff(args: string[] = []): string {
+  const cmd = ['git', 'diff', ...args].join(' ');
+  return execLarge(cmd);
+}
+
+export function getUntrackedFiles(): string[] {
+  return execLines('git ls-files --others --exclude-standard');
+}
+
+export function getUntrackedDiff(files: string[]): string {
+  const diffs: string[] = [];
+
+  for (const file of files) {
+    try {
+      execLarge(`git diff --no-index -- /dev/null "${file}"`);
+    } catch (err: unknown) {
+      const error = err as { stdout?: string; status?: number };
+      if (error.status === 1 && error.stdout) {
+        diffs.push(error.stdout);
+      }
+    }
+  }
+
+  return diffs.join('\n');
+}
+
+export function resolveRef(ref: string, extraArgs: string[] = []): string {
+  switch (ref) {
+    case 'staged': {
+      return getDiff(['--staged', ...extraArgs]);
+    }
+    case 'unstaged': {
+      return getDiff(extraArgs);
+    }
+    case 'working': {
+      return getDiff(['HEAD', ...extraArgs]);
+    }
+    case 'untracked': {
+      const files = getUntrackedFiles();
+      if (files.length === 0) {
+        return '';
+      }
+      return getUntrackedDiff(files);
+    }
+    case 'work': {
+      let raw = getDiff(['HEAD', ...extraArgs]);
+      const untrackedFiles = getUntrackedFiles();
+      if (untrackedFiles.length > 0) {
+        raw += '\n' + getUntrackedDiff(untrackedFiles);
+      }
+      return raw;
+    }
+    default: {
+      return getDiff([ref, ...extraArgs]);
+    }
+  }
+}
+
+export function revertFile(filePath: string, isUntracked: boolean): void {
+  if (isUntracked) {
+    exec(`rm "${filePath}"`);
+  } else {
+    exec(`git checkout HEAD -- "${filePath}"`);
+  }
+}
+
+export function revertHunk(patch: string): void {
+  execWithStdin('git apply --reverse --unidiff-zero', patch);
+}
+
+export function getDiffStat(args: string[] = []): string {
+  const cmd = ['git', 'diff', '--stat', ...args].join(' ');
+  try {
+    return execLarge(cmd);
+  } catch {
+    return '';
+  }
+}
+
+export function getMergeBase(a: string, b: string): string {
+  return exec(`git merge-base ${a} ${b}`);
+}
+
+export function getFileContent(path: string, ref = 'HEAD'): string {
+  return exec(`git show ${ref}:${path}`);
+}
+
+export function getFileLineCount(path: string, ref = 'HEAD'): number | null {
+  try {
+    const content = exec(`git show ${ref}:${path}`);
+    return content.split('\n').length;
+  } catch {
+    return null;
+  }
+}

package/packages/git/src/exec.ts

@@ -0,0 +1,35 @@
+import { execSync, type StdioOptions } from 'node:child_process';
+
+const STDIO: StdioOptions = ['pipe', 'pipe', 'pipe'];
+
+export function execWithStdin(cmd: string, input: string): string {
+  return execSync(cmd, {
+    encoding: 'utf-8',
+    stdio: STDIO,
+    input,
+    maxBuffer: 50 * 1024 * 1024,
+  });
+}
+
+export function exec(cmd: string): string {
+  return execSync(cmd, {
+    encoding: 'utf-8',
+    stdio: STDIO,
+  }).trim();
+}
+
+export function execLarge(cmd: string): string {
+  return execSync(cmd, {
+    encoding: 'utf-8',
+    stdio: STDIO,
+    maxBuffer: 50 * 1024 * 1024,
+  });
+}
+
+export function execLines(cmd: string): string[] {
+  const output = exec(cmd);
+  if (!output) {
+    return [];
+  }
+  return output.split('\n');
+}

package/packages/git/src/index.ts

@@ -0,0 +1,5 @@
+export type { Commit, RepoInfo } from './types.js';
+export { isGitRepo, getRepoRoot, getRepoName, getCurrentBranch, getRepoInfo, getHeadHash, getDiffityDir, getDiffityDirPath, isActionableRef } from './repo.js';
+export { getDiff, getDiffStat, getUntrackedFiles, getUntrackedDiff, getFileContent, getFileLineCount, getMergeBase, resolveRef, revertFile, revertHunk } from './diff.js';
+export { getStagedFiles, getUnstagedFiles } from './status.js';
+export { getRecentCommits } from './commits.js';

package/packages/git/src/repo.ts

@@ -0,0 +1,63 @@
+import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { exec } from './exec.js';
+import type { RepoInfo } from './types.js';
+
+export function isGitRepo(): boolean {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getRepoRoot(): string {
+  return exec('git rev-parse --show-toplevel');
+}
+
+export function getRepoName(): string {
+  const root = getRepoRoot();
+  return root.split('/').pop() || root;
+}
+
+export function getCurrentBranch(): string {
+  try {
+    return exec('git rev-parse --abbrev-ref HEAD');
+  } catch {
+    return 'HEAD';
+  }
+}
+
+export function getRepoInfo(): RepoInfo {
+  return {
+    name: getRepoName(),
+    branch: getCurrentBranch(),
+    root: getRepoRoot(),
+  };
+}
+
+export function getHeadHash(): string {
+  return exec('git rev-parse HEAD');
+}
+
+export function getDiffityDirPath(): string {
+  const repoRoot = getRepoRoot();
+  const hash = createHash('sha256').update(repoRoot).digest('hex').slice(0, 12);
+  return join(homedir(), '.diffity', hash);
+}
+
+export function getDiffityDir(): string {
+  const dir = getDiffityDirPath();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+const ACTIONABLE_REFS = new Set(['work', 'staged', 'unstaged', 'working', 'untracked']);
+
+export function isActionableRef(ref?: string): boolean {
+  return !!ref && ACTIONABLE_REFS.has(ref);
+}

package/packages/git/src/status.ts

@@ -0,0 +1,9 @@
+import { execLines } from './exec.js';
+
+export function getStagedFiles(): string[] {
+  return execLines('git diff --staged --name-only');
+}
+
+export function getUnstagedFiles(): string[] {
+  return execLines('git diff --name-only');
+}

package/packages/git/src/types.ts

@@ -0,0 +1,12 @@
+export interface Commit {
+  hash: string;
+  shortHash: string;
+  message: string;
+  relativeDate: string;
+}
+
+export interface RepoInfo {
+  name: string;
+  branch: string;
+  root: string;
+}

package/packages/git/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/packages/parser/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@diffity/parser",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}

package/packages/parser/src/index.ts

@@ -0,0 +1,12 @@
+export { parseDiff } from './parse.js';
+export { computeWordDiff } from './word-diff.js';
+export type {
+  DiffFile,
+  DiffHunk,
+  DiffLine,
+  DiffLineType,
+  FileStatus,
+  LineDiffType,
+  ParsedDiff,
+  WordDiffSegment,
+} from './types.js';

package/packages/parser/src/parse.ts

@@ -0,0 +1,299 @@
+import type {
+  DiffFile,
+  DiffHunk,
+  DiffLine,
+  DiffLineType,
+  FileStatus,
+  ParsedDiff,
+} from './types.js';
+import { computeWordDiff } from './word-diff.js';
+
+const DIFF_HEADER_RE = /^diff --git a\/(.*) b\/(.*)$/;
+const HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+const OLD_FILE_RE = /^--- (.+)$/;
+const NEW_FILE_RE = /^\+\+\+ (.+)$/;
+const SIMILARITY_RE = /^similarity index (\d+)%$/;
+const RENAME_FROM_RE = /^rename from (.+)$/;
+const RENAME_TO_RE = /^rename to (.+)$/;
+const COPY_FROM_RE = /^copy from (.+)$/;
+const COPY_TO_RE = /^copy to (.+)$/;
+const OLD_MODE_RE = /^old mode (\d+)$/;
+const NEW_MODE_RE = /^new mode (\d+)$/;
+const NEW_FILE_MODE_RE = /^new file mode (\d+)$/;
+const DELETED_FILE_MODE_RE = /^deleted file mode (\d+)$/;
+const BINARY_RE = /^Binary files (.+) and (.+) differ$/;
+const NO_NEWLINE_RE = /^\$/;
+
+function stripPrefix(path: string): string {
+  if (path === '/dev/null') {
+    return path;
+  }
+  if (path.startsWith('a/') || path.startsWith('b/')) {
+    return path.slice(2);
+  }
+  return path;
+}
+
+function attachWordDiffs(hunk: DiffHunk): void {
+  const lines = hunk.lines;
+  let i = 0;
+
+  while (i < lines.length) {
+    if (lines[i].type === 'delete') {
+      const deleteStart = i;
+      while (i < lines.length && lines[i].type === 'delete') {
+        i++;
+      }
+      const deleteEnd = i;
+
+      const addStart = i;
+      while (i < lines.length && lines[i].type === 'add') {
+        i++;
+      }
+      const addEnd = i;
+
+      const deleteCount = deleteEnd - deleteStart;
+      const addCount = addEnd - addStart;
+
+      if (deleteCount > 0 && addCount > 0) {
+        const pairCount = Math.min(deleteCount, addCount);
+        for (let p = 0; p < pairCount; p++) {
+          const delLine = lines[deleteStart + p];
+          const addLine = lines[addStart + p];
+          const segments = computeWordDiff(delLine.content, addLine.content);
+          delLine.wordDiff = segments;
+          addLine.wordDiff = segments;
+        }
+      }
+    } else {
+      i++;
+    }
+  }
+}
+
+export function parseDiff(raw: string): ParsedDiff {
+  const lines = raw.split('\n');
+  const files: DiffFile[] = [];
+  let currentFile: DiffFile | null = null;
+  let currentHunk: DiffHunk | null = null;
+  let oldLineNum = 0;
+  let newLineNum = 0;
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    const diffMatch = line.match(DIFF_HEADER_RE);
+    if (diffMatch) {
+      if (currentFile) {
+        files.push(currentFile);
+      }
+      currentFile = {
+        oldPath: diffMatch[1],
+        newPath: diffMatch[2],
+        status: 'modified',
+        hunks: [],
+        additions: 0,
+        deletions: 0,
+        isBinary: false,
+      };
+      currentHunk = null;
+      i++;
+      continue;
+    }
+
+    if (!currentFile) {
+      i++;
+      continue;
+    }
+
+    const oldModeMatch = line.match(OLD_MODE_RE);
+    if (oldModeMatch) {
+      currentFile.oldMode = oldModeMatch[1];
+      i++;
+      continue;
+    }
+
+    const newModeMatch = line.match(NEW_MODE_RE);
+    if (newModeMatch) {
+      currentFile.newMode = newModeMatch[1];
+      i++;
+      continue;
+    }
+
+    const newFileModeMatch = line.match(NEW_FILE_MODE_RE);
+    if (newFileModeMatch) {
+      currentFile.newMode = newFileModeMatch[1];
+      currentFile.status = 'added';
+      i++;
+      continue;
+    }
+
+    const deletedFileModeMatch = line.match(DELETED_FILE_MODE_RE);
+    if (deletedFileModeMatch) {
+      currentFile.oldMode = deletedFileModeMatch[1];
+      currentFile.status = 'deleted';
+      i++;
+      continue;
+    }
+
+    const similarityMatch = line.match(SIMILARITY_RE);
+    if (similarityMatch) {
+      currentFile.similarityIndex = parseInt(similarityMatch[1], 10);
+      i++;
+      continue;
+    }
+
+    const renameFromMatch = line.match(RENAME_FROM_RE);
+    if (renameFromMatch) {
+      currentFile.oldPath = renameFromMatch[1];
+      currentFile.status = 'renamed';
+      i++;
+      continue;
+    }
+
+    const renameToMatch = line.match(RENAME_TO_RE);
+    if (renameToMatch) {
+      currentFile.newPath = renameToMatch[1];
+      currentFile.status = 'renamed';
+      i++;
+      continue;
+    }
+
+    const copyFromMatch = line.match(COPY_FROM_RE);
+    if (copyFromMatch) {
+      currentFile.oldPath = copyFromMatch[1];
+      currentFile.status = 'copied';
+      i++;
+      continue;
+    }
+
+    const copyToMatch = line.match(COPY_TO_RE);
+    if (copyToMatch) {
+      currentFile.newPath = copyToMatch[1];
+      currentFile.status = 'copied';
+      i++;
+      continue;
+    }
+
+    const oldFileMatch = line.match(OLD_FILE_RE);
+    if (oldFileMatch) {
+      const path = stripPrefix(oldFileMatch[1]);
+      currentFile.oldPath = path;
+      if (path === '/dev/null') {
+        currentFile.status = 'added';
+      }
+      i++;
+      continue;
+    }
+
+    const newFileMatch = line.match(NEW_FILE_RE);
+    if (newFileMatch) {
+      const path = stripPrefix(newFileMatch[1]);
+      currentFile.newPath = path;
+      if (path === '/dev/null') {
+        currentFile.status = 'deleted';
+      }
+      i++;
+      continue;
+    }
+
+    const binaryMatch = line.match(BINARY_RE);
+    if (binaryMatch) {
+      currentFile.isBinary = true;
+      i++;
+      continue;
+    }
+
+    const hunkMatch = line.match(HUNK_HEADER_RE);
+    if (hunkMatch) {
+      currentHunk = {
+        header: line,
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: hunkMatch[2] !== undefined ? parseInt(hunkMatch[2], 10) : 1,
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: hunkMatch[4] !== undefined ? parseInt(hunkMatch[4], 10) : 1,
+        context: hunkMatch[5]?.trim() || undefined,
+        lines: [],
+      };
+      currentFile.hunks.push(currentHunk);
+      oldLineNum = currentHunk.oldStart;
+      newLineNum = currentHunk.newStart;
+      i++;
+      continue;
+    }
+
+    if (NO_NEWLINE_RE.test(line)) {
+      if (currentHunk && currentHunk.lines.length > 0) {
+        currentHunk.lines[currentHunk.lines.length - 1].noNewline = true;
+      }
+      i++;
+      continue;
+    }
+
+    if (currentHunk) {
+      const prefix = line[0];
+      const content = line.slice(1);
+
+      if (prefix === '+') {
+        const diffLine: DiffLine = {
+          type: 'add',
+          content,
+          oldLineNumber: null,
+          newLineNumber: newLineNum,
+        };
+        currentHunk.lines.push(diffLine);
+        currentFile.additions++;
+        newLineNum++;
+      } else if (prefix === '-') {
+        const diffLine: DiffLine = {
+          type: 'delete',
+          content,
+          oldLineNumber: oldLineNum,
+          newLineNumber: null,
+        };
+        currentHunk.lines.push(diffLine);
+        currentFile.deletions++;
+        oldLineNum++;
+      } else if (prefix === ' ') {
+        const diffLine: DiffLine = {
+          type: 'context',
+          content: content || '',
+          oldLineNumber: oldLineNum,
+          newLineNumber: newLineNum,
+        };
+        currentHunk.lines.push(diffLine);
+        oldLineNum++;
+        newLineNum++;
+      }
+    }
+
+    i++;
+  }
+
+  if (currentFile) {
+    files.push(currentFile);
+  }
+
+  for (const file of files) {
+    for (const hunk of file.hunks) {
+      attachWordDiffs(hunk);
+    }
+  }
+
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+  for (const file of files) {
+    totalAdditions += file.additions;
+    totalDeletions += file.deletions;
+  }
+
+  return {
+    files,
+    stats: {
+      totalAdditions,
+      totalDeletions,
+      filesChanged: files.length,
+    },
+  };
+}

package/packages/parser/src/types.ts

@@ -0,0 +1,52 @@
+export type FileStatus = 'added' | 'deleted' | 'modified' | 'renamed' | 'copied';
+
+export type LineDiffType = 'equal' | 'insert' | 'delete';
+
+export interface WordDiffSegment {
+  text: string;
+  type: LineDiffType;
+}
+
+export type DiffLineType = 'add' | 'delete' | 'context';
+
+export interface DiffLine {
+  type: DiffLineType;
+  content: string;
+  oldLineNumber: number | null;
+  newLineNumber: number | null;
+  noNewline?: boolean;
+  wordDiff?: WordDiffSegment[];
+}
+
+export interface DiffHunk {
+  header: string;
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  context?: string;
+  lines: DiffLine[];
+}
+
+export interface DiffFile {
+  oldPath: string;
+  newPath: string;
+  status: FileStatus;
+  hunks: DiffHunk[];
+  additions: number;
+  deletions: number;
+  isBinary: boolean;
+  oldMode?: string;
+  newMode?: string;
+  similarityIndex?: number;
+  oldFileLineCount?: number;
+}
+
+export interface ParsedDiff {
+  files: DiffFile[];
+  stats: {
+    totalAdditions: number;
+    totalDeletions: number;
+    filesChanged: number;
+  };
+}