diff-easy 0.1.0

package/dist/utils/editorOptions.js

@@ -0,0 +1,171 @@
+export const CUSTOM_EDITOR_ID = 'custom';
+export const NONE_EDITOR_ID = 'none';
+export const DEFAULT_EDITOR_ID = 'vscode';
+export const EDITOR_OPTIONS = [
+    {
+        id: 'vscode',
+        label: 'VS Code',
+        command: 'code',
+        argsTemplate: '-g %file:%line',
+    },
+    {
+        id: 'cursor',
+        label: 'Cursor',
+        command: 'cursor',
+        argsTemplate: '-g %file:%line',
+    },
+    {
+        id: 'zed',
+        label: 'Zed',
+        command: 'zed',
+        argsTemplate: '%file:%line',
+    },
+    {
+        id: 'textmate',
+        label: 'TextMate',
+        command: 'mate',
+        argsTemplate: '-l %line %file',
+    },
+    {
+        id: 'bbedit',
+        label: 'BBEdit',
+        command: 'bbedit',
+        argsTemplate: '+%line %file',
+    },
+    {
+        id: 'emacs',
+        label: 'Emacs',
+        command: 'emacsclient',
+        argsTemplate: '--no-wait +%line %file',
+    },
+    {
+        id: 'macvim',
+        label: 'MacVim',
+        command: 'mvim',
+        argsTemplate: '--remote-silent +%line %file',
+    },
+    {
+        id: 'sublime',
+        label: 'Sublime Text',
+        command: 'subl',
+        argsTemplate: '%file:%line',
+    },
+    {
+        id: 'nova',
+        label: 'Nova',
+        command: 'nova',
+        argsTemplate: 'open %file -l %line',
+    },
+    {
+        id: 'custom',
+        label: 'Custom…',
+        command: '',
+        argsTemplate: '',
+    },
+    {
+        id: 'none',
+        label: 'Hide “Open in editor” button',
+        command: '',
+        argsTemplate: '',
+    },
+];
+export const DEFAULT_EDITOR_OPTION = EDITOR_OPTIONS.find((option) => option.id === DEFAULT_EDITOR_ID) ?? EDITOR_OPTIONS[0];
+/**
+ * Case-insensitive lookup by id. Used mostly for the `DIFIT_EDITOR` / `EDITOR`
+ * environment-variable fallback on the server; the browser UI passes the full
+ * `{id, command, argsTemplate}` shape so it does not rely on this helper.
+ */
+export const resolveEditorOption = (input) => {
+    const normalized = (input ?? DEFAULT_EDITOR_ID).toLowerCase();
+    const matched = EDITOR_OPTIONS.find((option) => option.id === normalized);
+    return matched ?? DEFAULT_EDITOR_OPTION;
+};
+/**
+ * Tokenise a user-supplied arguments template string into individual CLI
+ * arguments. Supports single and double quoted segments so paths and flags
+ * containing spaces can be preserved.
+ *
+ * Inside double-quoted segments `\"` decodes to a literal `"` and `\\` to a
+ * literal `\`, mirroring common shell intuition. Other `\x` sequences pass
+ * through untouched so Lisp/regex fragments like `\s` or `\$` stay intact.
+ * Single-quoted segments are fully literal. The template is handed to
+ * `spawn` as argv directly – no shell is involved.
+ */
+export const parseEditorArgsTemplate = (template) => {
+    const input = template ?? '';
+    const tokens = [];
+    const n = input.length;
+    let i = 0;
+    while (i < n) {
+        while (i < n && /\s/.test(input[i] ?? ''))
+            i++;
+        if (i >= n)
+            break;
+        let token = '';
+        let inQuote = null;
+        while (i < n) {
+            const ch = input[i];
+            if (ch === undefined)
+                break;
+            if (inQuote === '"') {
+                if (ch === '\\' && i + 1 < n) {
+                    const next = input[i + 1];
+                    if (next === '"' || next === '\\') {
+                        token += next;
+                        i += 2;
+                        continue;
+                    }
+                }
+                if (ch === inQuote) {
+                    inQuote = null;
+                    i++;
+                }
+                else {
+                    token += ch;
+                    i++;
+                }
+                continue;
+            }
+            if (inQuote === "'") {
+                if (ch === inQuote) {
+                    inQuote = null;
+                    i++;
+                }
+                else {
+                    token += ch;
+                    i++;
+                }
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                inQuote = ch;
+                i++;
+                continue;
+            }
+            if (/\s/.test(ch))
+                break;
+            token += ch;
+            i++;
+        }
+        tokens.push(token);
+    }
+    return tokens;
+};
+/**
+ * Build the final `{ command, args }` tuple to hand to `child_process.spawn`.
+ * Returns `null` when the command is empty so callers can surface a clear
+ * "not configured" error instead of spawning an empty process.
+ *
+ * `%file` and `%line` are substituted as-is inside each token, so composite
+ * tokens such as `"%file:%line"` become `"/abs/file.ts:42"`. When no line
+ * number is available the substitution falls back to `1`.
+ */
+export const buildEditorSpawnSpec = (input) => {
+    const command = input.command.trim();
+    if (!command)
+        return null;
+    const tokens = parseEditorArgsTemplate(input.argsTemplate);
+    const lineValue = String(input.lineNumber ?? 1);
+    const args = tokens.map((piece) => piece.replaceAll('%file', input.filePath).replaceAll('%line', lineValue));
+    return { command, args };
+};

