diffity 0.1.0

package/packages/cli/src/server.ts

@@ -0,0 +1,370 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { createHash } from 'node:crypto';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { parseDiff, type ParsedDiff } from '@diffity/parser';
+import {
+  getDiff,
+  getDiffStat,
+  getUntrackedFiles,
+  getUntrackedDiff,
+  getRepoInfo,
+  getFileContent,
+  getStagedFiles,
+  getUnstagedFiles,
+  getRecentCommits,
+  getFileLineCount,
+  getMergeBase,
+  resolveRef,
+  revertFile,
+  revertHunk,
+  isActionableRef,
+} from '@diffity/git';
+import { findOrCreateSession } from './session.js';
+import { handleReviewRoute } from './review-routes.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const MIME_TYPES: Record<string, string> = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.ico': 'image/x-icon',
+};
+
+interface ServerOptions {
+  port: number;
+  diffArgs: string[];
+  description?: string;
+  effectiveRef?: string;
+}
+
+function sendJson(res: ServerResponse, data: unknown) {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function sendError(res: ServerResponse, status: number, message: string) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({ error: message }));
+}
+
+function serveStatic(res: ServerResponse, filePath: string) {
+  if (!existsSync(filePath)) {
+    sendError(res, 404, 'Not found');
+    return;
+  }
+  const ext = extname(filePath);
+  const mime = MIME_TYPES[ext] || 'application/octet-stream';
+  const content = readFileSync(filePath);
+  res.writeHead(200, { 'Content-Type': mime });
+  res.end(content);
+}
+
+
+function descriptionForRef(ref: string): string {
+  switch (ref) {
+    case 'staged':
+      return 'Staged changes';
+    case 'unstaged':
+      return 'Unstaged changes';
+    case 'working':
+      return 'Working tree changes';
+    case 'untracked':
+      return 'Untracked files';
+    case 'work':
+      return 'All changes';
+    default:
+      if (ref.includes('..')) {
+        return ref;
+      }
+      return `Changes from ${ref}`;
+  }
+}
+
+function resolveBaseRef(ref: string): string {
+  if (['staged', 'working', 'work'].includes(ref)) {
+    return 'HEAD';
+  }
+  if (ref === 'unstaged' || ref === 'untracked') {
+    return 'HEAD';
+  }
+
+  const threeDotsIdx = ref.indexOf('...');
+  if (threeDotsIdx !== -1) {
+    const left = ref.slice(0, threeDotsIdx);
+    const right = ref.slice(threeDotsIdx + 3);
+    return getMergeBase(left, right);
+  }
+
+  const twoDotsIdx = ref.indexOf('..');
+  if (twoDotsIdx !== -1) {
+    return ref.slice(0, twoDotsIdx);
+  }
+
+  return ref;
+}
+
+interface ServerResult {
+  port: number;
+  close: () => void;
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk: Buffer) => chunks.push(chunk));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+    req.on('error', reject);
+  });
+}
+
+export function startServer(options: ServerOptions): Promise<ServerResult> {
+  const { port, diffArgs, description, effectiveRef } = options;
+
+  let sessionId: string | null = null;
+  const reviewsEnabled = isActionableRef(effectiveRef);
+  if (reviewsEnabled && effectiveRef) {
+    const session = findOrCreateSession(effectiveRef);
+    sessionId = session.id;
+  }
+
+  const includeUntracked = diffArgs.length === 0;
+  function enrichWithLineCounts(diff: ParsedDiff, baseRef: string): ParsedDiff {
+    for (const file of diff.files) {
+      if (file.status === 'added' || file.isBinary) {
+        continue;
+      }
+      const path = file.oldPath || file.newPath;
+      const count = getFileLineCount(path, baseRef);
+      if (count !== null) {
+        file.oldFileLineCount = count;
+      }
+    }
+    return diff;
+  }
+
+  function getFullDiff(args: string[]): string {
+    let raw = getDiff(args);
+    if (includeUntracked) {
+      const untrackedFiles = getUntrackedFiles();
+      if (untrackedFiles.length > 0) {
+        raw += '\n' + getUntrackedDiff(untrackedFiles);
+      }
+    }
+    return raw;
+  }
+
+  const uiDir = join(__dirname, 'ui');
+
+  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const url = new URL(req.url || '/', `http://localhost:${port}`);
+    const pathname = url.pathname;
+
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (pathname === '/api/revert-file' && req.method === 'POST') {
+      try {
+        const body = JSON.parse(await readBody(req));
+        const { filePath: path, isUntracked } = body;
+        if (!path || typeof path !== 'string') {
+          sendError(res, 400, 'Missing filePath');
+          return;
+        }
+        revertFile(path, !!isUntracked);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        sendError(res, 500, `Failed to revert file: ${err}`);
+      }
+      return;
+    }
+
+    if (pathname === '/api/revert-hunk' && req.method === 'POST') {
+      try {
+        const body = JSON.parse(await readBody(req));
+        const { patch } = body;
+        if (!patch || typeof patch !== 'string') {
+          sendError(res, 400, 'Missing patch');
+          return;
+        }
+        revertHunk(patch);
+        sendJson(res, { ok: true });
+      } catch (err) {
+        sendError(res, 500, `Failed to revert hunk: ${err}`);
+      }
+      return;
+    }
+
+    if (pathname === '/api/overview') {
+      try {
+        const staged = getStagedFiles();
+        const unstaged = getUnstagedFiles();
+        const untracked = getUntrackedFiles();
+
+        const fileMap = new Map<string, string>();
+        for (const f of staged) {
+          fileMap.set(f, 'staged');
+        }
+        for (const f of unstaged) {
+          fileMap.set(f, 'modified');
+        }
+        for (const f of untracked) {
+          fileMap.set(f, 'added');
+        }
+
+        const files = Array.from(fileMap.entries()).map(([path, status]) => ({ path, status }));
+
+        sendJson(res, { files });
+      } catch (err) {
+        sendError(res, 500, `Failed to get overview: ${err}`);
+      }
+      return;
+    }
+
+    if (pathname === '/api/commits') {
+      const count = parseInt(url.searchParams.get('count') || '10', 10);
+      const skip = parseInt(url.searchParams.get('skip') || '0', 10);
+      const search = url.searchParams.get('search') || undefined;
+      try {
+        const commits = getRecentCommits({ count, skip, search });
+        sendJson(res, { commits, hasMore: commits.length === count });
+      } catch (err) {
+        sendError(res, 500, `Failed to get commits: ${err}`);
+      }
+      return;
+    }
+
+    if (pathname === '/api/diff-fingerprint') {
+      const ref = url.searchParams.get('ref');
+      let stat: string;
+      if (ref) {
+        switch (ref) {
+          case 'work':
+          case 'working':
+            stat = getDiffStat(['HEAD']) + '\n' + getUntrackedFiles().join('\n');
+            break;
+          case 'staged':
+            stat = getDiffStat(['--staged']);
+            break;
+          case 'unstaged':
+            stat = getDiffStat([]);
+            break;
+          case 'untracked':
+            stat = getUntrackedFiles().join('\n');
+            break;
+          default:
+            stat = getDiffStat([ref]);
+            break;
+        }
+      } else {
+        stat = getDiffStat(diffArgs);
+        if (includeUntracked) {
+          stat += '\n' + getUntrackedFiles().join('\n');
+        }
+      }
+      const hash = createHash('sha1').update(stat).digest('hex').slice(0, 12);
+      sendJson(res, { fingerprint: hash });
+      return;
+    }
+
+    if (pathname === '/api/diff') {
+      const ref = url.searchParams.get('ref');
+      const whitespace = url.searchParams.get('whitespace');
+      const extraArgs = whitespace === 'hide' ? ['-w'] : [];
+      const baseRef = ref ? resolveBaseRef(ref) : 'HEAD';
+
+      if (ref) {
+        sendJson(res, enrichWithLineCounts(parseDiff(resolveRef(ref, extraArgs)), baseRef));
+        return;
+      }
+
+      if (whitespace === 'hide') {
+        sendJson(res, enrichWithLineCounts(parseDiff(getFullDiff([...diffArgs, '-w'])), baseRef));
+        return;
+      }
+      sendJson(res, enrichWithLineCounts(parseDiff(getFullDiff(diffArgs)), baseRef));
+      return;
+    }
+
+    if (pathname.startsWith('/api/file/')) {
+      const filePath = decodeURIComponent(pathname.slice('/api/file/'.length));
+      const ref = url.searchParams.get('ref') || undefined;
+      const baseRef = ref ? resolveBaseRef(ref) : 'HEAD';
+      try {
+        const content = getFileContent(filePath, baseRef);
+        sendJson(res, { path: filePath, content: content.split('\n') });
+      } catch {
+        sendError(res, 404, `File not found: ${filePath}`);
+      }
+      return;
+    }
+
+    if (pathname === '/api/info') {
+      const ref = url.searchParams.get('ref');
+      const info = getRepoInfo();
+      let refDescription = description || diffArgs.join(' ') || 'Unstaged changes';
+      if (ref) {
+        refDescription = descriptionForRef(ref);
+      }
+      sendJson(res, {
+        ...info,
+        description: refDescription,
+        capabilities: { reviews: reviewsEnabled },
+        sessionId,
+      });
+      return;
+    }
+
+    if (handleReviewRoute(req, res, pathname, url)) {
+      return;
+    }
+
+    let filePath = join(uiDir, pathname === '/' ? 'index.html' : pathname);
+    if (!existsSync(filePath)) {
+      filePath = join(uiDir, 'index.html');
+    }
+    serveStatic(res, filePath);
+  });
+
+  const closeFn = () => server.close();
+
+  return new Promise((resolve, reject) => {
+    // When node --watch restarts the process, the old one may still hold the port
+    // briefly. Retry on the same port instead of falling back to a random one.
+    let retries = 0;
+    const maxRetries = 30;
+
+    const onError = (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && retries < maxRetries) {
+        retries++;
+        server.close();
+        setTimeout(() => server.listen(port), 500);
+      } else {
+        reject(err);
+      }
+    };
+
+    server.on('error', onError);
+    server.on('listening', () => {
+      const addr = server.address();
+      if (addr && typeof addr !== 'string') {
+        resolve({ port: addr.port, close: closeFn });
+      }
+    });
+
+    server.listen(port);
+  });
+}

