pi-gortex 0.3.0 → 0.4.1

package/src/render.ts

@@ -1,18 +1,25 @@
 // TUI rendering for bridged tools: a call line read off Gortex's argument
 // shape (operation, target, options), Pi's own read renderer for a file read,
-// and a result collapsed until the user expands it.
+// an edit's diff, and a result collapsed until the user expands it.
 
-import { createReadToolDefinition } from "@earendil-works/pi-coding-agent";
-import type { Theme, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { createReadToolDefinition, renderDiff } from "@earendil-works/pi-coding-agent";
+import type { Theme, ToolDefinition, ToolRenderers } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import type { Component } from "@earendil-works/pi-tui";
 
+import type { EditDetails } from "./diff.ts";
 import { textFromResult } from "./mcp-client.ts";
+import { isNativeGortexTool } from "./native.ts";
 
 type ToolRenderContext = Parameters<NonNullable<ToolDefinition["renderCall"]>>[2];
 
 export type RenderCall = (args: Record<string, unknown>, theme: Theme, context: ToolRenderContext) => Component;
-export type RenderResult = (result: unknown, options: { expanded?: boolean }) => Component;
+export type RenderResult = (
+  result: unknown,
+  options: { expanded?: boolean },
+  theme?: Theme,
+  context?: ToolRenderContext,
+) => Component;
 
 const OPERATION_ARGS = ["operation", "kind"];
 const SUBJECT_ARGS = ["target", "query", "question", "task", "path"];
@@ -144,6 +151,56 @@ export function resultText(result: unknown): string {
   return textFromResult(result) || JSON.stringify(structured ?? result ?? {});
 }
 
-/** renderResult collapses the result to nothing until the user expands it with ctrl+o. */
-export const renderResult: RenderResult = (result, options) =>
-  new Text(options?.expanded ? resultText(result) : "", 0, 0);
+/** diffView draws each file an edit changed with Pi's diff renderer, or nothing when the result has none. */
+function diffView(result: unknown, theme: Theme | undefined, context: ToolRenderContext | undefined): Container | undefined {
+  const diffs = (result as { details?: EditDetails })?.details?.diffs;
+  if (!diffs?.length || !theme || context?.isError) return undefined;
+  const view = new Container();
+  for (const { path, diff, note } of diffs) {
+    view.addChild(new Spacer(1));
+    if (note) {
+      view.addChild(new Text(`${theme.fg("accent", path)} ${theme.fg("muted", note)}`, 1, 0));
+      continue;
+    }
+    if (diffs.length > 1) view.addChild(new Text(theme.fg("accent", path), 1, 0));
+    view.addChild(new Text(renderDiff(diff, { filePath: path }), 1, 0));
+  }
+  return view;
+}
+
+/**
+ * renderResult shows the diff of every file an edit changed, the way Pi's own
+ * edit does. Gortex's text reply stays collapsed until the user expands it
+ * with ctrl+o.
+ */
+export const renderResult: RenderResult = (result, options, theme, context) => {
+  const text = new Text(options?.expanded ? resultText(result) : "", 0, 0);
+  const view = diffView(result, theme, context);
+  if (!view) return text;
+  if (options?.expanded) view.addChild(text);
+  return view;
+};
+
+/**
+ * nativeRenderers draws the diffs watchNativeEdits stores above Pi's own MCP
+ * result, which shows once expanded or on an error. Every other tool keeps its
+ * renderers.
+ */
+export function nativeRenderers(toolName: string, next: () => ToolRenderers | undefined): ToolRenderers | undefined {
+  const base = next();
+  // Without a base, Pi's MCP extension fills in its own renderers.
+  if (!base || !isNativeGortexTool(toolName)) return base;
+  const baseResult = base.renderResult;
+  return {
+    ...base,
+    renderResult(result, options, theme, context) {
+      // Pi's renderer reuses lastComponent as its own and clears it.
+      const own = () => baseResult?.(result, options, theme, { ...context, lastComponent: undefined });
+      const rest = options.expanded || context.isError ? own() : undefined;
+      const view = diffView(result, theme, context);
+      if (!view) return rest ?? new Text("", 0, 0);
+      if (rest) view.addChild(rest);
+      return view;
+    },
+  };
+}

package/src/runtime.ts

@@ -32,7 +32,9 @@ export interface BridgeChild {
 export interface SpawnOpts {
   stdio?: "ignore" | ("pipe" | "ignore")[];
   detached?: boolean;
+  cwd?: string;
   env?: Record<string, string | undefined>;
+  windowsHide?: boolean;
 }
 
 export interface ExecFileSyncOpts {
@@ -40,6 +42,7 @@ export interface ExecFileSyncOpts {
   encoding?: "utf8";
   maxBuffer?: number;
   timeout?: number;
+  windowsHide?: boolean;
 }
 
 export interface ProcessDeps {

package/src/state.ts

@@ -33,6 +33,13 @@ let versionWarning = "";
  */
 export const gortexToolNames = new Set<string>();
 
+/**
+ * Registered names the daemon has since dropped from its list. Pi cannot
+ * unregister a tool, so these are switched off in the active set instead, and
+ * back on if the daemon lists them again.
+ */
+export const withdrawnToolNames = new Set<string>();
+
 export function getClient(): MCPStdioClient | null {
   return client;
 }

package/src/tools.ts

@@ -1,12 +1,15 @@
 // Tool registration: each tool the bridge lists becomes a native Pi tool whose
 // execute() forwards to tools/call.
 
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { candidatePaths, editDetails, isFileEdit, withFileDiffs } from "./diff.ts";
+import type { FileDiff } from "./diff.ts";
 
 import type { ToolDescriptor } from "./mcp-client.ts";
 import { callRenderer, readCallRenderer, renderResult, resultText } from "./render.ts";
 import type { RenderCall, RenderResult } from "./render.ts";
-import { getClient, gortexToolNames } from "./state.ts";
+import { getClient, gortexToolNames, withdrawnToolNames } from "./state.ts";
 import { toolNameMap } from "./hook.ts";
 
 // Pi's reserved built-in names (mirrors toolNameMap's keys). A bridge tool that
@@ -44,7 +47,13 @@ interface BridgeToolDefinition {
   label: string;
   description: string;
   parameters: unknown;
-  execute(toolCallId: string, params: Record<string, unknown>): Promise<unknown>;
+  execute(
+    toolCallId: string,
+    params: Record<string, unknown>,
+    signal: AbortSignal | undefined,
+    onUpdate: unknown,
+    ctx: ExtensionContext | undefined,
+  ): Promise<unknown>;
   renderCall: RenderCall;
   renderResult: RenderResult;
 }
@@ -86,12 +95,20 @@ export function registerOneTool(pi: ExtensionAPI, desc: ToolDescriptor): void {
     label: name,
     description: piAliasedDescription(name, piAliasName(name), (desc.description || name).trim()),
     parameters,
-    async execute(_id: string, params: Record<string, unknown>) {
+    async execute(_id, params, signal, _onUpdate, ctx) {
       const client = getClient();
       if (!client) throw new Error(`gortex ${name}: MCP bridge is not connected`);
+      const args = params ?? {};
+      const callTool = () => client.callTool(name, args, signal);
       let result: unknown;
+      let diffs: FileDiff[] = [];
       try {
-        result = await client.callTool(name, params ?? {});
+        if (ctx && isFileEdit(name, args)) {
+          const paths = candidatePaths(args, ctx.cwd);
+          ({ result, diffs } = await withFileDiffs(paths, ctx.cwd, callTool, (r) => !(r as { isError?: boolean })?.isError));
+        } else {
+          result = await callTool();
+        }
       } catch (err) {
         throw new Error(`gortex ${name} failed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -103,7 +120,7 @@ export function registerOneTool(pi: ExtensionAPI, desc: ToolDescriptor): void {
       }
       const text = resultText(result);
       if ((result as { isError?: boolean })?.isError) throw new Error(text || `gortex ${name} failed`);
-      return { content: [{ type: "text", text }], details: {} };
+      return { content: [{ type: "text", text }], details: editDetails(diffs) };
     },
     renderCall: (name === "read" ? readCallRenderer : callRenderer)(piAliasName(name)),
     renderResult,
@@ -115,13 +132,36 @@ export function registerOneTool(pi: ExtensionAPI, desc: ToolDescriptor): void {
 export async function registerGortexTools(pi: ExtensionAPI): Promise<void> {
   const client = getClient();
   if (!client) return;
+  const listed = new Set<string>();
   for (const desc of await client.listTools()) {
-    if (!desc) continue;
+    if (!desc?.name) continue;
     registerOneTool(pi, desc);
+    listed.add(piAliasName(desc.name));
+  }
+  matchActiveTools(pi, listed);
+}
+
+/** Keeps the tools offered to the model in step with the daemon's list. */
+function matchActiveTools(pi: ExtensionAPI, listed: Set<string>): void {
+  const dropped = [...gortexToolNames].filter((name) => !listed.has(name));
+  const relisted = [...withdrawnToolNames].filter((name) => listed.has(name));
+  if (dropped.length === 0 && relisted.length === 0) return;
+  for (const name of dropped) {
+    gortexToolNames.delete(name);
+    withdrawnToolNames.add(name);
+  }
+  for (const name of relisted) withdrawnToolNames.delete(name);
+  try {
+    const active = new Set(pi.getActiveTools());
+    for (const name of dropped) active.delete(name);
+    for (const name of relisted) active.add(name);
+    pi.setActiveTools([...active]);
+  } catch {
+    // an invalidated instance keeps its last tool set.
   }
 }
 
-/** Re-fetches the tool list after a list_changed and registers anything new. */
+/** Re-fetches the tool list after a list_changed and applies the difference. */
 export async function syncTools(pi: ExtensionAPI): Promise<void> {
   try {
     await registerGortexTools(pi);