package/dist/utils/fileUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get file extension from filename or filepath
+ * @param filename - The filename or filepath
+ * @returns The file extension in lowercase, or null if no extension
+ */
+export declare function getFileExtension(filename: string): string | null;
+/**
+ * Get filename from filepath
+ * @param filepath - The filepath
+ * @returns The filename
+ */
+export declare function getFileName(filepath: string): string;

package/dist/utils/fileUtils.js

@@ -0,0 +1,21 @@
+/**
+ * Get file extension from filename or filepath
+ * @param filename - The filename or filepath
+ * @returns The file extension in lowercase, or null if no extension
+ */
+export function getFileExtension(filename) {
+    if (!filename)
+        return null;
+    const extension = filename.split('.').pop()?.toLowerCase();
+    return extension || null;
+}
+/**
+ * Get filename from filepath
+ * @param filepath - The filepath
+ * @returns The filename
+ */
+export function getFileName(filepath) {
+    if (!filepath)
+        return '';
+    return filepath.split('/').pop() || '';
+}

package/dist/utils/hubConfig.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hub configuration (diff-easy hub).
+ *
+ * Persists the user's workspace roots (scanned for repos), recently-opened
+ * folders/PRs, and per-repo "last seen turn" markers for activity badges.
+ * Stored at `$DIFIT_HOME/.difit/config.json` (DIFIT_HOME defaults to $HOME;
+ * the override exists so tests don't touch the real home dir).
+ */
+export interface RecentFolder {
+    repoId: string;
+    path: string;
+    name: string;
+}
+interface RecentPr {
+    url: string;
+    label: string;
+    repoId: string;
+}
+export interface HubConfig {
+    roots: string[];
+    recents: RecentFolder[];
+    recentPrs: RecentPr[];
+    /** repoId → timestamp of the newest turn the user has seen (for badges). */
+    lastSeen: Record<string, number>;
+}
+export declare function readHubConfig(): HubConfig;
+export declare function writeHubConfig(config: HubConfig): void;
+/** Add workspace roots (absolute, de-duplicated) to the config. */
+export declare function addHubRoots(paths: string[]): HubConfig;
+/** Record a recently-opened folder (most-recent first, capped). */
+export declare function pushRecentFolder(config: HubConfig, folder: RecentFolder): void;
+export {};

package/dist/utils/hubConfig.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join, resolve } from 'path';
+const DIR = '.difit';
+const FILE = 'config.json';
+const MAX_RECENTS = 20;
+function baseDir() {
+    return process.env.DIFIT_HOME || homedir();
+}
+function configPath() {
+    return join(baseDir(), DIR, FILE);
+}
+function defaultConfig() {
+    return { roots: [], recents: [], recentPrs: [], lastSeen: {} };
+}
+export function readHubConfig() {
+    try {
+        const raw = readFileSync(configPath(), 'utf8');
+        const data = JSON.parse(raw);
+        return {
+            roots: Array.isArray(data.roots) ? data.roots : [],
+            recents: Array.isArray(data.recents) ? data.recents : [],
+            recentPrs: Array.isArray(data.recentPrs) ? data.recentPrs : [],
+            lastSeen: data.lastSeen && typeof data.lastSeen === 'object' ? data.lastSeen : {},
+        };
+    }
+    catch {
+        return defaultConfig();
+    }
+}
+export function writeHubConfig(config) {
+    const dir = join(baseDir(), DIR);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}\n`);
+}
+/** Add workspace roots (absolute, de-duplicated) to the config. */
+export function addHubRoots(paths) {
+    const config = readHubConfig();
+    for (const p of paths) {
+        const abs = resolve(p);
+        if (!config.roots.includes(abs))
+            config.roots.push(abs);
+    }
+    writeHubConfig(config);
+    return config;
+}
+/** Record a recently-opened folder (most-recent first, capped). */
+export function pushRecentFolder(config, folder) {
+    config.recents = [folder, ...config.recents.filter((r) => r.repoId !== folder.repoId)].slice(0, MAX_RECENTS);
+}

package/dist/utils/suggestionUtils.d.ts

@@ -0,0 +1,19 @@
+interface SuggestionBlock {
+    suggestedCode: string;
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Check if a comment body contains any suggestion blocks
+ */
+export declare function hasSuggestionBlock(body: string): boolean;
+/**
+ * Parse all suggestion blocks from a comment body.
+ * Pure parser: only extracts suggestion blocks and their positions from the body text.
+ */
+export declare function parseSuggestionBlocks(body: string): SuggestionBlock[];
+/**
+ * Create a suggestion template with the given code
+ */
+export declare function createSuggestionTemplate(code: string): string;
+export {};

package/dist/utils/suggestionUtils.js

@@ -0,0 +1,31 @@
+/**
+ * Check if a comment body contains any suggestion blocks
+ */
+export function hasSuggestionBlock(body) {
+    return /```suggestion\n([\s\S]*?)```/.test(body);
+}
+/**
+ * Parse all suggestion blocks from a comment body.
+ * Pure parser: only extracts suggestion blocks and their positions from the body text.
+ */
+export function parseSuggestionBlocks(body) {
+    const blocks = [];
+    const regex = /```suggestion\n([\s\S]*?)```/g;
+    let match;
+    while ((match = regex.exec(body)) !== null) {
+        blocks.push({
+            suggestedCode: match[1].replace(/\n$/, ''), // Remove trailing newline
+            startIndex: match.index,
+            endIndex: match.index + match[0].length,
+        });
+    }
+    return blocks;
+}
+/**
+ * Create a suggestion template with the given code
+ */
+export function createSuggestionTemplate(code) {
+    // Ensure code ends with a newline for proper formatting
+    const normalizedCode = code.endsWith('\n') ? code : code + '\n';
+    return `\`\`\`suggestion\n${normalizedCode}\`\`\``;
+}

