@yannelli/paseo-linear-plugin 1.0.1 → 1.1.0-beta.1

package/shared/activity.ts

@@ -0,0 +1,312 @@
+import { displayCommand, shellActivity } from "./shell-activity";
+import { isSubagentCall, mergeSubagent, type SubagentRun, subagentOf } from "./subagents";
+import { type TodoLike, todoKey, todoStatus } from "./todo-sync";
+
+// Structural view of Paseo timeline items, so shared code needs no protocol import.
+export interface TimelineItemLike {
+  type: string;
+  [key: string]: unknown;
+}
+
+export type TouchKind = "read" | "edit" | "write" | "search";
+export type EventKind = TouchKind | "list" | "shell" | "agent" | "tool";
+export type ToolStatus = "running" | "completed" | "failed" | "canceled";
+
+export interface FileTouch {
+  path: string;
+  reads: number;
+  edits: number;
+  added: number;
+  removed: number;
+  created: boolean;
+  /** Position of the last touch in the timeline. Higher is more recent. */
+  order: number;
+  last: TouchKind;
+}
+
+export interface ActivityEvent {
+  id: string;
+  kind: EventKind;
+  text: string;
+  /** The command as run, for shell events. */
+  detail: string | null;
+  path: string | null;
+  /** Every file the event read or changed; `path` is the first. */
+  paths: string[];
+  status: ToolStatus;
+  added: number;
+  removed: number;
+  exitCode: number | null;
+}
+
+export interface DirTouch {
+  /** Folder with a trailing slash; "" is the repository root. */
+  path: string;
+  /** Searched recursively, not only listed. */
+  deep: boolean;
+  order: number;
+}
+
+/** What the agent works on now: a file, or an issue whose todo it just started. */
+export type AgentFocus = { kind: "file"; path: string } | { kind: "issue"; key: string };
+
+export interface Activity {
+  focus: AgentFocus | null;
+  files: FileTouch[];
+  dirs: DirTouch[];
+  /** Subagents started inside the provider, in launch order. */
+  subagents: SubagentRun[];
+  /** Newest first. */
+  events: ActivityEvent[];
+  current: ActivityEvent | null;
+  todos: TodoLike[];
+}
+
+const MAX_EVENTS = 40;
+// Bookkeeping tools: the todos already show what they do.
+const HIDDEN_TOOLS = /^(Task(Create|Update|List|Get|Stop|Output)|TodoWrite|ToolSearch|advisor|task_notification)$/;
+
+/** A repo-relative path, or null when the path is outside the agent's folder. */
+export function relativePath(path: string, cwd: string): string | null {
+  let value = path.trim().replace(/\\/g, "/");
+  const root = cwd.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+  if (root && value.startsWith(`${root}/`)) value = value.slice(root.length + 1);
+  else if (value.startsWith("/") || /^[A-Za-z]:\//.test(value)) return null;
+  value = value.replace(/^(\.\/)+/, "");
+  if (!value || value.split("/").includes("..")) return null;
+  return value;
+}
+
+function text(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+function lineCount(value: string | null): number {
+  if (!value) return 0;
+  return value.replace(/\n$/, "").split("\n").length;
+}
+
+function diffCounts(detail: Record<string, unknown>): { added: number; removed: number } {
+  // Subagent transcripts send counts, not the text.
+  if (typeof detail.added === "number") {
+    return { added: detail.added, removed: typeof detail.removed === "number" ? detail.removed : 0 };
+  }
+  const diff = text(detail.unifiedDiff);
+  if (diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) added += 1;
+      else if (line.startsWith("-") && !line.startsWith("---")) removed += 1;
+    }
+    return { added, removed };
+  }
+  return { added: lineCount(text(detail.newString)), removed: lineCount(text(detail.oldString)) };
+}
+
+function toolStatus(value: unknown): ToolStatus {
+  return value === "running" || value === "failed" || value === "canceled" ? value : "completed";
+}
+
+function baseName(path: string): string {
+  return path.split("/").pop() ?? path;
+}
+
+// Tool calls stream as repeated items with one callId. The last copy wins, in first position.
+function latestToolCalls(items: readonly TimelineItemLike[]) {
+  const order: string[] = [];
+  const byId = new Map<string, TimelineItemLike>();
+  const started = new Map<string, number>();
+  items.forEach((item, index) => {
+    if (item.type !== "tool_call") return;
+    const id = text(item.callId) ?? `index-${index}`;
+    if (!byId.has(id)) {
+      order.push(id);
+      started.set(id, index);
+    }
+    byId.set(id, item);
+  });
+  return order.map((id) => ({ id, item: byId.get(id) as TimelineItemLike, start: started.get(id) ?? 0 }));
+}
+
+interface FocusMark {
+  path: string;
+  /** Index of the item where the call started. */
+  at: number;
+}
+
+// The newest point at which the in-progress todo moved to another issue key.
+function todoFocus(items: readonly TimelineItemLike[]): { key: string; at: number } | null {
+  let focus: { key: string; at: number } | null = null;
+  let active: string | null = null;
+  items.forEach((item, index) => {
+    if (item.type !== "todo" || !Array.isArray(item.items)) return;
+    const doing = (item.items as TodoLike[]).find((todo) => todoStatus(todo) === "in_progress");
+    const key = doing ? todoKey(doing.text) : null;
+    if (key && key !== active) focus = { key, at: index };
+    active = key;
+  });
+  return focus;
+}
+
+export function deriveActivity(items: readonly TimelineItemLike[], cwd: string): Activity {
+  const files = new Map<string, FileTouch>();
+  const dirs = new Map<string, DirTouch>();
+  const events: ActivityEvent[] = [];
+  const subagents = new Map<string, SubagentRun>();
+  const subagentEvents = new Map<string, ActivityEvent>();
+  const resolve = (path: string) => relativePath(path, cwd);
+  let todos: TodoLike[] = [];
+  for (const item of items) {
+    if (item.type === "todo" && Array.isArray(item.items)) todos = item.items as TodoLike[];
+  }
+  const touch = (path: string, kind: TouchKind, order: number) => {
+    const entry = files.get(path) ?? {
+      path,
+      reads: 0,
+      edits: 0,
+      added: 0,
+      removed: 0,
+      created: false,
+      order,
+      last: kind,
+    };
+    entry.order = order;
+    entry.last = kind;
+    files.set(path, entry);
+    return entry;
+  };
+
+  let fileFocus: FocusMark | null = null;
+  let runningFocus: FocusMark | null = null;
+  latestToolCalls(items).forEach(({ id, item, start }, order) => {
+    if (HIDDEN_TOOLS.test(text(item.name) ?? "")) return;
+    const signal = subagentOf(item, resolve);
+    if (!signal && isSubagentCall(item)) return;
+    if (signal) {
+      // The launch call and the subagent item are one run, so they make one feed row.
+      const run = mergeSubagent(subagents, signal, order);
+      const known = subagentEvents.get(run.key);
+      const row: ActivityEvent = known ?? {
+        id,
+        kind: "agent",
+        text: run.description ? `${run.type}: ${run.description}` : run.type,
+        detail: null,
+        path: null,
+        paths: [],
+        status: run.status,
+        added: 0,
+        removed: 0,
+        exitCode: null,
+      };
+      row.status = run.status;
+      row.paths = run.targets;
+      row.path = run.targets[0] ?? null;
+      if (!known) {
+        subagentEvents.set(run.key, row);
+        events.push(row);
+      }
+      return;
+    }
+    const detail = (item.detail ?? {}) as Record<string, unknown>;
+    const status = toolStatus(item.status);
+    const event: ActivityEvent = {
+      id,
+      kind: "tool",
+      text: text(item.name) ?? "Tool call",
+      detail: null,
+      path: null,
+      paths: [],
+      status,
+      added: 0,
+      removed: 0,
+      exitCode: null,
+    };
+    const raw = text(detail.filePath);
+    const path = raw ? relativePath(raw, cwd) : null;
+    if (path) event.paths = [path];
+    if (detail.type === "read" && raw) {
+      event.kind = "read";
+      event.path = path;
+      event.text = `Read ${path ?? baseName(raw)}`;
+      if (path) touch(path, "read", order).reads += 1;
+    } else if ((detail.type === "edit" || detail.type === "write") && raw) {
+      const write = detail.type === "write";
+      const counts = write && typeof detail.added !== "number"
+        ? { added: lineCount(text(detail.content)), removed: 0 }
+        : diffCounts(detail);
+      event.kind = write ? "write" : "edit";
+      event.path = path;
+      event.added = counts.added;
+      event.removed = counts.removed;
+      event.text = `${write ? "Wrote" : "Edited"} ${path ?? baseName(raw)}`;
+      if (path && status !== "failed") {
+        const entry = touch(path, event.kind, order);
+        entry.edits += 1;
+        entry.added += counts.added;
+        entry.removed += counts.removed;
+        if (write && entry.reads === 0 && entry.edits === 1) entry.created = true;
+      }
+    } else if (detail.type === "search") {
+      event.kind = "search";
+      event.text = `Searched ${JSON.stringify(text(detail.query) ?? "")}`;
+      const hits = Array.isArray(detail.filePaths) ? detail.filePaths : [];
+      for (const hit of hits) {
+        const hitPath = typeof hit === "string" ? relativePath(hit, cwd) : null;
+        if (hitPath && !files.has(hitPath)) touch(hitPath, "search", order);
+      }
+    } else if (detail.type === "shell") {
+      const command = text(detail.command) ?? "";
+      const start = relativePath(text(detail.cwd) ?? "", cwd) ?? "";
+      const shell = shellActivity(command, cwd, start);
+      event.exitCode = typeof detail.exitCode === "number" ? detail.exitCode : null;
+      event.detail = displayCommand(command, cwd);
+      event.text = shell.summary;
+      event.paths = [...shell.writes.map((write) => write.path), ...shell.reads];
+      event.path = event.paths[0] ?? null;
+      event.kind = "shell";
+      if (shell.writes.length > 0) event.kind = "write";
+      else if (shell.reads.length > 0) event.kind = "read";
+      else if (shell.pattern !== null) event.kind = "search";
+      else if (shell.dirs.length > 0) event.kind = "list";
+      for (const read of shell.reads) touch(read, "read", order).reads += 1;
+      // A failed write may not have happened; reads count either way, as grep exits 1 on no match.
+      const succeeded = status === "completed" && (event.exitCode ?? 0) === 0;
+      for (const write of succeeded ? shell.writes : []) {
+        const entry = touch(write.path, write.mode, order);
+        entry.edits += 1;
+        if (write.mode === "write" && entry.reads === 0 && entry.edits === 1) entry.created = true;
+      }
+      for (const dir of shell.dirs) {
+        const known = dirs.get(dir.path);
+        dirs.set(dir.path, { path: dir.path, deep: dir.deep || (known?.deep ?? false), order });
+      }
+    }
+    const lead = event.path ?? event.paths[0];
+    if (lead && (event.kind === "read" || event.kind === "edit" || event.kind === "write")) {
+      if (!fileFocus || start >= fileFocus.at) fileFocus = { path: lead, at: start };
+      if (status === "running" && (!runningFocus || start >= runningFocus.at)) runningFocus = { path: lead, at: start };
+    }
+    events.push(event);
+  });
+
+  const recent = events.slice(-MAX_EVENTS).reverse();
+  const current = recent.find((event) => event.status === "running") ?? recent[0] ?? null;
+  // A running call wins; otherwise the newer of the last file and the last todo change.
+  const issueFocus = todoFocus(items);
+  const lastFile = fileFocus as FocusMark | null;
+  const running = runningFocus as FocusMark | null;
+  let focus: AgentFocus | null = null;
+  if (running) focus = { kind: "file", path: running.path };
+  else if (issueFocus && (!lastFile || issueFocus.at > lastFile.at)) focus = { kind: "issue", key: issueFocus.key };
+  else if (lastFile) focus = { kind: "file", path: lastFile.path };
+  return {
+    focus,
+    files: [...files.values()].sort((a, b) => b.order - a.order),
+    dirs: [...dirs.values()],
+    subagents: [...subagents.values()],
+    events: recent,
+    current,
+    todos,
+  };
+}

