@plannotator/pi-extension 0.27.5 → 0.27.7

package/generated/call-flow-types.ts

@@ -161,7 +161,7 @@ export interface ParsedCallDiffWorkerResult {
   diagnostics: CallFlowDiagnostic[];
 }
 
-const MAX_TREES = 100;
+const MAX_TREES = 2_000;
 const MAX_NODES = 5_000;
 const MAX_TREE_DEPTH = 32;
 const MAX_DIAGNOSTICS = 100;
@@ -218,9 +218,16 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
   if (!isRecord(value.result) || !Array.isArray(value.result.trees)) {
     throw new Error("CallDiff worker response is missing its diff trees.");
   }
-  if (value.result.trees.length > MAX_TREES) {
-    throw new Error("CallDiff result exceeded Plannotator's tree limits.");
-  }
+  // A large-but-valid result (many small entry trees — common in Swift, TS,
+  // and other per-function languages) degrades instead of failing: keep the
+  // first MAX_TREES trees and say so in diagnostics (#1351). The caps that
+  // guard against genuinely unbounded worker output (total nodes, depth, raw
+  // length) still throw below.
+  const totalTreeCount = value.result.trees.length;
+  const truncatedTrees = totalTreeCount > MAX_TREES;
+  const boundedTreeCandidates = truncatedTrees
+    ? value.result.trees.slice(0, MAX_TREES)
+    : value.result.trees;
 
   let nodeCount = 0;
   const parseNode = (candidate: unknown, depth: number): CallFlowNode => {
@@ -254,7 +261,7 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
   };
 
   const raw = boundedRaw(value.result.ascii);
-  const trees = value.result.trees.map((candidate): CallFlowTree => {
+  const trees = boundedTreeCandidates.map((candidate): CallFlowTree => {
     if (!isRecord(candidate)) throw new Error("CallDiff worker returned an invalid tree.");
     const entry = boundedString(candidate.entry, "tree entry");
     const tree = parseNode(candidate.tree, 0);
@@ -287,6 +294,12 @@ export function parseCallDiffWorkerResult(value: unknown): ParsedCallDiffWorkerR
       });
     }
   }