package/dist/utils/turnLog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared turn-log model (diff-easy addition).
+ *
+ * A "turn" is one round of an AI-agent conversation. The capture hook
+ * (`diff-easy snapshot`) records a git snapshot at the start (UserPromptSubmit)
+ * and end (Stop) of each turn; the server reads this log to show the diff a
+ * given turn produced. Snapshots are anchored under a git ref so the objects
+ * survive garbage collection (see src/cli/turns.ts).
+ */
+export interface TurnRecord {
+    id: string;
+    sessionId: string;
+    /** Full user prompt that started the turn (UserPromptSubmit), if available. */
+    prompt: string | null;
+    /** Short single-line preview for the timeline UI. */
+    promptPreview: string | null;
+    /** Snapshot commit of the working tree at the start of the turn. */
+    commitBefore: string;
+    /** Snapshot commit at the end of the turn; null while the turn is open. */
+    commitAfter: string | null;
+    startedAt: number;
+    endedAt: number | null;
+    status: 'open' | 'closed';
+}
+export interface ServerInfo {
+    port: number;
+    pid: number;
+    startedAt: number;
+}
+export declare function readTurnLog(repoRoot: string): TurnRecord[];
+export declare function writeTurnLog(repoRoot: string, turns: TurnRecord[]): void;
+/**
+ * Count completed turns whose end time is newer than `since` (epoch ms). Open
+ * (in-progress) turns are excluded — they aren't yet a reviewable change. Used
+ * to compute the hub's per-repo "new turns" activity badge.
+ */
+export declare function countTurnsSince(turns: TurnRecord[], since: number): number;
+/** Newest completed-turn end time (epoch ms), or 0 when there are none. */
+export declare function latestTurnTimestamp(turns: TurnRecord[]): number;
+export declare function readServerInfo(repoRoot: string): ServerInfo | null;
+export declare function writeServerInfo(repoRoot: string, info: ServerInfo): void;
+/** Remove the advertised server info (on shutdown, or when found to be stale). */
+export declare function deleteServerInfo(repoRoot: string): void;
+export declare function writeHubInfo(info: ServerInfo): void;
+/** Read the global hub advertisement, or null if no hub is running. */
+export declare function readHubInfo(): ServerInfo | null;
+export declare function deleteHubInfo(): void;