package/packages/cli/src/session.ts

@@ -0,0 +1,48 @@
+import { randomUUID } from 'node:crypto';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getHeadHash, getDiffityDir } from '@diffity/git';
+import { getDb } from './db.js';
+
+export interface Session {
+  id: string;
+  ref: string;
+  headHash: string;
+}
+
+function sessionFilePath(): string {
+  return join(getDiffityDir(), 'current-session');
+}
+
+export function findOrCreateSession(ref: string): Session {
+  const db = getDb();
+  const headHash = getHeadHash();
+
+  const existing = db.prepare(
+    'SELECT id, ref, head_hash FROM review_sessions WHERE ref = ? AND head_hash = ?'
+  ).get(ref, headHash) as { id: string; ref: string; head_hash: string } | undefined;
+
+  if (existing) {
+    const session: Session = { id: existing.id, ref: existing.ref, headHash: existing.head_hash };
+    writeFileSync(sessionFilePath(), JSON.stringify(session));
+    return session;
+  }
+
+  const id = randomUUID();
+  db.prepare(
+    'INSERT INTO review_sessions (id, ref, head_hash) VALUES (?, ?, ?)'
+  ).run(id, ref, headHash);
+
+  const session: Session = { id, ref, headHash };
+  writeFileSync(sessionFilePath(), JSON.stringify(session));
+  return session;
+}
+
+export function getCurrentSession(): Session | null {
+  try {
+    const raw = readFileSync(sessionFilePath(), 'utf-8');
+    return JSON.parse(raw) as Session;
+  } catch {
+    return null;
+  }
+}

