built-diff 0.1.0

package/dist/index.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawn } from "child_process";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join, dirname } from "path";
+import { serve } from "@hono/node-server";
+
+// src/server.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { serveStatic } from "@hono/node-server/serve-static";
+
+// src/comments.ts
+var commentStore = [];
+var nextCommentId = 1;
+var getComments = () => {
+  return commentStore;
+};
+var addComment = (data) => {
+  const comment = {
+    id: String(nextCommentId++),
+    filePath: data.filePath,
+    lineNumber: data.lineNumber,
+    side: data.side,
+    text: data.text,
+    timestamp: Date.now(),
+    delivered: false
+  };
+  commentStore.push(comment);
+  return comment;
+};
+var updateComment = (id, text) => {
+  const comment = commentStore.find((c) => c.id === id);
+  if (!comment)
+    return null;
+  comment.text = text;
+  comment.delivered = false;
+  return comment;
+};
+var deleteComment = (id) => {
+  const index = commentStore.findIndex((c) => c.id === id);
+  if (index === -1)
+    return false;
+  commentStore.splice(index, 1);
+  return true;
+};
+var getPendingComments = () => {
+  const pendingComments = commentStore.filter((comment) => !comment.delivered);
+  for (const comment of pendingComments) {
+    comment.delivered = true;
+  }
+  return pendingComments;
+};
+
+// src/git.ts
+import { execSync } from "child_process";
+var execGit = (command) => {
+  return execSync(command, { encoding: "utf-8" }).trim();
+};
+var getHeadSha = () => {
+  return execGit("git rev-parse HEAD");
+};
+var getBranch = () => {
+  return execGit("git rev-parse --abbrev-ref HEAD");
+};
+var isDirty = () => {
+  const statusOutput = execGit("git status --porcelain");
+  return statusOutput.length > 0;
+};
+var getDiff = (baseline) => {
+  try {
+    execGit("git add --intent-to-add -A");
+    const diffOutput = execGit(`git diff --no-ext-diff --no-color ${baseline}`);
+    execGit("git reset -q");
+    return diffOutput;
+  } catch {
+    return "";
+  }
+};
+var getStatus = () => {
+  return {
+    branch: getBranch(),
+    dirty: isDirty()
+  };
+};
+var commitAll = (message) => {
+  try {
+    execGit("git add -A");
+    execGit(`git commit -m ${JSON.stringify(message)}`);
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
+var pushToRemote = () => {
+  try {
+    execGit("git push");
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
+
+// src/constants.ts
+var SSE_KEEPALIVE_INTERVAL_MS = 15000;
+
+// src/server.ts
+var createApp = (baseline, staticDir) => {
+  const app = new Hono;
+  const connectedClients = new Set;
+  const broadcast = (event, data = "{}") => {
+    for (const sendToClient of connectedClients) {
+      sendToClient(event, data);
+    }
+  };
+  app.get("/api/comments", (context) => {
+    return context.json(getComments());
+  });
+  app.post("/api/comments", async (context) => {
+    const body = await context.req.json();
+    const comment = addComment(body);
+    broadcast("refresh");
+    return context.json(comment);
+  });
+  app.patch("/api/comments/:id", async (context) => {
+    const { text } = await context.req.json();
+    const comment = updateComment(context.req.param("id"), text);
+    if (!comment)
+      return context.json({ error: "Not found" }, 404);
+    broadcast("refresh");
+    return context.json(comment);
+  });
+  app.delete("/api/comments/:id", (context) => {
+    const deleted = deleteComment(context.req.param("id"));
+    if (!deleted)
+      return context.json({ error: "Not found" }, 404);
+    broadcast("refresh");
+    return context.json({ success: true });
+  });
+  app.get("/api/git/diff", (context) => {
+    const diffOutput = getDiff(baseline);
+    return context.json({ diff: diffOutput });
+  });
+  app.get("/api/git/status", (context) => {
+    return context.json(getStatus());
+  });
+  app.post("/api/git/commit", async (context) => {
+    const { message } = await context.req.json();
+    const result = commitAll(message);
+    if (result.success)
+      broadcast("refresh");
+    return context.json(result);
+  });
+  app.post("/api/git/push", (context) => {
+    const result = pushToRemote();
+    return context.json(result);
+  });
+  app.get("/api/events", (context) => {
+    return streamSSE(context, async (stream) => {
+      const sendToClient = (event, data) => {
+        stream.writeSSE({ event, data }).catch(() => {});
+      };
+      connectedClients.add(sendToClient);
+      await stream.writeSSE({ event: "connected", data: "{}" });
+      const keepAliveTimer = setInterval(() => {
+        stream.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+          clearInterval(keepAliveTimer);
+        });
+      }, SSE_KEEPALIVE_INTERVAL_MS);
+      stream.onAbort(() => {
+        connectedClients.delete(sendToClient);
+        clearInterval(keepAliveTimer);
+      });
+      await new Promise(() => {});
+    });
+  });
+  app.post("/api/hook/pre-tool-use", async (context) => {
+    const pendingComments = getPendingComments();
+    if (pendingComments.length === 0) {
+      return context.json({});
+    }
+    const formattedComments = pendingComments.map((comment) => `[Review comment on ${comment.filePath}:${comment.lineNumber}] ${comment.text}`).join(`
+`);
+    return context.json({
+      additionalContext: `The user has left review comments on your changes. Please address them:
+${formattedComments}`
+    });
+  });
+  app.post("/api/hook/post-tool-use", (context) => {
+    broadcast("refresh");
+    return context.json({});
+  });
+  app.use("/*", serveStatic({
+    root: staticDir
+  }));
+  app.get("/*", serveStatic({ root: staticDir, path: "index.html" }));
+  return { app, broadcast };
+};
+
+// src/index.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+var currentDir = dirname(fileURLToPath(import.meta.url));
+var cliArgs = process.argv.slice(2);
+var baselineCommit = getHeadSha();
+console.log(`built-diff: baseline ${baselineCommit.slice(0, 8)}`);
+var staticDir;
+try {
+  const requireFromModule = createRequire(import.meta.url);
+  const webPackagePath = requireFromModule.resolve("@built-diff/web/package.json");
+  staticDir = join(dirname(webPackagePath), "dist");
+} catch {
+  staticDir = join(currentDir, "static");
+}
+var { app } = createApp(baselineCommit, staticDir);
+var cleanupTempDir = (tempDir) => {
+  try {
+    rmSync(tempDir, { recursive: true, force: true });
+  } catch {}
+};
+var getBrowserOpenCommand = () => {
+  if (process.platform === "darwin")
+    return "open";
+  if (process.platform === "win32")
+    return "start";
+  return "xdg-open";
+};
+var server = serve({ fetch: app.fetch, port: 0 }, (info) => {
+  const serverPort = info.port;
+  console.log(`built-diff: server on http://localhost:${serverPort}`);
+  const tempDir = join(tmpdir(), `built-diff-${process.pid}`);
+  mkdirSync(tempDir, { recursive: true });
+  let mcpServerEntryPath;
+  try {
+    const requireFromModule = createRequire(import.meta.url);
+    mcpServerEntryPath = requireFromModule.resolve("@built-diff/mcp-server");
+  } catch {
+    mcpServerEntryPath = join(currentDir, "..", "..", "mcp-server", "dist", "index.js");
+  }
+  const mcpConfig = {
+    mcpServers: {
+      "built-diff": {
+        command: "node",
+        args: [mcpServerEntryPath],
+        env: {
+          BUILT_DIFF_PORT: String(serverPort)
+        }
+      }
+    }
+  };
+  const mcpConfigPath = join(tempDir, "mcp.json");
+  writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+  const hookBaseUrl = `http://localhost:${serverPort}`;
+  const settings = {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: ".*",
+          hooks: [
+            {
+              type: "command",
+              command: `curl -s -X POST ${hookBaseUrl}/api/hook/pre-tool-use`
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: "Edit|Write|MultiEdit",
+          hooks: [
+            {
+              type: "command",
+              command: `curl -s -X POST ${hookBaseUrl}/api/hook/post-tool-use`
+            }
+          ]
+        }
+      ]
+    }
+  };
+  const settingsPath = join(tempDir, "settings.json");
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  spawn(getBrowserOpenCommand(), [`http://localhost:${serverPort}`], {
+    stdio: "ignore",
+    detached: true
+  }).unref();
+  const claudeArgs = [
+    "--mcp-config",
+    mcpConfigPath,
+    "--settings",
+    settingsPath,
+    "--append-system-prompt",
+    "You have a built-diff MCP server connected. Use the check_review tool periodically to see if the user has left inline review comments on your code changes in the web UI. Address any comments you find.",
+    ...cliArgs
+  ];
+  const claudeProcess = spawn("claude", claudeArgs, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      BUILT_DIFF_PORT: String(serverPort)
+    }
+  });
+  claudeProcess.on("error", (spawnError) => {
+    console.error("built-diff: failed to start claude:", spawnError.message);
+    console.error("Make sure the 'claude' CLI is installed and in your PATH.");
+    cleanupTempDir(tempDir);
+    process.exit(1);
+  });
+  claudeProcess.on("exit", (exitCode) => {
+    cleanupTempDir(tempDir);
+    server.close();
+    process.exit(exitCode ?? 0);
+  });
+  process.on("SIGINT", () => {
+    claudeProcess.kill("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    claudeProcess.kill("SIGTERM");
+  });
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "built-diff",
+  "version": "0.1.0",
+  "description": "Review Claude Code changes in a web UI with inline comments",
+  "bin": {
+    "built-diff": "dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.14.0",
+    "hono": "^4.7.0",
+    "@built-diff/mcp-server": "0.1.0",
+    "@built-diff/web": "0.1.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "diff",
+    "code-review"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --packages external",
+    "dev": "bun run src/dev-server.ts",
+    "dev:claude": "bun run src/index.ts"
+  }
+}