diffprism 0.34.1 → 0.36.0

package/dist/chunk-QGWYCEJN.js

@@ -0,0 +1,448 @@
+// packages/git/src/local.ts
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import path from "path";
+function getGitDiff(ref, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    execSync("git --version", { cwd, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "git is not available. Please install git and make sure it is on your PATH."
+    );
+  }
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
+  } catch {
+    throw new Error(
+      `The directory "${cwd}" is not inside a git repository.`
+    );
+  }
+  let command;
+  let includeUntracked = false;
+  switch (ref) {
+    case "staged":
+      command = "git diff --staged --no-color";
+      break;
+    case "unstaged":
+      command = "git diff --no-color";
+      includeUntracked = true;
+      break;
+    case "all":
+      command = "git diff HEAD --no-color";
+      includeUntracked = true;
+      break;
+    default:
+      command = `git diff --no-color ${ref}`;
+      break;
+  }
+  let output;
+  try {
+    output = execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+      // 50 MB
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`git diff failed: ${message}`);
+  }
+  if (includeUntracked) {
+    output += getUntrackedDiffs(cwd);
+  }
+  return output;
+}
+function getCurrentBranch(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function listBranches(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    const output = execSync(
+      "git branch -a --format='%(refname:short)' --sort=-committerdate",
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!output) return { local: [], remote: [] };
+    const local = [];
+    const remote = [];
+    for (const line of output.split("\n")) {
+      const name = line.trim();
+      if (!name) continue;
+      if (name.endsWith("/HEAD")) continue;
+      if (name.includes("/")) {
+        remote.push(name);
+      } else {
+        local.push(name);
+      }
+    }
+    return { local, remote };
+  } catch {
+    return { local: [], remote: [] };
+  }
+}
+function listCommits(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const limit = options?.limit ?? 50;
+  try {
+    const output = execSync(
+      `git log --format='%H<<>>%h<<>>%s<<>>%an<<>>%aI' -n ${limit}`,
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!output) return [];
+    const commits = [];
+    for (const line of output.split("\n")) {
+      const parts = line.split("<<>>");
+      if (parts.length < 5) continue;
+      commits.push({
+        hash: parts[0],
+        shortHash: parts[1],
+        subject: parts[2],
+        author: parts[3],
+        date: parts[4]
+      });
+    }
+    return commits;
+  } catch {
+    return [];
+  }
+}
+function detectWorktree(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  try {
+    const gitDir = execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const resolvedGitDir = path.resolve(cwd, gitDir);
+    const resolvedCommonDir = path.resolve(cwd, gitCommonDir);
+    const isWorktree = resolvedGitDir !== resolvedCommonDir;
+    if (!isWorktree) {
+      return { isWorktree: false };
+    }
+    const worktreePath = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const mainWorktreePath = path.dirname(resolvedCommonDir);
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return {
+      isWorktree: true,
+      worktreePath,
+      mainWorktreePath,
+      branch: branch === "HEAD" ? void 0 : branch
+    };
+  } catch {
+    return { isWorktree: false };
+  }
+}
+function getUntrackedDiffs(cwd) {
+  let untrackedList;
+  try {
+    untrackedList = execSync(
+      "git ls-files --others --exclude-standard",
+      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+  } catch {
+    return "";
+  }
+  if (!untrackedList) return "";
+  const files = untrackedList.split("\n");
+  let result = "";
+  for (const file of files) {
+    const absPath = path.resolve(cwd, file);
+    let content;
+    try {
+      content = readFileSync(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    const hasTrailingNewline = content.length > 0 && content[content.length - 1] === "\n";
+    const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+    result += `diff --git a/${file} b/${file}
+`;
+    result += "new file mode 100644\n";
+    result += "--- /dev/null\n";
+    result += `+++ b/${file}
+`;
+    result += `@@ -0,0 +1,${contentLines.length} @@
+`;
+    for (const line of contentLines) {
+      result += `+${line}
+`;
+    }
+    if (!hasTrailingNewline) {
+      result += "\\n";
+    }
+  }
+  return result;
+}
+
+// packages/git/src/parser.ts
+import path2 from "path";
+var EXTENSION_MAP = {
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  java: "java",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  hpp: "cpp",
+  cc: "cpp",
+  cs: "csharp",
+  md: "markdown",
+  json: "json",
+  yaml: "yaml",
+  yml: "yaml",
+  html: "html",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell"
+};
+var FILENAME_MAP = {
+  Dockerfile: "dockerfile",
+  Makefile: "makefile"
+};
+function detectLanguage(filePath) {
+  const basename = path2.basename(filePath);
+  if (FILENAME_MAP[basename]) {
+    return FILENAME_MAP[basename];
+  }
+  const ext = basename.includes(".") ? basename.slice(basename.lastIndexOf(".") + 1) : "";
+  return EXTENSION_MAP[ext] ?? "text";
+}
+function stripPrefix(raw) {
+  if (raw === "/dev/null") return raw;
+  return raw.replace(/^[ab]\//, "");
+}
+function parseDiff(rawDiff, baseRef, headRef) {
+  if (!rawDiff.trim()) {
+    return { baseRef, headRef, files: [] };
+  }
+  const files = [];
+  const lines = rawDiff.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    if (!lines[i].startsWith("diff --git ")) {
+      i++;
+      continue;
+    }
+    let oldPath;
+    let newPath;
+    let status = "modified";
+    let binary = false;
+    let renameFrom;
+    let renameTo;
+    const diffLine = lines[i];
+    const gitPathMatch = diffLine.match(/^diff --git a\/(.*) b\/(.*)$/);
+    if (gitPathMatch) {
+      oldPath = gitPathMatch[1];
+      newPath = gitPathMatch[2];
+    }
+    i++;
+    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
+      const line = lines[i];
+      if (line.startsWith("--- ")) {
+        const raw = line.slice(4);
+        oldPath = stripPrefix(raw);
+        if (raw === "/dev/null") {
+          status = "added";
+        }
+      } else if (line.startsWith("+++ ")) {
+        const raw = line.slice(4);
+        newPath = stripPrefix(raw);
+        if (raw === "/dev/null") {
+          status = "deleted";
+        }
+      } else if (line.startsWith("rename from ")) {
+        renameFrom = line.slice("rename from ".length);
+        status = "renamed";
+      } else if (line.startsWith("rename to ")) {
+        renameTo = line.slice("rename to ".length);
+        status = "renamed";
+      } else if (line.startsWith("new file mode")) {
+        status = "added";
+      } else if (line.startsWith("deleted file mode")) {
+        status = "deleted";
+      } else if (line.startsWith("Binary files") || line === "GIT binary patch") {
+        binary = true;
+        if (line.includes("/dev/null") && line.includes(" and b/")) {
+          status = "added";
+        } else if (line.includes("a/") && line.includes("/dev/null")) {
+          status = "deleted";
+        }
+      }
+      if (line.startsWith("@@ ")) {
+        break;
+      }
+      i++;
+    }
+    const filePath = status === "deleted" ? oldPath ?? newPath ?? "unknown" : newPath ?? oldPath ?? "unknown";
+    const fileOldPath = status === "renamed" ? renameFrom ?? oldPath : oldPath;
+    const hunks = [];
+    let additions = 0;
+    let deletions = 0;
+    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
+      const line = lines[i];
+      if (line.startsWith("@@ ")) {
+        const hunkMatch = line.match(
+          /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+        );
+        if (!hunkMatch) {
+          i++;
+          continue;
+        }
+        const oldStart = parseInt(hunkMatch[1], 10);
+        const oldLines = hunkMatch[2] !== void 0 ? parseInt(hunkMatch[2], 10) : 1;
+        const newStart = parseInt(hunkMatch[3], 10);
+        const newLines = hunkMatch[4] !== void 0 ? parseInt(hunkMatch[4], 10) : 1;
+        const changes = [];
+        let oldLineNum = oldStart;
+        let newLineNum = newStart;
+        i++;
+        while (i < lines.length) {
+          const changeLine = lines[i];
+          if (changeLine.startsWith("@@ ") || changeLine.startsWith("diff --git ")) {
+            break;
+          }
+          if (changeLine.startsWith("\")) {
+            i++;
+            continue;
+          }
+          if (changeLine.startsWith("+")) {
+            changes.push({
+              type: "add",
+              lineNumber: newLineNum,
+              content: changeLine.slice(1)
+            });
+            newLineNum++;
+            additions++;
+          } else if (changeLine.startsWith("-")) {
+            changes.push({
+              type: "delete",
+              lineNumber: oldLineNum,
+              content: changeLine.slice(1)
+            });
+            oldLineNum++;
+            deletions++;
+          } else {
+            changes.push({
+              type: "context",
+              lineNumber: newLineNum,
+              content: changeLine.length > 0 ? changeLine.slice(1) : ""
+            });
+            oldLineNum++;
+            newLineNum++;
+          }
+          i++;
+        }
+        hunks.push({ oldStart, oldLines, newStart, newLines, changes });
+      } else {
+        i++;
+      }
+    }
+    const diffFile = {
+      path: filePath,
+      status,
+      hunks,
+      language: detectLanguage(filePath),
+      binary,
+      additions,
+      deletions
+    };
+    if (status === "renamed" && fileOldPath) {
+      diffFile.oldPath = fileOldPath;
+    }
+    files.push(diffFile);
+  }
+  return { baseRef, headRef, files };
+}
+
+// packages/git/src/index.ts
+function getDiff(ref, options) {
+  if (ref === "working-copy") {
+    return getWorkingCopyDiff(options);
+  }
+  const rawDiff = getGitDiff(ref, options);
+  let baseRef;
+  let headRef;
+  if (ref === "staged") {
+    baseRef = "HEAD";
+    headRef = "staged";
+  } else if (ref === "unstaged") {
+    baseRef = "staged";
+    headRef = "working tree";
+  } else if (ref.includes("..")) {
+    const [base, head] = ref.split("..");
+    baseRef = base;
+    headRef = head;
+  } else {
+    baseRef = ref;
+    headRef = "HEAD";
+  }
+  const diffSet = parseDiff(rawDiff, baseRef, headRef);
+  return { diffSet, rawDiff };
+}
+function getWorkingCopyDiff(options) {
+  const stagedRaw = getGitDiff("staged", options);
+  const unstagedRaw = getGitDiff("unstaged", options);
+  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
+  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
+  const stagedFiles = stagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "staged"
+  }));
+  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
+    ...f,
+    stage: "unstaged"
+  }));
+  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
+  return {
+    diffSet: {
+      baseRef: "HEAD",
+      headRef: "working tree",
+      files: [...stagedFiles, ...unstagedFiles]
+    },
+    rawDiff
+  };
+}
+
+export {
+  getGitDiff,
+  getCurrentBranch,
+  listBranches,
+  listCommits,
+  detectWorktree,
+  parseDiff,
+  getDiff
+};