package/packages/cli/src/threads.ts

@@ -0,0 +1,238 @@
+import { randomUUID } from 'node:crypto';
+import { getDb } from './db.js';
+
+export interface ThreadAuthor {
+  name: string;
+  type: 'user' | 'agent';
+}
+
+export interface ThreadComment {
+  id: string;
+  author: ThreadAuthor;
+  body: string;
+  createdAt: string;
+}
+
+export type ThreadStatus = 'open' | 'resolved' | 'dismissed';
+
+export interface Thread {
+  id: string;
+  sessionId: string;
+  filePath: string;
+  side: string;
+  startLine: number;
+  endLine: number;
+  status: ThreadStatus;
+  anchorContent: string | null;
+  createdAt: string;
+  updatedAt: string;
+  comments: ThreadComment[];
+}
+
+interface ThreadRow {
+  id: string;
+  session_id: string;
+  file_path: string;
+  side: string;
+  start_line: number;
+  end_line: number;
+  status: string;
+  anchor_content: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface CommentRow {
+  id: string;
+  thread_id: string;
+  author_name: string;
+  author_type: string;
+  body: string;
+  created_at: string;
+}
+
+function rowToThread(row: ThreadRow, comments: ThreadComment[]): Thread {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    filePath: row.file_path,
+    side: row.side,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    status: row.status as ThreadStatus,
+    anchorContent: row.anchor_content,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    comments,
+  };
+}
+
+function rowToComment(row: CommentRow): ThreadComment {
+  return {
+    id: row.id,
+    author: { name: row.author_name, type: row.author_type as 'user' | 'agent' },
+    body: row.body,
+    createdAt: row.created_at,
+  };
+}
+
+function getCommentsForThreads(threadIds: string[]): Map<string, ThreadComment[]> {
+  if (threadIds.length === 0) {
+    return new Map();
+  }
+  const db = getDb();
+  const placeholders = threadIds.map(() => '?').join(', ');
+  const rows = db.prepare(
+    `SELECT * FROM comments WHERE thread_id IN (${placeholders}) ORDER BY created_at ASC`
+  ).all(...threadIds) as CommentRow[];
+
+  const map = new Map<string, ThreadComment[]>();
+  for (const row of rows) {
+    const comments = map.get(row.thread_id) ?? [];
+    comments.push(rowToComment(row));
+    map.set(row.thread_id, comments);
+  }
+  return map;
+}
+
+function getCommentsForThread(threadId: string): ThreadComment[] {
+  const map = getCommentsForThreads([threadId]);
+  return map.get(threadId) ?? [];
+}
+
+export function createThread(
+  sessionId: string,
+  filePath: string,
+  side: string,
+  startLine: number,
+  endLine: number,
+  body: string,
+  author: ThreadAuthor,
+  anchorContent?: string,
+): Thread {
+  const db = getDb();
+  const threadId = randomUUID();
+  const commentId = randomUUID();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'INSERT INTO comment_threads (id, session_id, file_path, side, start_line, end_line, anchor_content, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
+  ).run(threadId, sessionId, filePath, side, startLine, endLine, anchorContent ?? null, now, now);
+
+  db.prepare(
+    'INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(commentId, threadId, author.name, author.type, body, now);
+
+  return {
+    id: threadId,
+    sessionId,
+    filePath,
+    side,
+    startLine,
+    endLine,
+    status: 'open',
+    anchorContent: anchorContent ?? null,
+    createdAt: now,
+    updatedAt: now,
+    comments: [{
+      id: commentId,
+      author,
+      body,
+      createdAt: now,
+    }],
+  };
+}
+
+export function getThreadsForSession(sessionId: string, status?: ThreadStatus): Thread[] {
+  const db = getDb();
+  let rows: ThreadRow[];
+  if (status) {
+    rows = db.prepare(
+      'SELECT * FROM comment_threads WHERE session_id = ? AND status = ? ORDER BY created_at ASC'
+    ).all(sessionId, status) as ThreadRow[];
+  } else {
+    rows = db.prepare(
+      'SELECT * FROM comment_threads WHERE session_id = ? ORDER BY created_at ASC'
+    ).all(sessionId) as ThreadRow[];
+  }
+
+  const commentsByThread = getCommentsForThreads(rows.map(r => r.id));
+  return rows.map(row => rowToThread(row, commentsByThread.get(row.id) ?? []));
+}
+
+export function getThread(idOrPrefix: string): Thread | null {
+  const db = getDb();
+  let row = db.prepare('SELECT * FROM comment_threads WHERE id = ?').get(idOrPrefix) as ThreadRow | undefined;
+
+  if (!row && idOrPrefix.length >= 8) {
+    row = db.prepare('SELECT * FROM comment_threads WHERE id LIKE ?').get(idOrPrefix + '%') as ThreadRow | undefined;
+  }
+
+  if (!row) {
+    return null;
+  }
+
+  return rowToThread(row, getCommentsForThread(row.id));
+}
+
+export function addReply(threadId: string, body: string, author: ThreadAuthor): ThreadComment {
+  const db = getDb();
+  const commentId = randomUUID();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+  ).run(commentId, threadId, author.name, author.type, body, now);
+
+  db.prepare(
+    'UPDATE comment_threads SET updated_at = ? WHERE id = ?'
+  ).run(now, threadId);
+
+  return {
+    id: commentId,
+    author,
+    body,
+    createdAt: now,
+  };
+}
+
+export function updateThreadStatus(threadId: string, status: ThreadStatus, summaryBody?: string, summaryAuthor?: ThreadAuthor): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+
+  db.prepare(
+    'UPDATE comment_threads SET status = ?, updated_at = ? WHERE id = ?'
+  ).run(status, now, threadId);
+
+  if (summaryBody && summaryAuthor) {
+    const commentId = randomUUID();
+    db.prepare(
+      'INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)'
+    ).run(commentId, threadId, summaryAuthor.name, summaryAuthor.type, summaryBody, now);
+  }
+}
+
+export function deleteThread(threadId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM comment_threads WHERE id = ?').run(threadId);
+}
+
+export function deleteAllThreadsForSession(sessionId: string): void {
+  const db = getDb();
+  db.prepare('DELETE FROM comment_threads WHERE session_id = ?').run(sessionId);
+}
+
+export function deleteComment(commentId: string): void {
+  const db = getDb();
+  const comment = db.prepare('SELECT thread_id FROM comments WHERE id = ?').get(commentId) as { thread_id: string } | undefined;
+  if (!comment) {
+    return;
+  }
+
+  db.prepare('DELETE FROM comments WHERE id = ?').run(commentId);
+
+  const remaining = db.prepare('SELECT COUNT(*) as count FROM comments WHERE thread_id = ?').get(comment.thread_id) as { count: number };
+  if (remaining.count === 0) {
+    db.prepare('DELETE FROM comment_threads WHERE id = ?').run(comment.thread_id);
+  }
+}

package/packages/cli/tsconfig.json

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

package/packages/git/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@diffity/git",
+  "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"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.9.3"
+  }
+}