package/dist/utils/turnLog.js

@@ -0,0 +1,133 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const TURN_DIR_NAME = '.difit-turns';
+const TURN_LOG_NAME = 'log.json';
+const SERVER_INFO_NAME = 'server.json';
+function turnDir(repoRoot) {
+    return join(repoRoot, TURN_DIR_NAME);
+}
+function turnLogPath(repoRoot) {
+    return join(turnDir(repoRoot), TURN_LOG_NAME);
+}
+function serverInfoPath(repoRoot) {
+    return join(turnDir(repoRoot), SERVER_INFO_NAME);
+}
+function ensureTurnDir(repoRoot) {
+    const dir = turnDir(repoRoot);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+        // The whole directory is local-only state; keep it out of version control.
+        try {
+            writeFileSync(join(dir, '.gitignore'), '*\n');
+        }
+        catch {
+            // best-effort
+        }
+    }
+}
+export function readTurnLog(repoRoot) {
+    try {
+        const raw = readFileSync(turnLogPath(repoRoot), 'utf8');
+        const data = JSON.parse(raw);
+        if (data && typeof data === 'object' && Array.isArray(data.turns)) {
+            return data.turns;
+        }
+        if (Array.isArray(data))
+            return data;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeTurnLog(repoRoot, turns) {
+    ensureTurnDir(repoRoot);
+    const payload = { version: 1, turns };
+    writeFileSync(turnLogPath(repoRoot), `${JSON.stringify(payload, null, 2)}\n`);
+}
+/**
+ * Count completed turns whose end time is newer than `since` (epoch ms). Open
+ * (in-progress) turns are excluded — they aren't yet a reviewable change. Used
+ * to compute the hub's per-repo "new turns" activity badge.
+ */
+export function countTurnsSince(turns, since) {
+    return turns.filter((turn) => turn.endedAt != null && turn.endedAt > since).length;
+}
+/** Newest completed-turn end time (epoch ms), or 0 when there are none. */
+export function latestTurnTimestamp(turns) {
+    let latest = 0;
+    for (const turn of turns) {
+        if (turn.endedAt != null && turn.endedAt > latest) {
+            latest = turn.endedAt;
+        }
+    }
+    return latest;
+}
+export function readServerInfo(repoRoot) {
+    try {
+        const raw = readFileSync(serverInfoPath(repoRoot), 'utf8');
+        const data = JSON.parse(raw);
+        if (data && typeof data === 'object' && typeof data.port === 'number') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeServerInfo(repoRoot, info) {
+    ensureTurnDir(repoRoot);
+    writeFileSync(serverInfoPath(repoRoot), `${JSON.stringify(info, null, 2)}\n`);
+}
+/** Remove the advertised server info (on shutdown, or when found to be stale). */
+export function deleteServerInfo(repoRoot) {
+    try {
+        rmSync(serverInfoPath(repoRoot), { force: true });
+    }
+    catch {
+        // best-effort — a leftover file only costs a wasted liveness check
+    }
+}
+// ----- Hub server discovery (diff-easy hub) -------------------------------
+// The always-on hub serves many repos, so it advertises itself at a single
+// global path (not per-repo) that the capture hook reads regardless of which
+// repo the agent ran in.
+const HUB_DIR_NAME = '.difit';
+const HUB_INFO_NAME = 'hub.json';
+/** Base dir for hub state. `DIFIT_HOME` overrides $HOME (used to isolate tests). */
+function hubBaseDir() {
+    return process.env.DIFIT_HOME || homedir();
+}
+function hubInfoPath() {
+    return join(hubBaseDir(), HUB_DIR_NAME, HUB_INFO_NAME);
+}
+export function writeHubInfo(info) {
+    const dir = join(hubBaseDir(), HUB_DIR_NAME);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(hubInfoPath(), `${JSON.stringify(info, null, 2)}\n`);
+}
+/** Read the global hub advertisement, or null if no hub is running. */
+export function readHubInfo() {
+    try {
+        const raw = readFileSync(hubInfoPath(), 'utf8');
+        const data = JSON.parse(raw);
+        if (data && typeof data === 'object' && typeof data.port === 'number') {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function deleteHubInfo() {
+    try {
+        rmSync(hubInfoPath(), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "diff-easy",
+  "version": "0.1.0",
+  "description": "A local git diff viewer for AI-agent workflows: filter by file/type, search within diffs, and review the diff produced by each agent turn. Built on difit.",
+  "keywords": [
+    "cli",
+    "code-review",
+    "diff",
+    "diff-viewer",
+    "git",
+    "github",
+    "react",
+    "review",
+    "tailwind"
+  ],
+  "license": "MIT",
+  "author": "Sai Mageshvar",
+  "bin": {
+    "diff-easy": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/cli/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "node scripts/dev.js",
+    "dev:site": "pnpm run build:cli && node scripts/export-site-data.js && vite --config vite.config.site.ts --open /",
+    "dev:cli": "tsc --project tsconfig.cli.json && NODE_ENV=development node dist/cli/index.js",
+    "clean": "node -e \"const fs=require('fs');['dist','tsconfig.cli.tsbuildinfo','tsconfig.tsbuildinfo'].forEach(f=>fs.rmSync(f,{recursive:true,force:true}))\"",
+    "build": "pnpm run clean && pnpm run build:cli && vite build && node scripts/prune-dist-tests.js",
+    "build:site": "pnpm run build:cli && GITHUB_PAGES=true vite build --config vite.config.site.ts",
+    "build:cli": "tsc --project tsconfig.cli.json",
+    "export:site-data": "node scripts/export-site-data.js",
+    "start": "pnpm run build && node dist/cli/index.js",
+    "check": "oxlint . --type-aware --type-check --deny-warnings --report-unused-disable-directives",
+    "check:fix": "oxlint . --type-aware --type-check --deny-warnings --report-unused-disable-directives --fix",
+    "format": "oxfmt --check .",
+    "format:fix": "oxfmt --write .",
+    "knip": "knip --use-tsconfig-files",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepare": "lefthook install",
+    "prepublishOnly": "NODE_ENV=production pnpm run build",
+    "perf": "node scripts/measure-performance.js",
+    "perf:small": "node scripts/measure-performance.js --size small",
+    "perf:medium": "node scripts/measure-performance.js --size medium",
+    "perf:large": "node scripts/measure-performance.js --size large",
+    "perf:xlarge": "node scripts/measure-performance.js --size xlarge",
+    "perf:compare": "node scripts/compare-performance.js"
+  },
+  "dependencies": {
+    "@floating-ui/react": "^0.27.16",
+    "@parcel/watcher": "^2.5.1",
+    "commander": "^14.0.0",
+    "diff": "^9.0.0",
+    "express": "^5.1.0",
+    "lucide-react": "^1.0.0",
+    "mermaid": "^11.13.0",
+    "open": "^11.0.0",
+    "prism-react-renderer": "^2.4.1",
+    "prismjs": "^1.30.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-hotkeys-hook": "^5.2.4",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "simple-git": "^3.28.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.11",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@tsconfig/strictest": "^2.0.5",
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.0.8",
+    "@types/react": "^19.1.8",
+    "@types/react-dom": "^19.1.6",
+    "@vitejs/plugin-react": "^6.0.0",
+    "autoprefixer": "^10.4.21",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "happy-dom": "^20.0.0",
+    "knip": "^6.0.0",
+    "lefthook": "^2.0.0",
+    "oxfmt": "^0.53.0",
+    "oxlint": "^1.49.0",
+    "oxlint-tsgolint": "^0.23.0",
+    "playwright": "^1.54.1",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.11",
+    "typescript": "^6.0.0",
+    "undici": "^8.0.0",
+    "vite": "^8.0.0",
+    "vitest": "^4.0.6"
+  },
+  "engines": {
+    "node": ">=21.0.0"
+  },
+  "packageManager": "pnpm@11.5.0"
+}