diffprism 0.2.0

package/dist/chunk-AUPKNXCS.js

@@ -0,0 +1,597 @@
+// packages/core/src/pipeline.ts
+import http from "http";
+import fs from "fs";
+import path2 from "path";
+import getPort from "get-port";
+import open from "open";
+import { fileURLToPath } from "url";
+
+// packages/git/src/local.ts
+import { execSync } from "child_process";
+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;
+  switch (ref) {
+    case "staged":
+      command = "git diff --staged --no-color";
+      break;
+    case "unstaged":
+      command = "git diff --no-color";
+      break;
+    default:
+      command = `git diff --no-color ${ref}`;
+      break;
+  }
+  try {
+    const output = execSync(command, {
+      cwd,
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+      // 50 MB
+    });
+    return output;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`git diff failed: ${message}`);
+  }
+}
+
+// packages/git/src/parser.ts
+import path 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 = path.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) {
+  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 };
+}
+
+// packages/analysis/src/deterministic.ts
+function categorizeFiles(files) {
+  const notable = files.map((f) => ({
+    file: f.path,
+    description: `${f.status} (${f.language || "unknown"}) +${f.additions} -${f.deletions}`,
+    reason: "Uncategorized in M0 \u2014 placed in notable by default"
+  }));
+  return {
+    critical: [],
+    notable,
+    mechanical: []
+  };
+}
+function computeFileStats(files) {
+  return files.map((f) => ({
+    path: f.path,
+    language: f.language,
+    status: f.status,
+    additions: f.additions,
+    deletions: f.deletions
+  }));
+}
+function detectAffectedModules(files) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const lastSlash = f.path.lastIndexOf("/");
+    if (lastSlash > 0) {
+      dirs.add(f.path.slice(0, lastSlash));
+    }
+  }
+  return [...dirs].sort();
+}
+var TEST_PATTERNS = [
+  /\.test\./,
+  /\.spec\./,
+  /\/__tests__\//,
+  /\/test\//
+];
+function detectAffectedTests(files) {
+  return files.filter((f) => TEST_PATTERNS.some((re) => re.test(f.path))).map((f) => f.path);
+}
+var DEPENDENCY_FIELDS = [
+  '"dependencies"',
+  '"devDependencies"',
+  '"peerDependencies"',
+  '"optionalDependencies"'
+];
+function detectNewDependencies(files) {
+  const deps = /* @__PURE__ */ new Set();
+  const packageFiles = files.filter(
+    (f) => f.path.endsWith("package.json") && f.hunks.length > 0
+  );
+  for (const file of packageFiles) {
+    for (const hunk of file.hunks) {
+      let inDependencyBlock = false;
+      for (const change of hunk.changes) {
+        const line = change.content;
+        if (DEPENDENCY_FIELDS.some((field) => line.includes(field))) {
+          inDependencyBlock = true;
+          continue;
+        }
+        if (inDependencyBlock && line.trim().startsWith("}")) {
+          inDependencyBlock = false;
+          continue;
+        }
+        if (change.type === "add" && inDependencyBlock) {
+          const match = line.match(/"([^"]+)"\s*:/);
+          if (match) {
+            deps.add(match[1]);
+          }
+        }
+      }
+    }
+  }
+  return [...deps].sort();
+}
+function generateSummary(files) {
+  const totalFiles = files.length;
+  const counts = {
+    added: 0,
+    modified: 0,
+    deleted: 0,
+    renamed: 0
+  };
+  let totalAdditions = 0;
+  let totalDeletions = 0;
+  for (const f of files) {
+    counts[f.status]++;
+    totalAdditions += f.additions;
+    totalDeletions += f.deletions;
+  }
+  const parts = [];
+  if (counts.modified > 0) parts.push(`${counts.modified} modified`);
+  if (counts.added > 0) parts.push(`${counts.added} added`);
+  if (counts.deleted > 0) parts.push(`${counts.deleted} deleted`);
+  if (counts.renamed > 0) parts.push(`${counts.renamed} renamed`);
+  const breakdown = parts.length > 0 ? `: ${parts.join(", ")}` : "";
+  return `${totalFiles} files changed${breakdown} (+${totalAdditions} -${totalDeletions})`;
+}
+
+// packages/analysis/src/index.ts
+function analyze(diffSet) {
+  const { files } = diffSet;
+  const triage = categorizeFiles(files);
+  const fileStats = computeFileStats(files);
+  const affectedModules = detectAffectedModules(files);
+  const affectedTests = detectAffectedTests(files);
+  const newDependencies = detectNewDependencies(files);
+  const summary = generateSummary(files);
+  return {
+    summary,
+    triage,
+    impact: {
+      affectedModules,
+      affectedTests,
+      publicApiChanges: false,
+      breakingChanges: [],
+      newDependencies
+    },
+    verification: {
+      testsPass: null,
+      typeCheck: null,
+      lintClean: null
+    },
+    fileStats
+  };
+}
+
+// packages/core/src/ws-bridge.ts
+import { WebSocketServer, WebSocket } from "ws";
+function createWsBridge(port) {
+  const wss = new WebSocketServer({ port });
+  let client = null;
+  let resultResolve = null;
+  let resultReject = null;
+  let pendingInit = null;
+  let initPayload = null;
+  let closeTimer = null;
+  wss.on("connection", (ws) => {
+    if (closeTimer) {
+      clearTimeout(closeTimer);
+      closeTimer = null;
+    }
+    client = ws;
+    const payload = pendingInit ?? initPayload;
+    if (payload) {
+      const msg = {
+        type: "review:init",
+        payload
+      };
+      ws.send(JSON.stringify(msg));
+      pendingInit = null;
+    }
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "review:submit" && resultResolve) {
+          resultResolve(msg.payload);
+          resultResolve = null;
+          resultReject = null;
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      client = null;
+      if (resultReject) {
+        closeTimer = setTimeout(() => {
+          if (resultReject) {
+            resultReject(new Error("Browser closed before review was submitted"));
+            resultResolve = null;
+            resultReject = null;
+          }
+        }, 2e3);
+      }
+    });
+  });
+  return {
+    port,
+    sendInit(payload) {
+      initPayload = payload;
+      if (client && client.readyState === WebSocket.OPEN) {
+        const msg = {
+          type: "review:init",
+          payload
+        };
+        client.send(JSON.stringify(msg));
+      } else {
+        pendingInit = payload;
+      }
+    },
+    waitForResult() {
+      return new Promise((resolve, reject) => {
+        resultResolve = resolve;
+        resultReject = reject;
+      });
+    },
+    close() {
+      for (const ws of wss.clients) {
+        ws.close();
+      }
+      wss.close();
+    }
+  };
+}
+
+// packages/core/src/review-manager.ts
+var sessions = /* @__PURE__ */ new Map();
+var idCounter = 0;
+function createSession(options) {
+  const id = `review-${Date.now()}-${++idCounter}`;
+  const session = {
+    id,
+    options,
+    status: "pending",
+    createdAt: Date.now()
+  };
+  sessions.set(id, session);
+  return session;
+}
+function updateSession(id, update) {
+  const session = sessions.get(id);
+  if (session) {
+    Object.assign(session, update);
+  }
+}
+
+// packages/core/src/pipeline.ts
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function resolveUiDist() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = path2.dirname(thisFile);
+  const publishedUiDist = path2.resolve(thisDir, "..", "ui-dist");
+  if (fs.existsSync(path2.join(publishedUiDist, "index.html"))) {
+    return publishedUiDist;
+  }
+  const workspaceRoot = path2.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path2.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs.existsSync(path2.join(devUiDist, "index.html"))) {
+    return devUiDist;
+  }
+  throw new Error(
+    "Could not find built UI. Run 'pnpm -F @diffprism/ui build' first."
+  );
+}
+function createStaticServer(distPath, port) {
+  const server = http.createServer((req, res) => {
+    const urlPath = req.url?.split("?")[0] ?? "/";
+    let filePath = path2.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs.existsSync(filePath)) {
+      filePath = path2.join(distPath, "index.html");
+    }
+    const ext = path2.extname(filePath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    try {
+      const content = fs.readFileSync(filePath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+    } catch {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(port, () => resolve(server));
+  });
+}
+async function startReview(options) {
+  const { diffRef, title, description, reasoning, cwd, silent } = options;
+  const { diffSet, rawDiff } = getDiff(diffRef, { cwd });
+  if (diffSet.files.length === 0) {
+    if (!silent) {
+      console.log("No changes to review.");
+    }
+    return {
+      decision: "approved",
+      comments: [],
+      summary: "No changes to review."
+    };
+  }
+  const briefing = analyze(diffSet);
+  const session = createSession(options);
+  updateSession(session.id, { status: "in_progress" });
+  const [wsPort, httpPort] = await Promise.all([
+    getPort(),
+    getPort()
+  ]);
+  const bridge = createWsBridge(wsPort);
+  const uiDist = resolveUiDist();
+  let httpServer = null;
+  try {
+    httpServer = await createStaticServer(uiDist, httpPort);
+    const url = `http://localhost:${httpPort}?wsPort=${wsPort}&reviewId=${session.id}`;
+    if (!silent) {
+      console.log(`
+DiffPrism Review: ${title ?? briefing.summary}`);
+      console.log(`Opening browser at ${url}
+`);
+    }
+    await open(url);
+    const initPayload = {
+      reviewId: session.id,
+      diffSet,
+      rawDiff,
+      briefing,
+      metadata: { title, description, reasoning }
+    };
+    bridge.sendInit(initPayload);
+    const result = await bridge.waitForResult();
+    updateSession(session.id, { status: "completed", result });
+    return result;
+  } finally {
+    bridge.close();
+    if (httpServer) {
+      httpServer.close();
+    }
+  }
+}
+
+export {
+  startReview
+};

package/dist/mcp-server.js

@@ -0,0 +1,63 @@
+import {
+  startReview
+} from "./chunk-AUPKNXCS.js";
+
+// packages/mcp-server/src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+async function startMcpServer() {
+  const server = new McpServer({
+    name: "diffprism",
+    version: "0.0.1"
+  });
+  server.tool(
+    "open_review",
+    "Open a browser-based code review for local git changes. Blocks until the engineer submits their review decision.",
+    {
+      diff_ref: z.string().describe(
+        'Git diff reference: "staged", "unstaged", or a ref range like "HEAD~3..HEAD"'
+      ),
+      title: z.string().optional().describe("Title for the review"),
+      description: z.string().optional().describe("Description of the changes"),
+      reasoning: z.string().optional().describe("Agent reasoning about why these changes were made")
+    },
+    async ({ diff_ref, title, description, reasoning }) => {
+      try {
+        const result = await startReview({
+          diffRef: diff_ref,
+          title,
+          description,
+          reasoning,
+          cwd: process.cwd(),
+          silent: true
+          // Suppress stdout — MCP uses stdio
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+export {
+  startMcpServer
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "diffprism",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Local-first code review tool for agent-generated code changes",
+  "bin": {
+    "diffprism": "dist/bin.js"
+  },
+  "files": [
+    "dist/",
+    "ui-dist/"
+  ],
+  "scripts": {
+    "build": "pnpm -r run build && pnpm run bundle",
+    "bundle": "tsup && rm -rf ui-dist && cp -r packages/ui/dist ui-dist",
+    "dev": "pnpm -r run dev",
+    "lint": "pnpm -r run lint",
+    "test": "pnpm -r run test",
+    "cli": "pnpm -F @diffprism/ui build && tsx cli/src/index.ts",
+    "prepublishOnly": "pnpm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "open": "^10.1.0",
+    "get-port": "^7.1.0",
+    "commander": "^13.0.0",
+    "@modelcontextprotocol/sdk": "^1.4.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}