package/dist/chunk-UYZ3A2PB.js

@@ -0,0 +1,231 @@
+import {
+  ensureServer,
+  submitReviewToServer
+} from "./chunk-ITPHDFOS.js";
+import {
+  parseDiff
+} from "./chunk-QGWYCEJN.js";
+import {
+  analyze
+} from "./chunk-DHCVZGHE.js";
+
+// cli/src/demo-data/sample-diff.ts
+var sampleDiff = `diff --git a/src/middleware/auth.ts b/src/middleware/auth.ts
+new file mode 100644
+index 0000000..a1b2c3d
+--- /dev/null
++++ b/src/middleware/auth.ts
+@@ -0,0 +1,52 @@
++import jwt from "jsonwebtoken";
++import type { Request, Response, NextFunction } from "express";
++
++const JWT_SECRET = process.env.JWT_SECRET ?? "dev-secret";
++const TOKEN_EXPIRY = "24h";
++
++export interface AuthPayload {
++  userId: string;
++  email: string;
++  role: "admin" | "user" | "viewer";
++}
++
++/**
++ * Verify JWT token from Authorization header.
++ * Attaches decoded payload to req.auth on success.
++ */
++export function authenticate(
++  req: Request,
++  res: Response,
++  next: NextFunction,
++): void {
++  const header = req.headers.authorization;
++
++  if (!header?.startsWith("Bearer ")) {
++    res.status(401).json({ error: "Missing or invalid Authorization header" });
++    return;
++  }
++
++  const token = header.slice(7);
++
++  try {
++    const decoded = jwt.verify(token, JWT_SECRET) as AuthPayload;
++    (req as Request & { auth: AuthPayload }).auth = decoded;
++    next();
++  } catch (err) {
++    if (err instanceof jwt.TokenExpiredError) {
++      res.status(401).json({ error: "Token expired" });
++      return;
++    }
++    // TODO: Add refresh token support
++    console.log("Auth error:", err);
++    res.status(401).json({ error: "Invalid token" });
++  }
++}
++
++/**
++ * Generate a signed JWT for the given user payload.
++ */
++export function generateToken(payload: AuthPayload): string {
++  return jwt.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
++}
+diff --git a/src/routes/users.ts b/src/routes/users.ts
+index d4e5f6a..b7c8d9e 100644
+--- a/src/routes/users.ts
++++ b/src/routes/users.ts
+@@ -1,6 +1,7 @@
+ import { Router } from "express";
+ import { db } from "../db/client.js";
+ import { validateBody } from "../util/validate.js";
++import { authenticate, type AuthPayload } from "../middleware/auth.js";
+
+ const router = Router();
+
+@@ -12,6 +13,22 @@
+   res.json(users);
+ });
+
++// Protected routes \u2014 require valid JWT
++router.use(authenticate);
++
++router.get("/me", (req, res) => {
++  const auth = (req as Request & { auth: AuthPayload }).auth;
++  const user = db.users.findById(auth.userId);
++
++  if (!user) {
++    res.status(404).json({ error: "User not found" });
++    return;
++  }
++
++  const { passwordHash, ...profile } = user;
++  res.json(profile);
++});
++
+ router.post("/", validateBody("createUser"), async (req, res) => {
+   const { email, name, role } = req.body;
+
+@@ -22,7 +39,7 @@
+     return;
+   }
+
+-  const user = await db.users.create({ email, name, role });
++  const user = await db.users.create({ email, name, role: role ?? "user" });
+   res.status(201).json(user);
+ });
+
+diff --git a/src/middleware/__tests__/auth.test.ts b/src/middleware/__tests__/auth.test.ts
+new file mode 100644
+index 0000000..e1f2a3b
+--- /dev/null
++++ b/src/middleware/__tests__/auth.test.ts
+@@ -0,0 +1,64 @@
++import { describe, it, expect, vi, beforeEach } from "vitest";
++import { authenticate, generateToken } from "../auth.js";
++
++function createMockReq(authHeader?: string) {
++  return {
++    headers: { authorization: authHeader },
++  } as unknown as Request;
++}
++
++function createMockRes() {
++  const res = {
++    status: vi.fn().mockReturnThis(),
++    json: vi.fn().mockReturnThis(),
++  };
++  return res as unknown as Response;
++}
++
++describe("authenticate middleware", () => {
++  const validPayload = { userId: "u1", email: "test@example.com", role: "user" as const };
++
++  it("rejects requests without Authorization header", () => {
++    const req = createMockReq();
++    const res = createMockRes();
++    const next = vi.fn();
++
++    authenticate(req as any, res as any, next);
++
++    expect(res.status).toHaveBeenCalledWith(401);
++    expect(next).not.toHaveBeenCalled();
++  });
++
++  it("rejects requests with invalid token", () => {
++    const req = createMockReq("Bearer invalid-token");
++    const res = createMockRes();
++    const next = vi.fn();
++
++    authenticate(req as any, res as any, next);
++
++    expect(res.status).toHaveBeenCalledWith(401);
++    expect(next).not.toHaveBeenCalled();
++  });
++
++  it("passes valid tokens and attaches auth payload", () => {
++    const token = generateToken(validPayload);
++    const req = createMockReq(\`Bearer \${token}\`);
++    const res = createMockRes();
++    const next = vi.fn();
++
++    authenticate(req as any, res as any, next);
++
++    expect(next).toHaveBeenCalled();
++    expect((req as any).auth).toMatchObject({
++      userId: "u1",
++      email: "test@example.com",
++    });
++  });
++});
++
++describe("generateToken", () => {
++  it("returns a string token", () => {
++    const token = generateToken({ userId: "u1", email: "a@b.com", role: "admin" });
++    expect(typeof token).toBe("string");
++    expect(token.split(".")).toHaveLength(3); // JWT has 3 parts
++  });
++});
+`;
+
+// cli/src/commands/demo.ts
+async function demo(flags) {
+  try {
+    console.log("Starting DiffPrism demo...\n");
+    const diffSet = parseDiff(sampleDiff, "main", "feature/add-auth");
+    const briefing = analyze(diffSet);
+    console.log(
+      `${diffSet.files.length} files, +${diffSet.files.reduce((s, f) => s + f.additions, 0)} -${diffSet.files.reduce((s, f) => s + f.deletions, 0)}`
+    );
+    const payload = {
+      reviewId: "",
+      diffSet,
+      rawDiff: sampleDiff,
+      briefing,
+      metadata: {
+        title: "Add user authentication middleware",
+        reasoning: "Added JWT-based auth middleware to protect API routes. Included token validation, error handling for expired tokens, and unit tests for the middleware.",
+        currentBranch: "feature/add-auth"
+      }
+    };
+    const serverInfo = await ensureServer({ dev: flags.dev });
+    const { result } = await submitReviewToServer(serverInfo, "demo", {
+      injectedPayload: payload,
+      projectPath: "demo",
+      diffRef: "demo"
+    });
+    console.log(`
+Review submitted: ${result.decision}`);
+    if (result.comments.length > 0) {
+      console.log(`${result.comments.length} comment(s)`);
+    }
+    console.log("\nNext steps:");
+    console.log("  Run `npx diffprism setup` to configure for Claude Code");
+    console.log("  Run `npx diffprism review` in a git repo to review real changes\n");
+    process.exit(0);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+
+export {
+  demo
+};

package/dist/demo-JH5YOKTZ.js

@@ -0,0 +1,10 @@
+import {
+  demo
+} from "./chunk-UYZ3A2PB.js";
+import "./chunk-ITPHDFOS.js";
+import "./chunk-QGWYCEJN.js";
+import "./chunk-DHCVZGHE.js";
+import "./chunk-JSBRDJBE.js";
+export {
+  demo
+};