package/shared/agent-hooks.ts

@@ -0,0 +1,68 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { GuidanceSchema } from "./settings";
+
+// Claude Code hooks for an agent started from an issue. The daemon writes them as a Claude Code
+// plugin and the launch passes its folder with --plugin-dir, so they never replace the settings
+// Paseo itself passes with --settings. Each hook only prints text; none of them runs project code.
+
+export const IDENTIFIER = /^[A-Za-z][A-Za-z0-9]*-\d+$/;
+
+const HookIssueSchema = z.object({
+  identifier: z.string().regex(IDENTIFIER),
+  title: z.string(),
+  children: z.array(z.object({ identifier: z.string().regex(IDENTIFIER), title: z.string() })).max(100),
+});
+export type HookIssue = z.infer<typeof HookIssueSchema>;
+
+export const agentHooksRpc = defineRpc({
+  name: "linear.agent.hooks",
+  input: z.object({ issue: HookIssueSchema, guidance: GuidanceSchema }),
+  /** Null when no hook applies or the daemon host cannot run them. */
+  output: z.object({ pluginDir: z.string().nullable() }),
+});
+
+/** Single-quotes text for a POSIX shell. */
+export function shellQuote(text: string): string {
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function printHook(event: string, context: string) {
+  const output = { hookSpecificOutput: { hookEventName: event, additionalContext: context } };
+  return { type: "command", command: `printf '%s' ${shellQuote(JSON.stringify(output))}` };
+}
+
+function issueLines(issue: HookIssue): string[] {
+  const lines = [`Linear issue ${issue.identifier}: ${issue.title}`];
+  for (const child of issue.children.slice(0, 30)) lines.push(`- ${child.identifier}: ${child.title}`);
+  return lines;
+}
+
+/** The plugin's hooks.json, or null when no guidance option needs a hook. */
+export function claudeHooks(issue: HookIssue, guidance: z.infer<typeof GuidanceSchema>) {
+  const hooks: Record<string, unknown[]> = {};
+  if (guidance.subagentKeys) {
+    const context = [
+      `You are a subagent for ${issue.identifier}.`,
+      ...issueLines(issue),
+      "Put the key of the issue you work on in the first line of your reply, such as",
+      `"${issue.children[0]?.identifier ?? issue.identifier}: checked the form".`,
+      "If your work moves to another issue, state the new key.",
+    ].join("\n");
+    hooks.SubagentStart = [{ hooks: [printHook("SubagentStart", context)] }];
+  }
+  if (guidance.updateLinear || guidance.subagentKeys || guidance.paseoSubagents) {
+    // After compaction the summary can drop the issue, so restate it.
+    const context = [
+      `You work on ${issue.identifier}. The Linear rules in your first prompt still apply.`,
+      ...issueLines(issue),
+    ].join("\n");
+    hooks.SessionStart = [{ matcher: "compact", hooks: [printHook("SessionStart", context)] }];
+  }
+  return Object.keys(hooks).length > 0 ? { hooks } : null;
+}
+
+/** Claude Code plugin names are lowercase words joined by hyphens. */
+export function hookPluginName(identifier: string): string {
+  return `paseo-linear-${identifier.toLowerCase()}`;
+}

package/shared/agent-tools.ts

@@ -0,0 +1,130 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { IDENTIFIER } from "./agent-hooks";
+import type { IssueDetail } from "./linear";
+
+// The plugin's MCP server for agents started from an issue. It gives them Linear tools for
+// their issue tree and a way to start Paseo agents on its sub-issues. The daemon hosts it on
+// 127.0.0.1, and each agent gets its own bearer token.
+
+export const TOOLS_SERVER = "linear";
+/** Children get only the Linear tools, so agents never start agents of their own. */
+export const LINEAR_TOOLS = ["read_issue", "edit_issue"] as const;
+export const AGENT_TOOLS = ["start_agent", "wait_agent"] as const;
+
+export const McpHttpServerSchema = z.object({
+  type: z.literal("http"),
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string()).optional(),
+});
+
+export const ToolPolicySchema = z.object({
+  preapproved: z.array(z.object({ kind: z.literal("mcp"), server: z.string(), tool: z.string() })),
+});
+
+export const ToolScopeSchema = z.object({
+  /** The issue the launch started from. The tools reach it and its sub-issues. */
+  root: z.string().regex(IDENTIFIER),
+  /** The issue this agent works on, the default for read_issue and edit_issue. */
+  home: z.string().regex(IDENTIFIER),
+  /** The Paseo project whose Linear key loaded the issue. */
+  keyScope: z.string().nullable(),
+  workspaceId: z.string().min(1),
+  /** The agent config that started agents copy. */
+  config: z.object({
+    provider: z.string().min(1),
+    thinkingOptionId: z.string().optional(),
+    modeId: z.string().optional(),
+  }),
+});
+export type ToolScope = z.infer<typeof ToolScopeSchema>;
+
+export const agentToolsRpc = defineRpc({
+  name: "linear.agent.tools",
+  input: ToolScopeSchema,
+  output: z.object({
+    /** Goes in the agent's labels, so a tool call can find the agent that made it. */
+    grantId: z.string(),
+    server: McpHttpServerSchema,
+    toolPolicy: ToolPolicySchema,
+  }),
+});
+
+export function toolPolicy(tools: readonly string[]): z.infer<typeof ToolPolicySchema> {
+  return { preapproved: tools.map((tool) => ({ kind: "mcp" as const, server: TOOLS_SERVER, tool })) };
+}
+
+const IssueKey = z.string().regex(IDENTIFIER);
+
+export const ReadIssueInput = z.object({
+  issue: IssueKey.optional().describe("Issue key, such as ENG-12. The default is the issue you work on."),
+});
+
+export const EditIssueInput = z.object({
+  issue: IssueKey.optional().describe("Issue key, such as ENG-12. The default is the issue you work on."),
+  old_text: z
+    .string()
+    .describe("Exact text of the description to replace. It must occur one time. Use an empty string to add new_text at the end."),
+  new_text: z.string().describe("The text that replaces old_text."),
+});
+
+export const StartAgentInput = z.object({
+  issue: IssueKey.describe("Key of the sub-issue the agent works on."),
+  title: z.string().min(1).max(120).describe("Short title. Start it with the issue key."),
+  prompt: z.string().min(1).describe("The full task. The agent does not see your conversation."),
+  thinking: z
+    .string()
+    .optional()
+    .describe("Thinking option of the agent's model, such as low, medium, or high. The default is yours."),
+});
+
+export const WaitAgentInput = z.object({
+  agent_id: z.string().min(1),
+  timeout_seconds: z.number().int().min(1).max(600).default(50),
+});
+
+/** Replaces the one place where old text occurs. Empty old text adds the new text at the end. */
+export function editText(body: string, oldText: string, newText: string): { body: string } | { error: string } {
+  if (oldText === "") return { body: body.trimEnd() ? `${body.trimEnd()}\n\n${newText}` : newText };
+  const first = body.indexOf(oldText);
+  if (first < 0) return { error: "old_text is not in the description. Read the issue again, because it can change." };
+  if (body.indexOf(oldText, first + 1) >= 0) {
+    return { error: "old_text occurs more than one time. Add nearby lines so that it occurs one time." };
+  }
+  return { body: body.slice(0, first) + newText + body.slice(first + oldText.length) };
+}
+
+/** Counts Markdown task list items, so a reply can say how many are done. */
+export function taskCount(body: string): { done: number; total: number } {
+  const items = [...body.matchAll(/^\s*[-*+] \[([ xX])\]/gm)];
+  return { done: items.filter((item) => item[1] !== " ").length, total: items.length };
+}
+
+/** The issue as text for read_issue. */
+export function issueText(issue: IssueDetail): string {
+  const tasks = taskCount(issue.description ?? "");
+  const lines = [
+    `${issue.identifier}: ${issue.title}`,
+    `Status: ${issue.state.name}`,
+    `URL: ${issue.url}`,
+    tasks.total > 0 ? `Task list: ${tasks.done} of ${tasks.total} checked` : null,
+    "",
+    "Description:",
+    issue.description?.trim() || "(empty)",
+  ];
+  if (issue.children.length > 0) {
+    lines.push("", "Sub-issues:");
+    for (const child of issue.children) lines.push(`- ${child.identifier} [${child.state.name}]: ${child.title}`);
+  }
+  return lines.filter((line) => line !== null).join("\n");
+}
+
+/** Opens the prompt of an agent that start_agent makes. */
+export function childBrief(key: string, root: string): string {
+  const parent = key.toUpperCase() === root.toUpperCase() ? "" : `, a sub-issue of ${root}`;
+  return [
+    `You work on Linear issue ${key}${parent}. Start your first reply with "${key}:".`,
+    `Use the ${TOOLS_SERVER} MCP tools: read_issue shows the issue, and edit_issue changes its description.`,
+    "Check off each task list item you finish by replacing `- [ ]` with `- [x]`. Do not post comments.",
+  ].join("\n");
+}