+  if (truncatedTrees) {
+    diagnostics.push({
+      level: "warning",
+      message: `Showing the first ${MAX_TREES.toLocaleString("en-US")} of ${totalTreeCount.toLocaleString("en-US")} call trees; the rest were truncated to bound the result.`,
+    });
+  }
 
   return {
     version: boundedString(value.version, "version", 100),

package/generated/config.ts

@@ -46,7 +46,8 @@ export type PromptRuntime =
   | "copilot-cli"
   | "pi"
   | "codex"
-  | "gemini-cli";
+  | "gemini-cli"
+  | "oh-my-pi";
 
 interface PromptSectionConfig {
   [key: string]: string | Partial<Record<PromptRuntime, PromptSectionOverrides>> | undefined;

package/generated/jj-core.ts

@@ -9,6 +9,7 @@ import {
   type JjEvoLogEntry,
   JJ_TRUNK_REVSET,
   jjLineBaseRevset,
+  parseRemoteBookmark,
   validateFilePath,
 } from "./review-core.ts";
 
@@ -27,6 +28,31 @@ export interface ReviewJjRuntime {
   ) => Promise<GitCommandResult>;
 }
 
+// `reachable(@, mutable())` is JJ's definition of the stack being worked on.
+// Its root parents are where that line diverged from immutable history.
+//
+// `latest(..., 1)` is what keeps the query single-record. A criss-cross history
+// can leave several fork points, and the parser below reads one record only, so
+// the tie-break belongs in the revset where it is deliberate and testable
+// rather than in a silent "first row wins" slice. It also matters for
+// correctness: bookmark preference (remote before local) is only meaningful
+// within one commit, so a multi-row answer could otherwise pick a remote
+// bookmark from one commit over a local bookmark on a nearer one.
+const JJ_LINE_BASE_REVSET = "latest(fork_point(roots(reachable(@, mutable()))-), 1)";
+
+// `jj git push --change` mints bookmarks under `git.push-bookmark-prefix`
+// (default `push-`). They name one change, not a line of work, so they are
+// never a useful review base. They reach the fork point in practice: a
+// colleague's pushed change bookmark arrives as an untracked remote bookmark,
+// which makes its commit immutable and therefore a candidate base, and the
+// reviewer would be told they are comparing against `push-vmopwunwxopv@origin`.
+const JJ_GENERATED_PUSH_BOOKMARK_PREFIX = "push-";
+
+// `commit_id` renders in full, so an all-zero id is the virtual root commit.
+// A repo with no immutable history forks there, and a 40-zero hash means
+// nothing to a reviewer, so keep the `trunk()` sentinel for that case.
+const JJ_ROOT_COMMIT_ID = /^0+$/;
+
 export async function detectJjWorkspace(
   runtime: ReviewJjRuntime,
   cwd?: string,
@@ -369,13 +395,35 @@ export async function selectDefaultJjCompareTarget(
     "log",
     "--no-graph",
     "-r",
-    JJ_TRUNK_REVSET,
+    JJ_LINE_BASE_REVSET,
     "-T",
-    "json(bookmarks)",
+    'json(bookmarks) ++ "\\t" ++ commit_id ++ "\\n"',
   ], { cwd });
+  // Every unresolvable case falls back to `trunk()`, which is what this
+  // returned before the line-of-work base was inferred at all. The only live
+  // caller is `getJjContext`, which runs on the review startup path with no
+  // handler above it, so throwing here does not report a problem: it aborts
+  // `plannotator review` with a stack trace before the server is built. That
+  // also covers a `jj` too old for `fork_point`/`reachable`, where the revset
+  // itself fails and the previous default is still perfectly serviceable.
   if (result.exitCode !== 0) return JJ_TRUNK_REVSET;
 
-  return parseJjResolvedBookmarks(result.stdout)[0] ?? JJ_TRUNK_REVSET;
+  const [record] = splitJjTemplateRecords(result.stdout);
+  if (!record) return JJ_TRUNK_REVSET;
+
+  const fields = splitJjTemplateFields(record);
+  const bookmark = parseJjResolvedBookmarks(fields?.[0] ?? record)
+    .find((name) => !isGeneratedPushBookmark(name));
+  if (bookmark) return bookmark;
+
+  const commitId = fields?.[1]?.trim();
+  if (commitId && !JJ_ROOT_COMMIT_ID.test(commitId)) return commitId;
+  return JJ_TRUNK_REVSET;
+}
+
+function isGeneratedPushBookmark(target: string): boolean {
+  const name = parseRemoteBookmark(target)?.name ?? target;
+  return name.startsWith(JJ_GENERATED_PUSH_BOOKMARK_PREFIX);
 }
 
 function parseJjResolvedBookmarks(value: string): string[] {

package/generated/live-probe.ts

@@ -0,0 +1,133 @@
+// @generated — DO NOT EDIT. Source: packages/shared/live-probe.ts
+/**
+ * Shared live-app eligibility probe for annotate URL targets.
+ *
+ * One implementation of the "does this loopback URL front a live dev app?"
+ * decision, used by the Bun CLI's annotate resolution
+ * (apps/hook/server/annotate-resolution.ts) and the Pi extension's annotate
+ * command (vendored to generated/). Both hosts must probe identically: same
+ * 3s timeout, same `accept: text/html` request, same "any status < 500"
+ * gate, same final-response redirect rule — a drifting copy here would make
+ * the same URL open live on one agent and static on another.
+ *
+ * Pure Web-platform code: global fetch + AbortSignal.timeout, no Bun or
+ * node:http APIs.
+ */
+
+import { isLoopbackHostname } from "./live-proxy-core.ts";
+
+export const LIVE_PROBE_TIMEOUT_MS = 3000;
+
+export interface LiveAppCandidate {
+  parsed: URL | null;
+  /** The URL parsed and its hostname is loopback (localhost / ::1 / 127/8). */
+  loopback: boolean;
+}
+
+/** Parse an annotate URL target and classify its live-mode candidacy. */
+export function classifyLiveAppCandidate(url: string): LiveAppCandidate {
+  let parsed: URL | null = null;
+  try {
+    parsed = new URL(url);
+  } catch {
+    parsed = null;
+  }
+  return { parsed, loopback: parsed !== null && isLoopbackHostname(parsed.hostname) };
+}
+
+export interface LiveAppProbeResult {
+  liveEligible: boolean;
+  /** Fetch-level failure message, when the probe never completed. */
+  probeError: string | null;
+  /** Final URL when the probe redirected off the target's loopback origin. */
+  probeRedirectedTo: string | null;
+}
+
+/**
+ * Probe a loopback http URL for live eligibility. Live eligibility is judged
+ * on the FINAL response after redirects: a loopback URL that 302s off its
+ * own origin (auth portal, tunnel splash page, another local service) must
+ * not open a live session whose iframe immediately navigates off the proxy;
+ * same-server redirects (/ to /login) stay live-eligible. Any status < 500
+ * with an HTML content type qualifies, so a login page or SPA 404 still
+ * opens live.
+ */
+export async function probeLiveAppTarget(
+  targetUrl: string,
+  parsedUrl: URL,
+  fetchImpl: typeof fetch = fetch,
+): Promise<LiveAppProbeResult> {
+  let liveEligible = false;
+  let probeError: string | null = null;
+  let probeRedirectedTo: string | null = null;
+  try {
+    const probe = await fetchImpl(targetUrl, {
+      headers: { accept: "text/html" },
+      redirect: "follow",
+      signal: AbortSignal.timeout(LIVE_PROBE_TIMEOUT_MS),
+    });
+    const contentType = probe.headers.get("content-type") ?? "";
+    let finalOnOrigin = false;
+    try {
+      const finalUrl = new URL(probe.url || targetUrl);
+      finalOnOrigin =
+        finalUrl.protocol === "http:"
+        && isLoopbackHostname(finalUrl.hostname)
+        && (finalUrl.port || "80") === (parsedUrl.port || "80");
+      if (!finalOnOrigin) probeRedirectedTo = probe.url;
+    } catch {
+      finalOnOrigin = false;
+    }
+    liveEligible = probe.status < 500 && contentType.includes("text/html") && finalOnOrigin;
+  } catch (err) {
+    probeError = err instanceof Error ? err.message : String(err);
+  }
+  return { liveEligible, probeError, probeRedirectedTo };
+}
+
+// --- Shared user-facing messages ---------------------------------------------
+// Wording is shared so a Pi user and a CLI user read the SAME explanation for
+// the same condition; hosts differ only in the channel (stderr vs notify).
+
+/** --app given with a file/folder target. */
+export const LIVE_APP_REQUIRES_URL_MESSAGE =
+  "--app requires a URL target (a running local app, e.g. http://localhost:5173)";
+
+/** --app given with a non-loopback URL. */
+export const LIVE_APP_REQUIRES_LOOPBACK_MESSAGE = "--app requires a localhost/loopback URL";
+
+/** --app given with an https URL (the live proxy is http-only). */
+export const LIVE_APP_REQUIRES_HTTP_MESSAGE =
+  "--app requires an http:// URL (the live app proxy does not support https upstreams)";
+
+/** Live sessions are hard-off in remote mode; no override env var exists. */
+export const LIVE_APP_REMOTE_MESSAGE =
+  "Live app annotation is unavailable in remote mode (PLANNOTATOR_REMOTE). Run locally, or use --static to annotate a converted snapshot of the page.";
+
+/** The --app forced-live failure, keyed on what the probe found. */
+export function buildForceAppFailureMessage(
+  targetUrl: string,
+  probe: LiveAppProbeResult,
+): string {
+  if (probe.probeError !== null) {
+    return `--app: could not reach ${targetUrl}: ${probe.probeError}`;
+  }
+  if (probe.probeRedirectedTo !== null) {
+    return `--app: ${targetUrl} redirected off its loopback origin (${probe.probeRedirectedTo}); live mode requires the app to serve HTML from the probed origin`;
+  }
+  return `--app: ${targetUrl} did not return an HTML page`;
+}
+
+/**
+ * Fallback notice when a live-eligible-looking URL probed as unreachable and
+ * the session degrades to static conversion. A dev server still starting up
+ * probes as unreachable, and a silent downgrade to static conversion reads
+ * as a broken live session, so the notice names the condition and the
+ * retry-with---app escape hatch.
+ */
+export function buildLiveProbeFallbackNotice(targetUrl: string, probeError: string): string {
+  return (
+    `Live probe failed for ${targetUrl} (${probeError}); using static conversion. `
+    + `If a dev server is still starting up, retry with --app to force live mode.`
+  );
+}