@mrclrchtr/supi-antigravity 6.4.0

package/src/tool/antigravity_run/render.ts

@@ -0,0 +1,236 @@
+/** Compact TUI renderers for Antigravity Run calls and results. */
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import type {
+  AntigravityRunResultDetails,
+  ClassifiedSource,
+  ClassifiedWorkspaceEvidence,
+} from "../../types.ts";
+import { ANTIGRAVITY_RUN_TOOL_LABEL } from "./spec.ts";
+
+const MAX_PROMPT_PREVIEW = 120;
+const MAX_ERROR_PREVIEW = 500;
+
+/** Render the tool name, safe prompt preview, model, and workspace status. */
+export function renderAntigravityCall(args: unknown, theme: Theme, _context?: unknown): Text {
+  const params = isRecord(args) ? args : {};
+  const prompt = typeof params.prompt === "string" ? safePreview(params.prompt) : undefined;
+  const newInput = isRecord(params.new) ? params.new : undefined;
+  const model = typeof newInput?.model === "string" ? newInput.model : undefined;
+  const workspace = typeof newInput?.workspace === "boolean" ? newInput.workspace : undefined;
+  const continuation = isRecord(params.continue);
+  const parts = [
+    theme.fg("toolTitle", ANTIGRAVITY_RUN_TOOL_LABEL),
+    model ? theme.fg("accent", model) : continuation ? theme.fg("accent", "follow-up") : undefined,
+    workspace === undefined
+      ? undefined
+      : theme.fg("dim", workspace ? "workspace" : "Consultation Workspace"),
+    prompt ? theme.fg("dim", `· ${prompt}`) : undefined,
+  ].filter((part): part is string => part !== undefined);
+  return new Text(parts.join(" "), 0, 0);
+}
+
+/** Render partial, collapsed, expanded, and error Antigravity states. */
+export function renderAntigravityResult(
+  result: {
+    content?: Array<{ type: string; text?: string }>;
+    details?: unknown;
+    isError?: boolean;
+  },
+  options: { expanded: boolean; isPartial: boolean },
+  theme: Theme,
+  context: { isError?: boolean } = {},
+): Container | Text {
+  if (options.isPartial) return renderPartial(result.details, options.expanded, theme);
+  if (result.isError || context.isError)
+    return renderError(result.content, options.expanded, theme);
+  const details = asDetails(result.details);
+  if (!details) return new Text(theme.fg("dim", "Antigravity Run finished."), 0, 0);
+  return options.expanded
+    ? renderExpanded(details, result.content, theme)
+    : renderCollapsed(details, theme);
+}
+
+function renderPartial(detailsValue: unknown, expanded: boolean, theme: Theme): Text | Container {
+  const details = isRecord(detailsValue) ? detailsValue : {};
+  const model = typeof details.model === "string" ? details.model : "model pending";
+  const workspace = details.workspaceAccess === true ? "workspace" : "Consultation Workspace";
+  const activity =
+    typeof details.latestActivity === "string" ? safePreview(details.latestActivity) : "preparing";
+  const line = theme.fg("warning", `● ${ANTIGRAVITY_RUN_TOOL_LABEL} · ${model} · ${workspace}`);
+  if (!expanded) return new Text(`${line}\n${theme.fg("dim", activity)}`, 0, 0);
+  const container = new Container();
+  container.addChild(new Text(line, 0, 0));
+  container.addChild(new Text(theme.fg("dim", `activity: ${activity}`), 1, 0));
+  return container;
+}
+
+function renderCollapsed(details: AntigravityRunResultDetails, theme: Theme): Text {
+  const usage = formatUsage(details.usage);
+  const evidence = [
+    `${details.observedSources.length} observed source${details.observedSources.length === 1 ? "" : "s"}`,
+    `${details.observedWorkspaceEvidence.length} observed path${details.observedWorkspaceEvidence.length === 1 ? "" : "s"}`,
+  ];
+  if (usage) evidence.push(usage);
+  const warning = details.warnings.length > 0 ? ` · ${details.warnings.length} warning(s)` : "";
+  return new Text(
+    `${theme.fg("success", "✓ Antigravity Run complete")} · ${details.handle} · ${evidence.join(" · ")}${warning}`,
+    0,
+    0,
+  );
+}
+
+function renderExpanded(
+  details: AntigravityRunResultDetails,
+  content: Array<{ type: string; text?: string }> | undefined,
+  theme: Theme,
+): Container {
+  const container = new Container();
+  container.addChild(
+    new Text(
+      theme.fg(
+        "accent",
+        `${theme.bold("Antigravity Run complete")} · ${details.model} · ${details.workingDirectoryKind}`,
+      ),
+      0,
+      0,
+    ),
+  );
+  container.addChild(new Text(theme.fg("dim", `handle: ${details.handle}`), 1, 0));
+  container.addChild(
+    new Text(
+      theme.fg(
+        "dim",
+        `CLI: ${details.cliVersion} · ${formatUsage(details.usage) || "usage unavailable"}`,
+      ),
+      1,
+      0,
+    ),
+  );
+  container.addChild(
+    new Text(
+      theme.fg(
+        "dim",
+        `web: ${details.webUsed ? "used" : "not used"} · workspace: ${details.workspaceUsed ? "used" : "not used"} · project guidance: ${details.ambientProjectGuidanceAvailable ? "available" : "not available"}`,
+      ),
+      1,
+      0,
+    ),
+  );
+  renderSources(container, "Observed sources", details.observedSources, theme);
+  renderSources(container, "Claimed sources", details.claimedSources, theme);
+  renderWorkspace(container, "Observed workspace paths", details.observedWorkspaceEvidence, theme);
+  renderWorkspace(container, "Claimed workspace paths", details.claimedWorkspaceEvidence, theme);
+  if (details.warnings.length > 0) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("warning", "Warnings"), 1, 0));
+    for (const warning of details.warnings)
+      container.addChild(new Text(theme.fg("dim", `- ${warning}`), 1, 0));
+  }
+  const markdown = content?.find((item) => item.type === "text")?.text;
+  if (markdown) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Markdown(markdown, 1, 0, getMarkdownTheme()));
+  }
+  return container;
+}
+
+function renderSources(
+  container: Container,
+  title: string,
+  sources: readonly ClassifiedSource[],
+  theme: Theme,
+): void {
+  if (sources.length === 0) return;
+  container.addChild(new Spacer(1));
+  container.addChild(new Text(theme.fg("muted", title), 1, 0));
+  for (const source of sources) {
+    container.addChild(
+      new Text(theme.fg("dim", `- ${safePreview(source.title)}: ${source.url}`), 2, 0),
+    );
+  }
+}
+
+function renderWorkspace(
+  container: Container,
+  title: string,
+  evidence: readonly ClassifiedWorkspaceEvidence[],
+  theme: Theme,
+): void {
+  if (evidence.length === 0) return;
+  container.addChild(new Spacer(1));
+  container.addChild(new Text(theme.fg("muted", title), 1, 0));
+  for (const item of evidence) {
+    container.addChild(
+      new Text(theme.fg("dim", `- ${item.path}: ${safePreview(item.summary)}`), 2, 0),
+    );
+  }
+}
+
+function renderError(
+  content: Array<{ type: string; text?: string }> | undefined,
+  expanded: boolean,
+  theme: Theme,
+): Text {
+  const text = content?.find((item) => item.type === "text")?.text;
+  const message = text ? safePreview(text, expanded ? MAX_ERROR_PREVIEW : 160) : "operation failed";
+  return new Text(theme.fg("error", `Antigravity Run failed: ${message}`), 0, 0);
+}
+
+function asDetails(value: unknown): AntigravityRunResultDetails | undefined {
+  if (!isRecord(value)) return undefined;
+  if (
+    typeof value.model !== "string" ||
+    typeof value.handle !== "string" ||
+    typeof value.cliVersion !== "string" ||
+    (value.workingDirectoryKind !== "workspace" && value.workingDirectoryKind !== "consultation") ||
+    !Array.isArray(value.observedSources) ||
+    !Array.isArray(value.claimedSources) ||
+    !Array.isArray(value.observedWorkspaceEvidence) ||
+    !Array.isArray(value.claimedWorkspaceEvidence) ||
+    !Array.isArray(value.warnings) ||
+    !value.observedSources.every(isClassifiedSource) ||
+    !value.claimedSources.every(isClassifiedSource) ||
+    !value.observedWorkspaceEvidence.every(isClassifiedWorkspaceEvidence) ||
+    !value.claimedWorkspaceEvidence.every(isClassifiedWorkspaceEvidence) ||
+    !value.warnings.every((warning) => typeof warning === "string")
+  ) {
+    return undefined;
+  }
+  return value as unknown as AntigravityRunResultDetails;
+}
+
+function formatUsage(
+  usage: { totalTokens?: number; inputTokens?: number; outputTokens?: number } | undefined,
+): string {
+  if (!usage) return "";
+  const total = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+  return `${total.toLocaleString("en-US")} tokens`;
+}
+
+function isClassifiedSource(value: unknown): value is ClassifiedSource {
+  return (
+    isRecord(value) &&
+    typeof value.title === "string" &&
+    typeof value.url === "string" &&
+    (value.evidence === "observed" || value.evidence === "claimed")
+  );
+}
+
+function isClassifiedWorkspaceEvidence(value: unknown): value is ClassifiedWorkspaceEvidence {
+  return (
+    isRecord(value) &&
+    typeof value.path === "string" &&
+    typeof value.summary === "string" &&
+    (value.evidence === "observed" || value.evidence === "claimed")
+  );
+}
+
+function safePreview(value: string, maxLength = MAX_PROMPT_PREVIEW): string {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1)}…`;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/tool/antigravity_run/result.ts

@@ -0,0 +1,186 @@
+import type { Usage } from "@earendil-works/pi-ai";
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { isWebToolName, isWorkspaceToolName } from "../../activity.ts";
+import type {
+  AntigravityExecutionFacts,
+  AntigravityRunResultDetails,
+  AntigravityUsage,
+  ClassifiedSource,
+  ClassifiedWorkspaceEvidence,
+  ConversationHandleRecord,
+} from "../../types.ts";
+import { classifyAnswerEvidence } from "./evidence.ts";
+
+/** PI's hard result bounds for model-visible Antigravity output. */
+export const MAX_RESULT_BYTES = 50 * 1024;
+export const MAX_RESULT_LINES = 2_000;
+
+/** Inputs needed to assemble one completed Antigravity Run result. */
+export interface AntigravityResultOptions {
+  facts: AntigravityExecutionFacts;
+  handle: ConversationHandleRecord;
+  durationMs: number;
+  hookWarning?: string;
+}
+
+/** Assemble model-visible evidence and free structured renderer details. */
+export function buildAntigravityResult(
+  options: AntigravityResultOptions,
+): AgentToolResult<AntigravityRunResultDetails> {
+  const { facts, handle } = options;
+  const evidence = classifyAnswerEvidence(facts.answer, facts, handle.canonicalWorkingDirectory);
+  const webUsed = facts.successfulToolNames.some(isWebToolName);
+  const workspaceUsed = facts.successfulToolNames.some(isWorkspaceToolName);
+  const warnings = buildWarnings({
+    evidenceWarnings: evidence.warnings,
+    observedSourceCount: evidence.observedSources.length,
+    observedWorkspaceEvidenceCount: evidence.observedWorkspaceEvidence.length,
+    webUsed,
+    workspaceUsed,
+    permissionDenials: facts.permissionDenials,
+    hookWarning: options.hookWarning,
+  });
+  const details: AntigravityRunResultDetails = {
+    model: handle.model,
+    workingDirectoryKind: handle.workspaceAccess ? "workspace" : "consultation",
+    canonicalWorkingDirectory: handle.canonicalWorkingDirectory,
+    workspaceAccess: handle.workspaceAccess,
+    cliVersion: handle.cliVersion,
+    durationMs: Math.max(0, Math.floor(options.durationMs)),
+    ...(facts.usage ? { usage: facts.usage } : {}),
+    observedToolNames: facts.observedToolNames,
+    observedToolCounts: facts.observedToolCounts,
+    permissionDenials: facts.permissionDenials,
+    webUsed,
+    workspaceUsed,
+    ambientProjectGuidanceAvailable: handle.workspaceAccess,
+    ...(options.hookWarning ? { activeProjectHookWarning: options.hookWarning } : {}),
+    handle: handle.handle,
+    rawAntigravityId: handle.rawAntigravityId,
+    handleState: "active",
+    observedSources: evidence.observedSources,
+    claimedSources: evidence.claimedSources,
+    observedWorkspaceEvidence: evidence.observedWorkspaceEvidence,
+    claimedWorkspaceEvidence: evidence.claimedWorkspaceEvidence,
+    warnings,
+  };
+  const text = formatModelResult(facts.answer.answer, details);
+  return {
+    content: [{ type: "text", text }],
+    details,
+    ...(facts.usage ? { usage: toPiUsage(facts.usage) } : {}),
+  };
+}
+
+function formatModelResult(answer: string, details: AntigravityRunResultDetails): string {
+  const sections = [
+    answer.trim(),
+    "",
+    `Web Capability: ${details.webUsed ? "used" : "not used"}`,
+    `Workspace Access: ${details.workspaceAccess ? "current workspace" : "Consultation Workspace"}`,
+    `Ambient Project Guidance: ${details.ambientProjectGuidanceAvailable ? "available" : "not available"}`,
+    formatSources("Observed Sources", details.observedSources),
+    formatSources("Claimed Sources (not observed)", details.claimedSources),
+    formatWorkspace("Observed Workspace Evidence", details.observedWorkspaceEvidence),
+    formatWorkspace("Claimed Workspace Evidence (not observed)", details.claimedWorkspaceEvidence),
+    formatWarnings(details.warnings),
+    `Conversation Handle: ${details.handle}`,
+  ];
+  return boundResult(sections.filter((section) => section.length > 0).join("\n"));
+}
+
+function formatSources(title: string, sources: readonly ClassifiedSource[]): string {
+  if (sources.length === 0) return `${title}: none`;
+  return [
+    title,
+    ...sources.map((source) => `- [${safeMarkdown(source.title)}](${source.url})`),
+  ].join("\n");
+}
+
+function formatWorkspace(title: string, evidence: readonly ClassifiedWorkspaceEvidence[]): string {
+  if (evidence.length === 0) return `${title}: none`;
+  return [title, ...evidence.map((item) => `- ${item.path}: ${safeMarkdown(item.summary)}`)].join(
+    "\n",
+  );
+}
+
+function formatWarnings(warnings: readonly string[]): string {
+  return warnings.length > 0
+    ? ["Warnings", ...warnings.map((warning) => `- ${warning}`)].join("\n")
+    : "Warnings: none";
+}
+
+function buildWarnings(options: {
+  evidenceWarnings: readonly string[];
+  observedSourceCount: number;
+  observedWorkspaceEvidenceCount: number;
+  webUsed: boolean;
+  workspaceUsed: boolean;
+  permissionDenials: number;
+  hookWarning?: string;
+}): string[] {
+  const warnings = [...options.evidenceWarnings];
+  if (options.hookWarning) warnings.push(options.hookWarning);
+  if (options.permissionDenials > 0) {
+    warnings.push(
+      `${options.permissionDenials} Antigravity tool action(s) were denied by permissions.`,
+    );
+  }
+  if (options.webUsed && options.observedSourceCount === 0) {
+    warnings.push("Antigravity used web tools, but no source URL was observed in the answer.");
+  }
+  if (options.workspaceUsed && options.observedWorkspaceEvidenceCount === 0) {
+    warnings.push(
+      "Antigravity used workspace tools, but no workspace path was observed in the answer.",
+    );
+  }
+  return [...new Set(warnings)].slice(0, 24);
+}
+
+function boundResult(value: string): string {
+  const lines = value.split(/\r?\n/);
+  const result = lines.slice(0, MAX_RESULT_LINES).join("\n");
+  const truncated =
+    lines.length > MAX_RESULT_LINES || Buffer.byteLength(result, "utf8") > MAX_RESULT_BYTES;
+  if (!truncated) return result;
+
+  const marker = "[Antigravity result truncated to PI limits]";
+  const markerBytes = Buffer.byteLength(marker, "utf8") + 1;
+  const contentLimit = Math.max(0, MAX_RESULT_BYTES - markerBytes);
+  const contentLines = result.split(/\r?\n/).slice(0, MAX_RESULT_LINES - 1);
+  const content = truncateUtf8(contentLines.join("\n"), contentLimit);
+  return content ? `${content}\n${marker}` : marker;
+}
+
+function truncateUtf8(value: string, maxBytes: number): string {
+  let bytes = 0;
+  let result = "";
+  for (const character of value) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + characterBytes > maxBytes) break;
+    result += character;
+    bytes += characterBytes;
+  }
+  return result;
+}
+
+function safeMarkdown(value: string): string {
+  return value
+    .replaceAll("[", "\\[")
+    .replaceAll("]", "\\]")
+    .replace(/[\r\n]/g, " ");
+}
+
+function toPiUsage(usage: AntigravityUsage): Usage {
+  const input = usage.inputTokens ?? 0;
+  const output = usage.outputTokens ?? 0;
+  const totalTokens = usage.totalTokens ?? input + output;
+  return {
+    input,
+    output,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+}

package/src/tool/antigravity_run/spec.ts

@@ -0,0 +1,20 @@
+import type { TSchema } from "typebox";
+import type { CuratedModel } from "../../types.ts";
+import { buildAntigravityRunSchema } from "./input.ts";
+
+/** Canonical Antigravity tool name. */
+export const ANTIGRAVITY_RUN_TOOL_NAME = "antigravity_run";
+/** Human-facing Antigravity tool label. */
+export const ANTIGRAVITY_RUN_TOOL_LABEL = "Antigravity Run";
+
+/** Build the provider-facing parameters from one immutable Model Catalogue. */
+export function buildAntigravityRunParameters(catalogue: readonly CuratedModel[]): TSchema {
+  return buildAntigravityRunSchema(catalogue);
+}
+
+/** Canonical machine-readable metadata for antigravity_run. */
+export const antigravityRunSpec = {
+  name: ANTIGRAVITY_RUN_TOOL_NAME,
+  label: ANTIGRAVITY_RUN_TOOL_LABEL,
+  executionMode: "parallel",
+} as const;

package/src/types.ts

@@ -0,0 +1,107 @@
+/** The four model choices SuPi may expose to a new Antigravity Run. */
+export const CURATED_MODELS = Object.freeze([
+  "gemini-3.8-flash-low",
+  "gemini-3.8-flash-medium",
+  "gemini-3.8-flash-high",
+  "gemini-3.1-pro-high",
+] as const);
+
+/** A model in the discovered Model Catalogue. */
+export type CuratedModel = (typeof CURATED_MODELS)[number];
+
+/** Return whether a value is one of the four curated model IDs. */
+export function isCuratedModel(value: unknown): value is CuratedModel {
+  return typeof value === "string" && CURATED_MODELS.includes(value as CuratedModel);
+}
+
+/** Workspace choice made by the caller. */
+export type WorkspaceAccess = boolean;
+
+/** A source returned by Antigravity's structured answer. */
+export interface AntigravitySource {
+  title: string;
+  url: string;
+}
+
+/** A workspace path returned by Antigravity's structured answer. */
+export interface AntigravityWorkspaceEvidence {
+  path: string;
+  summary: string;
+}
+
+/** The exact structured answer required from Antigravity. */
+export interface AntigravityAnswer {
+  answer: string;
+  sources: AntigravitySource[];
+  workspaceEvidence: AntigravityWorkspaceEvidence[];
+}
+
+/** Bounded token accounting reported by the Antigravity CLI. */
+export interface AntigravityUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+
+/** A validated answer reference classified by its execution evidence. */
+export interface ClassifiedSource extends AntigravitySource {
+  evidence: "observed" | "claimed";
+}
+
+/** A validated workspace reference classified by its execution evidence. */
+export interface ClassifiedWorkspaceEvidence extends AntigravityWorkspaceEvidence {
+  evidence: "observed" | "claimed";
+}
+
+/** Safe process facts collected without retaining stream events. */
+export interface AntigravityExecutionFacts {
+  answer: AntigravityAnswer;
+  conversationId: string;
+  usage?: AntigravityUsage;
+  observedToolNames: string[];
+  observedToolCounts: Record<string, number>;
+  successfulToolNames: string[];
+  permissionDenials: number;
+  observedSourceHashes: string[];
+  observedWorkspacePathHashes: string[];
+}
+
+/** State persisted for one opaque Conversation Handle. */
+export interface ConversationHandleRecord {
+  handle: string;
+  rawAntigravityId: string;
+  model: CuratedModel;
+  canonicalWorkingDirectory: string;
+  workspaceAccess: WorkspaceAccess;
+  cliVersion: string;
+  status: "active" | "retired";
+}
+
+/** Human and model-visible details for one completed Antigravity Run. */
+export interface AntigravityRunResultDetails {
+  model: CuratedModel;
+  workingDirectoryKind: "consultation" | "workspace";
+  canonicalWorkingDirectory: string;
+  workspaceAccess: WorkspaceAccess;
+  cliVersion: string;
+  durationMs: number;
+  usage?: AntigravityUsage;
+  observedToolNames: string[];
+  observedToolCounts: Record<string, number>;
+  permissionDenials: number;
+  webUsed: boolean;
+  workspaceUsed: boolean;
+  ambientProjectGuidanceAvailable: boolean;
+  activeProjectHookWarning?: string;
+  handle: string;
+  rawAntigravityId: string;
+  handleState: "active";
+  observedSources: ClassifiedSource[];
+  claimedSources: ClassifiedSource[];
+  observedWorkspaceEvidence: ClassifiedWorkspaceEvidence[];
+  claimedWorkspaceEvidence: ClassifiedWorkspaceEvidence[];
+  warnings: string[];
+}
+
+/** Optional callback for safe progress activity. */
+export type AntigravityProgressCallback = (activity: string) => void;