package/shared/graph-camera.ts

@@ -0,0 +1,93 @@
+import type { Point } from "./graph-geometry";
+import type { Graph } from "./graph-model";
+
+// The graph camera shifts and zooms the canvas, which scales around its center. A canvas
+// point p draws at center + shift + zoom * (p - center). Zoom 1 with no shift shows it all.
+
+export interface Camera {
+  x: number;
+  y: number;
+  zoom: number;
+}
+
+export interface Box {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+
+export const FIT: Camera = { x: 0, y: 0, zoom: 1 };
+export const MIN_ZOOM = 1;
+export const MAX_ZOOM = 4;
+/** Auto mode zooms no further than this, so the nodes around the agents stay in view. */
+const AUTO_ZOOM = 2.5;
+const PAD_X = 90;
+const PAD_Y = 56;
+
+const clamp = (value: number, low: number, high: number) => Math.min(high, Math.max(low, value));
+
+/** Where a canvas point draws in the view. */
+export function project(camera: Camera, at: Point, width: number, height: number): Point {
+  return {
+    x: width / 2 + camera.x + camera.zoom * (at.x - width / 2),
+    y: height / 2 + camera.y + camera.zoom * (at.y - height / 2),
+  };
+}
+
+/** The canvas point that draws at a point of the view. */
+export function unproject(camera: Camera, at: Point, width: number, height: number): Point {
+  return {
+    x: width / 2 + (at.x - width / 2 - camera.x) / camera.zoom,
+    y: height / 2 + (at.y - height / 2 - camera.y) / camera.zoom,
+  };
+}
+
+/** Keeps the zoom in range and the canvas edges at or past the edges of the view. */
+export function clampCamera(camera: Camera, width: number, height: number): Camera {
+  const zoom = clamp(camera.zoom, MIN_ZOOM, MAX_ZOOM);
+  const spanX = ((zoom - 1) * width) / 2;
+  const spanY = ((zoom - 1) * height) / 2;
+  return { zoom, x: clamp(camera.x, -spanX, spanX), y: clamp(camera.y, -spanY, spanY) };
+}
+
+/** Zooms by a factor and keeps the canvas point under `at` where it is. */
+export function zoomAt(camera: Camera, at: Point, factor: number, width: number, height: number): Camera {
+  const zoom = clamp(camera.zoom * factor, MIN_ZOOM, MAX_ZOOM);
+  const cx = width / 2;
+  const cy = height / 2;
+  const px = cx + (at.x - cx - camera.x) / camera.zoom;
+  const py = cy + (at.y - cy - camera.y) / camera.zoom;
+  return clampCamera({ zoom, x: at.x - cx - zoom * (px - cx), y: at.y - cy - zoom * (py - cy) }, width, height);
+}
+
+/** Shows the box as large as fits in the view, up to the auto zoom. */
+export function frameBox(box: Box, width: number, height: number): Camera {
+  const fit = Math.min(width / Math.max(1, box.right - box.left), height / Math.max(1, box.bottom - box.top));
+  const zoom = clamp(fit, MIN_ZOOM, AUTO_ZOOM);
+  const x = zoom * (width / 2 - (box.left + box.right) / 2);
+  const y = zoom * (height / 2 - (box.top + box.bottom) / 2);
+  return clampCamera({ zoom, x, y }, width, height);
+}
+
+// The area auto mode shows: the nodes the running agents work on and their neighbors, with
+// room for labels and cursors. Null when no agent works on a node other than the issue.
+export function focusBox(graph: Graph, positions: ReadonlyMap<string, Point>, targets: Iterable<string>): Box | null {
+  const ids = new Set<string>();
+  for (const target of targets) if (target !== graph.root) ids.add(target);
+  if (ids.size === 0) return null;
+  for (const edge of graph.edges) {
+    if (ids.has(edge.from) && edge.to !== graph.root) ids.add(edge.to);
+    else if (ids.has(edge.to) && edge.from !== graph.root) ids.add(edge.from);
+  }
+  let box: Box | null = null;
+  for (const id of ids) {
+    const at = positions.get(id);
+    if (!at) continue;
+    box = box
+      ? { left: Math.min(box.left, at.x), top: Math.min(box.top, at.y), right: Math.max(box.right, at.x), bottom: Math.max(box.bottom, at.y) }
+      : { left: at.x, top: at.y, right: at.x, bottom: at.y };
+  }
+  if (!box) return null;
+  return { left: box.left - PAD_X, top: box.top - PAD_Y, right: box.right + PAD_X, bottom: box.bottom + PAD_Y };
+}