@estebanforge/pi-antigravity-bridge 1.0.0

package/src/diff-render.ts

@@ -0,0 +1,190 @@
+// G8: surface agy's file edits as a diff in pi's thinking stream.
+//
+// agy edits with its OWN native `write_to_file` (full-file content), inside a
+// closed tool loop that lands changes on disk. pi's native colored diff viewer
+// is unreachable for agy turns (it is part of the tool-call lifecycle, and the
+// provider emits no toolCall blocks by design), so we compute a line-numbered
+// diff ourselves and stream it as text through the thinking channel, reusing
+// pi's own `generateDiffString` for an identical format.
+//
+// OLD content comes from git (the committed version), resolved PER FILE so
+// nested repos / submodules / multi-repo workspaces each diff against their
+// own HEAD. A turn-scoped cache makes multi-edit-same-file turns diff
+// incrementally instead of cumulatively. Off-repo / untracked / binary files
+// degrade to a one-line summary. See docs/PI-BRIDGE-GAPS.md (G8).
+
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { generateDiffString } from "@earendil-works/pi-coding-agent";
+
+/** Maximum diff lines emitted for one edit before truncation. */
+export const DEFAULT_MAX_DIFF_LINES = 100;
+
+/** Injectable git operations so the pure logic is unit-testable without a
+ *  real repo. `toplevel` returns null when the dir is not inside a git work
+ *  tree; `showHead` returns null when the path is untracked / absent from HEAD. */
+export interface GitOps {
+	toplevel(fileDir: string): string | null;
+	showHead(toplevel: string, relPath: string): string | null;
+}
+
+/** Default git ops via synchronous git CLI calls. Cheap; one process per call. */
+export function createExecGitOps(): GitOps {
+	const run = (args: string[], cwd: string): string | null => {
+		try {
+			return execFileSync("git", args, {
+				cwd,
+				encoding: "utf-8",
+				stdio: ["ignore", "pipe", "ignore"],
+			});
+		} catch {
+			return null;
+		}
+	};
+	return {
+		toplevel: (fileDir) => {
+			const t = run(["rev-parse", "--show-toplevel"], fileDir);
+			return t ? t.trim() || null : null;
+		},
+		showHead: (toplevel, relPath) => run(["show", `HEAD:${relPath}`], toplevel),
+	};
+}
+
+export type EditDiffKind = "diff" | "summary" | "binary" | "none";
+
+export interface EditDiffOutcome {
+	kind: EditDiffKind;
+	/** Text to append after the edit label in the thinking stream. Empty for
+	 *  `none` (nothing to show). */
+	text: string;
+}
+
+/** A parsed agy edit-tool invocation: a file path plus its full new content.
+ *  Detected generically by key name so future agy edit-tool variants work
+ *  without hardcoding tool names. */
+export interface ParsedEdit {
+	/** File path as agy wrote it (absolute or cwd-relative). */
+	file: string;
+	content: string;
+	description?: string;
+}
+
+/** True if the string looks like binary (contains a NUL byte). Mirrors git's
+ *  own heuristic; avoids feeding binary into the line differ. */
+function isBinary(s: string): boolean {
+	return s.includes("\u0000");
+}
+
+/** Parse an agy tool-call inputJson into an edit if it carries both a
+ *  file-path-like and a content-like string field. Returns null for non-edits
+ *  (reads, greps, malformed JSON, missing fields). */
+export function parseEditToolInput(inputJson: string): ParsedEdit | null {
+	if (!inputJson) return null;
+	let obj: Record<string, unknown>;
+	try {
+		obj = JSON.parse(inputJson);
+	} catch {
+		return null;
+	}
+	if (!obj || typeof obj !== "object") return null;
+	let file = "";
+	let content = "";
+	let description: string | undefined;
+	for (const [k, v] of Object.entries(obj)) {
+		if (typeof v !== "string") continue;
+		if (!file && /(^|_)?(file|path)$/i.test(k)) file = v;
+		else if (!content && /content|code/i.test(k)) content = v;
+		else if (!description && /description|toolaction|toolsummary/i.test(k)) description = v;
+	}
+	if (!file || !content) return null;
+	return { file, content, description };
+}
+
+/** Turn-scoped diff context. Holds the OLD-content cache (so the 2nd edit to
+ *  the same file in a turn diffs against the 1st edit's result, not HEAD again)
+ *  and a toplevel cache (one `rev-parse` per edited directory per turn).
+ *  Create one fresh per turn so concurrent turns never share state. */
+export class TurnDiffContext {
+	private readonly oldCache = new Map<string, string>();
+	private readonly toplevelCache = new Map<string, string | null>();
+	private readonly seenFiles = new Set<string>();
+
+	constructor(
+		private readonly git: GitOps,
+		private readonly maxDiffLines: number = DEFAULT_MAX_DIFF_LINES,
+	) {}
+
+	/** Compute the diff (or summary) for one edit. `absFile` must be absolute. */
+	diffEdit(absFile: string, newContent: string): EditDiffOutcome {
+		// Binary short-circuit before any git work.
+		if (isBinary(newContent)) {
+			this.oldCache.set(absFile, newContent);
+			return { kind: "binary", text: "(binary file; diff skipped)" };
+		}
+
+		const dir = path.dirname(absFile);
+		let toplevel = this.toplevelCache.get(dir);
+		if (toplevel === undefined) {
+			toplevel = this.git.toplevel(dir);
+			this.toplevelCache.set(dir, toplevel);
+		}
+
+		// Not inside any git repo: no OLD baseline available without a pre-turn
+		// snapshot (approach C, deferred). Degrade to a one-line summary.
+		if (!toplevel) {
+			this.oldCache.set(absFile, newContent);
+			return {
+				kind: "summary",
+				text: `(${countLines(newContent)} lines; not in a git repo, no diff)`,
+			};
+		}
+
+		const relPath = path.relative(toplevel, absFile);
+		// File lives outside its resolved repo (e.g. agy edited something under a
+		// sibling tree). Treat like off-repo: summary, no diff.
+		if (relPath.startsWith("..")) {
+			this.oldCache.set(absFile, newContent);
+			return {
+				kind: "summary",
+				text: `(${countLines(newContent)} lines; outside the git repo, no diff)`,
+			};
+		}
+
+		// OLD baseline: the prior edit's result if we've seen this file this
+		// turn, else the committed version (untracked/new file -> empty string).
+		let oldContent: string;
+		if (this.seenFiles.has(absFile) && this.oldCache.has(absFile)) {
+			oldContent = this.oldCache.get(absFile) ?? "";
+		} else {
+			const committed = this.git.showHead(toplevel, relPath);
+			oldContent = committed ?? "";
+		}
+		this.seenFiles.add(absFile);
+		this.oldCache.set(absFile, newContent);
+
+		if (isBinary(oldContent)) {
+			return { kind: "binary", text: "(was binary; diff skipped)" };
+		}
+		if (oldContent === newContent) {
+			return { kind: "none", text: "" };
+		}
+
+		const { diff } = generateDiffString(oldContent, newContent);
+		return { kind: "diff", text: capLines(diff, this.maxDiffLines) };
+	}
+}
+
+function countLines(s: string): number {
+	if (s.length === 0) return 0;
+	return s.split("\n").length;
+}
+
+/** Truncate a diff to at most `max` lines, keeping the head and noting how many
+ *  were dropped. A diff's changes are interspersed, so head-first is fine. */
+function capLines(diff: string, max: number): string {
+	if (max <= 0) return diff;
+	const lines = diff.split("\n");
+	if (lines.length <= max) return diff;
+	const dropped = lines.length - max;
+	return `${lines.slice(0, max).join("\n")}\n[... ${dropped} more diff lines]`;
+}

