diffprism 0.44.0 → 0.47.0

package/dist/{chunk-4IQOTAHD.js → chunk-PQWU5NW4.js}

@@ -122,30 +122,45 @@ function buildDefaultSpawnCommand(options) {
   const thisDir = path2.dirname(thisFile);
   const workspaceRoot = path2.resolve(thisDir, "..", "..", "..");
   const devBin = path2.join(workspaceRoot, "cli", "bin", "diffprism.mjs");
-  let binPath = "diffprism";
   if (fs2.existsSync(devBin)) {
-    binPath = devBin;
-  } else {
-    let searchDir = thisDir;
-    while (searchDir !== path2.dirname(searchDir)) {
-      const candidate = path2.join(
-        searchDir,
-        "node_modules",
-        ".bin",
-        "diffprism"
+    return withDevFlag([process.execPath, devBin, "server", "--_daemon"], options);
+  }
+  let searchDir = thisDir;
+  while (searchDir !== path2.dirname(searchDir)) {
+    const ownBin = readOwnBinPath(searchDir);
+    if (ownBin) {
+      return withDevFlag(
+        [process.execPath, ownBin, "server", "--_daemon"],
+        options
       );
-      if (fs2.existsSync(candidate)) {
-        binPath = candidate;
-        break;
-      }
-      searchDir = path2.dirname(searchDir);
     }
+    const shim = path2.join(searchDir, "node_modules", ".bin", "diffprism");
+    if (fs2.existsSync(shim)) {
+      return withDevFlag([shim, "server", "--_daemon"], options);
+    }
+    searchDir = path2.dirname(searchDir);
   }
-  const args = [process.execPath, binPath, "server", "--_daemon"];
-  if (options.dev) {
-    args.push("--dev");
+  return withDevFlag(["diffprism", "server", "--_daemon"], options);
+}
+function withDevFlag(args, options) {
+  return options.dev ? [...args, "--dev"] : args;
+}
+function readOwnBinPath(dir) {
+  const manifestPath = path2.join(dir, "package.json");
+  if (!fs2.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+    const entry = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.diffprism;
+    if (!entry) {
+      return null;
+    }
+    const resolved = path2.resolve(dir, entry);
+    return fs2.existsSync(resolved) ? resolved : null;
+  } catch {
+    return null;
   }
-  return args;
 }
 async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -851,6 +866,96 @@ async function handleApiRequest(req, res) {
     }
     return true;
   }
+  if (method === "POST" && url === "/api/pr/open") {
+    try {
+      const body = await readBody(req);
+      const { prUrl } = JSON.parse(body);
+      if (!prUrl) {
+        jsonResponse(res, 400, { error: "Missing prUrl" });
+        return true;
+      }
+      const {
+        isPrRef,
+        parsePrRef,
+        resolveGitHubToken,
+        createGitHubClient,
+        fetchPullRequest,
+        fetchPullRequestDiff,
+        normalizePr
+      } = await import("./src-KF5HRJPX.js");
+      if (!isPrRef(prUrl)) {
+        jsonResponse(res, 400, {
+          error: "Invalid PR URL. Expected https://github.com/owner/repo/pull/123 or owner/repo#123"
+        });
+        return true;
+      }
+      let token;
+      try {
+        token = resolveGitHubToken();
+      } catch (err) {
+        jsonResponse(res, 401, {
+          error: err instanceof Error ? err.message : "GitHub token not found"
+        });
+        return true;
+      }
+      const { owner, repo, number: prNumber } = parsePrRef(prUrl);
+      const client = createGitHubClient(token);
+      const [prMetadata, rawDiff] = await Promise.all([
+        fetchPullRequest(client, owner, repo, prNumber),
+        fetchPullRequestDiff(client, owner, repo, prNumber)
+      ]);
+      const normalized = normalizePr(rawDiff, prMetadata);
+      let localRepoPath = null;
+      try {
+        const { execSync } = await import("child_process");
+        const remoteOutput = execSync("git remote -v", {
+          cwd: process.cwd(),
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const repoPattern = new RegExp(`github\\.com[:/]${owner}/${repo}(\\.git)?\\s`, "i");
+        if (repoPattern.test(remoteOutput)) {
+          localRepoPath = process.cwd();
+        }
+      } catch {
+      }
+      const sessionId = `session-${randomUUID2().slice(0, 8)}`;
+      normalized.payload.reviewId = sessionId;
+      const session = {
+        id: sessionId,
+        payload: normalized.payload,
+        projectPath: localRepoPath ?? `github:${owner}/${repo}#${prNumber}`,
+        source: "manual",
+        status: "pending",
+        createdAt: Date.now(),
+        result: null,
+        hasNewChanges: false,
+        annotations: []
+      };
+      sessions.set(sessionId, session);
+      broadcastToAll({
+        type: "session:added",
+        payload: toSummary(session)
+      });
+      jsonResponse(res, 201, {
+        sessionId,
+        fileCount: normalized.diffSet.files.length,
+        localRepoPath,
+        pr: {
+          title: prMetadata.title,
+          author: prMetadata.author,
+          url: prMetadata.url,
+          baseBranch: prMetadata.baseBranch,
+          headBranch: prMetadata.headBranch
+        }
+      });
+    } catch (err) {
+      jsonResponse(res, 500, {
+        error: err instanceof Error ? err.message : "Failed to fetch PR"
+      });
+    }
+    return true;
+  }
   if (method === "GET" && req.url) {
     const parsedUrl = new URL(req.url, "http://localhost");
     if (parsedUrl.pathname === "/api/fs/list") {
@@ -903,6 +1008,20 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, toSummary(session));
     return true;
   }
+  const getPayloadParams = matchRoute(method, url, "GET", "/api/reviews/:id/payload");
+  if (getPayloadParams) {
+    const session = sessions.get(getPayloadParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, {
+      payload: session.payload,
+      projectPath: session.projectPath,
+      annotations: session.annotations
+    });
+    return true;
+  }
   const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
   if (postResultParams) {
     const session = sessions.get(postResultParams.id);
@@ -1033,6 +1152,38 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, { ok: true });
     return true;
   }
+  const postFocusParams = matchRoute(method, url, "POST", "/api/reviews/:id/focus");
+  if (postFocusParams) {
+    const session = sessions.get(postFocusParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const { file, lineStart, lineEnd } = JSON.parse(body);
+      session.userFocus = {
+        file,
+        lineStart,
+        lineEnd,
+        updatedAt: Date.now()
+      };
+      jsonResponse(res, 200, { ok: true });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getFocusParams = matchRoute(method, url, "GET", "/api/reviews/:id/focus");
+  if (getFocusParams) {
+    const session = sessions.get(getFocusParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, { focus: session.userFocus ?? null });
+    return true;
+  }
   const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
   if (deleteParams) {
     stopSessionWatcher(deleteParams.id);

package/dist/{chunk-LH6H3QSC.js → chunk-TZ5SGWHP.js}

@@ -1,7 +1,7 @@
 import {
   ensureServer,
   submitReviewToServer
-} from "./chunk-4IQOTAHD.js";
+} from "./chunk-PQWU5NW4.js";
 import {
   parseDiff
 } from "./chunk-QGWYCEJN.js";

package/dist/{demo-MDPKCAXZ.js → demo-H2NAMKCT.js}

@@ -1,7 +1,7 @@
 import {
   demo
-} from "./chunk-LH6H3QSC.js";
-import "./chunk-4IQOTAHD.js";
+} from "./chunk-TZ5SGWHP.js";
+import "./chunk-PQWU5NW4.js";
 import "./chunk-QGWYCEJN.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";