diffity 0.1.0 → 0.1.2

package/packages/cli/src/server.ts

@@ -1,370 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,238 +0,0 @@
-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

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

package/packages/git/package.json

@@ -1,24 +0,0 @@
-{
-  "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"
-  }
-}