package/src/discovery.ts

@@ -0,0 +1,199 @@
+// Discover the agy conversation id that `agy -p` creates but never prints.
+//
+// agy's print mode writes its steps to a fresh SQLite DB at
+// ~/.gemini/antigravity-cli/conversations/<uuid>.db. It does NOT echo the id.
+// The only reliable bind is to snapshot the *.db stems in that dir before
+// spawn, then diff after: exactly one new file = ours. If several appear we
+// refuse to bind (can't tell which is ours)  -  same approach as antigravity-acp
+// (scan.ts), agy-acp (scan.ts), and pi-ask-antigravity.
+//
+// CONCURRENCY: when another agy (or subagent) starts in parallel, more than
+// one new .db can land in the dir during our turn. mtime filtering does NOT
+// disambiguate two *active* concurrent runs (both DBs are >= turn-start), and
+// prompt-content matching is fragile (the user-message step_type 98 payload
+// is undocumented and deeply nested; a field-number shift would silently
+// misbind). The authoritative signal is which candidate .db OUR spawned agy
+// process tree holds open right now  -  resolved via /proc/<pid>/fd on Linux.
+// When that signal is unavailable (no pid, non-Linux, process already exited,
+// or the scan itself is ambiguous) we fail safe to null, preserving the
+// original "refuse to bind" behavior rather than guessing.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+/** Default conversations dir. Override with AGY_CONVERSATIONS_DIR. */
+export const CONVERSATIONS_DIR =
+	process.env.AGY_CONVERSATIONS_DIR ||
+	path.join(os.homedir(), ".gemini", "antigravity-cli", "conversations");
+
+/** Snapshot the set of conversation ids (*.db stems) currently on disk.
+ *  Empty set (not throw) when the dir is missing  -  agy will create it. */
+export function snapshotConversations(dir: string = CONVERSATIONS_DIR): Set<string> {
+	const out = new Set<string>();
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(dir);
+	} catch {
+		return out;
+	}
+	for (const f of entries) {
+		if (f.endsWith(".db")) out.add(f.slice(0, -3));
+	}
+	return out;
+}
+
+/** Resolve which of the `candidates` DB ids is held open by the process tree
+ *  rooted at `rootPid`. Used to disambiguate concurrent agy runs.
+ *
+ *  Returns the single matching id, or null when none / several are open, when
+ *  /proc is unavailable, or when reading fails. Injectable so tests can stub
+ *  it without touching the filesystem. */
+export type OpenDbResolver = (
+	rootPid: number,
+	dir: string,
+	candidates: Set<string>,
+) => string | null;
+
+/** Read pid + ppid from /proc/<pid>/stat. Returns null when the entry is gone
+ *  (process exited) or unparseable. comm may contain spaces and parens, so we
+ *  split on the LAST ')' rather than naively tokenizing. */
+function readProcStat(pid: number): { pid: number; ppid: number } | null {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+	} catch {
+		return null;
+	}
+	const closeParen = raw.lastIndexOf(")");
+	if (closeParen < 0) return null;
+	// After "pid (comm)" come: state ppid pgrp session ...
+	const fields = raw.slice(closeParen + 2).trim().split(/\s+/);
+	const ppid = Number(fields[1]);
+	if (!Number.isFinite(ppid)) return null;
+	return { pid, ppid };
+}
+
+/** Collect rootPid and every descendant pid by walking /proc/<pid>/stat
+ *  parent links. Single pass over /proc building a pid->ppid map, then
+ *  iterated to closure. */
+function collectDescendants(rootPid: number): Set<number> {
+	const out = new Set<number>([rootPid]);
+	let entries: string[];
+	try {
+		entries = fs.readdirSync("/proc");
+	} catch {
+		return out;
+	}
+	const ppidOf = new Map<number, number>();
+	for (const e of entries) {
+		if (!/^\d+$/.test(e)) continue;
+		const s = readProcStat(Number(e));
+		if (s) ppidOf.set(s.pid, s.ppid);
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [pid, ppid] of ppidOf) {
+			if (out.has(pid)) continue;
+			if (out.has(ppid)) {
+				out.add(pid);
+				changed = true;
+			}
+		}
+	}
+	return out;
+}
+
+/** Linux /proc implementation of OpenDbResolver. Scans every FD symlink in
+ *  the root process's tree and returns the one candidate .db that is open.
+ *  Non-authoritative when zero or >1 candidates are open  -  caller fails safe. */
+export const procTreeOpenDbResolver: OpenDbResolver = (rootPid, dir, candidates) => {
+	if (candidates.size <= 1) return null; // nothing to disambiguate
+	if (process.platform !== "linux") return null; // /proc/<pid>/fd is Linux-only
+	const dirResolved = safeRealpath(dir);
+	const tree = collectDescendants(rootPid);
+	const found = new Set<string>();
+	for (const pid of tree) {
+		let fds: string[];
+		try {
+			fds = fs.readdirSync(`/proc/${pid}/fd`);
+		} catch {
+			continue; // process gone or fd dir unreadable
+		}
+		for (const fd of fds) {
+			let target: string;
+			try {
+				target = fs.readlinkSync(`/proc/${pid}/fd/${fd}`);
+			} catch {
+				continue;
+			}
+			// agy also holds .db-wal / .db-shm open; only the base .db matters.
+			const base = path.basename(target);
+			if (!base.endsWith(".db")) continue;
+			if (dirResolved && safeRealpath(path.dirname(target)) !== dirResolved) continue;
+			const id = base.slice(0, -3);
+			if (candidates.has(id)) found.add(id);
+		}
+	}
+	if (found.size === 1) return [...found][0] ?? null;
+	return null;
+};
+
+/** fs.realpathSync that swallows ENOENT (dir may not be canonicalized yet). */
+function safeRealpath(p: string): string | null {
+	try {
+		return fs.realpathSync(p);
+	} catch {
+		return null;
+	}
+}
+
+/** Options for {@link newConversationId}. */
+export interface BindOptions {
+	/** Pid of the spawned agy (the process we want to bind to). When set and
+	 *  multiple candidate DBs exist, the process-tree FD resolver tries to
+	 *  pick ours. Omit to keep the legacy fail-safe behavior. */
+	pid?: number;
+	/** Override resolver (tests). Defaults to the Linux /proc scanner. */
+	resolveOpenDb?: OpenDbResolver;
+	/** Invoked when the snapshot is ambiguous (more than one new DB since
+	 *  `before`) and the resolver could not authoritatively pick ours. Lets a
+	 *  caller bound its retry budget to the genuinely-ambiguous case only, so
+	 *  the ordinary "agy hasn't created its DB yet" wait is not counted
+	 *  against it. Not invoked when there is nothing new yet, or when exactly
+	 *  one new DB binds, or when the resolver succeeds. */
+	onAmbiguous?: () => void;
+}
+
+/** Find the conversation id created since `before`. Returns null when none
+ *  appeared, or when several appeared and we cannot authoritatively tie one
+ *  to our process. Pass `opts.pid` to enable concurrent-run disambiguation. */
+export function newConversationId(
+	dir: string,
+	before: Set<string>,
+	opts: BindOptions = {},
+): string | null {
+	const after = snapshotConversations(dir);
+	const created = [...after].filter((id) => !before.has(id));
+	if (created.length === 0) return null;
+	if (created.length === 1) return created[0] ?? null;
+	// Ambiguous: more than one new DB since the snapshot. Try to authoritatively
+	// identify ours via the spawned process's open files. Fail safe to null
+	// (refuse to bind) when the resolver can't pick exactly one.
+	if (opts.pid !== undefined) {
+		const resolve = opts.resolveOpenDb ?? procTreeOpenDbResolver;
+		const hit = resolve(opts.pid, dir, new Set(created));
+		if (hit && created.includes(hit)) return hit;
+	}
+	opts.onAmbiguous?.();
+	return null;
+}
+
+/** Path to the DB file for a given conversation id. */
+export function conversationDbPath(
+	id: string,
+	dir: string = CONVERSATIONS_DIR,
+): string {
+	return path.join(dir, `${id}.db`);
+}