pi-openai-codex-compat 0.0.1-alpha.0

package/extensions/openai-codex-compat/apply-patch-render.ts

@@ -0,0 +1,133 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Container, Text } from "@earendil-works/pi-tui";
+import { type ApplyPatchDetails, previewPatch } from "./apply-patch-engine.ts";
+import { ApplyPatchDiffComponent, isApplyPatchDetails } from "./apply-patch-diff-render.ts";
+import {
+  CodexToolSurfaceComponent,
+  type CodexToolBackgroundResolver,
+} from "./codex-tool-surface.ts";
+import { DEFAULT_CONFIG } from "./config.ts";
+
+export { formatApplyPatchRenderText } from "./apply-patch-diff-render.ts";
+
+type ApplyPatchArgs = {
+  patch: string;
+};
+
+type ApplyPatchRenderState = {
+  previewKey?: string;
+  previewPending?: boolean;
+  preview?: ApplyPatchDetails;
+};
+
+type ApplyPatchRenderContext = {
+  args: ApplyPatchArgs;
+  toolCallId: string;
+  invalidate: () => void;
+  lastComponent: unknown;
+  state: ApplyPatchRenderState;
+  cwd: string;
+  executionStarted: boolean;
+  argsComplete: boolean;
+  isPartial: boolean;
+  expanded: boolean;
+  showImages: boolean;
+  isError: boolean;
+};
+
+type ApplyPatchResult = {
+  content: Array<{ type: string; text?: string }>;
+  details?: unknown;
+};
+
+export function renderApplyPatchCall(
+  args: ApplyPatchArgs,
+  theme: Theme,
+  context: ApplyPatchRenderContext,
+  resolveBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+): Component {
+  const container = new Container();
+  container.addChild(new Text(theme.fg("toolTitle", theme.bold("apply_patch")), 0, 0));
+
+  if (context.isPartial) {
+    const state = context.state;
+    const patch = typeof args.patch === "string" ? args.patch : "";
+    if (context.argsComplete && patch) {
+      const previewKey = `${context.cwd}\0${patch}`;
+      if (state.previewKey !== previewKey) {
+        state.previewKey = previewKey;
+        delete state.preview;
+        state.previewPending = false;
+      }
+      if (!state.preview && !state.previewPending) {
+        state.previewPending = true;
+        void previewPatch(context.cwd, patch)
+          .then((preview) => {
+            if (state.previewKey === previewKey) state.preview = preview;
+          })
+          .catch(() => {})
+          .finally(() => {
+            if (state.previewKey === previewKey) {
+              state.previewPending = false;
+              context.invalidate();
+            }
+          });
+      }
+    }
+
+    if (isApplyPatchDetails(state.preview)) {
+      container.addChild(
+        new ApplyPatchDiffComponent(state.preview, theme, context.cwd, context.expanded),
+      );
+    }
+  }
+
+  return new CodexToolSurfaceComponent(container, theme, {
+    background: resolveBackground,
+    status: context.isPartial ? "pending" : context.isError ? "error" : "success",
+    top: true,
+    bottom: context.isPartial,
+  });
+}
+
+export function renderApplyPatchResult(
+  result: ApplyPatchResult,
+  options: { isPartial: boolean },
+  theme: Theme,
+  context: ApplyPatchRenderContext,
+  resolveBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+): Component {
+  if (options.isPartial) return new Container();
+
+  const details = isApplyPatchDetails(result.details) ? result.details : undefined;
+  const preview = isApplyPatchDetails(context.state.preview) ? context.state.preview : undefined;
+  const renderDetails =
+    details?.status === "failed" && preview
+      ? {
+          ...preview,
+          status: "failed" as const,
+          ...(details.error !== undefined ? { error: details.error } : {}),
+        }
+      : details;
+
+  if (renderDetails) {
+    return new CodexToolSurfaceComponent(
+      new ApplyPatchDiffComponent(renderDetails, theme, context.cwd, context.expanded),
+      theme,
+      {
+        background: resolveBackground,
+        status: context.isError ? "error" : "success",
+        top: false,
+        bottom: true,
+      },
+    );
+  }
+  const text = context.isError ? theme.bold(theme.fg("error", "✘ Failed to apply patch")) : "";
+  if (!text) return new Container();
+  return new CodexToolSurfaceComponent(new Text(text, 0, 0), theme, {
+    background: resolveBackground,
+    status: "error",
+    top: false,
+    bottom: true,
+  });
+}

package/extensions/openai-codex-compat/apply-patch.ts

@@ -0,0 +1,142 @@
+import { performance } from "node:perf_hooks";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { CodexToolBackgroundResolver } from "./codex-tool-surface.ts";
+import { DEFAULT_CONFIG } from "./config.ts";
+import {
+  applyPatch,
+  type ApplyPatchDetails,
+  ApplyPatchExecutionError,
+  formatApplyPatchModelOutput,
+  formatApplyPatchSummary,
+} from "./apply-patch-engine.ts";
+import { renderApplyPatchCall, renderApplyPatchResult } from "./apply-patch-render.ts";
+
+export {
+  applyPatch,
+  type ApplyPatchDetails,
+  type AppliedPatchChange,
+  ApplyPatchExecutionError,
+  ApplyPatchInputError,
+  ApplyPatchParseError,
+  ApplyPatchVerificationError,
+  type ParsedPatch,
+  type PatchOperation,
+  type UpdateChunk,
+  parsePatch,
+  parsePatchDocument,
+  previewPatch,
+} from "./apply-patch-engine.ts";
+
+export const APPLY_PATCH_TOOL_NAME = "apply_patch";
+export const APPLY_PATCH_INPUT_PROPERTY = "patch";
+
+// Adapted from OpenAI Codex's Apache-2.0 apply_patch grammar; see
+// THIRD_PARTY_NOTICES.md. Pi serializes it as a native custom grammar tool for
+// capable models and falls back to an ordinary function tool elsewhere.
+export const APPLY_PATCH_LARK_GRAMMAR = String.raw`start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF`;
+
+export default function registerApplyPatch(
+  pi: ExtensionAPI,
+  resolveToolBackground: CodexToolBackgroundResolver = () => DEFAULT_CONFIG.toolBackground,
+): void {
+  const failedDetails = new Map<string, ApplyPatchDetails>();
+
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== APPLY_PATCH_TOOL_NAME) return;
+    const details = failedDetails.get(event.toolCallId);
+    if (!details) return;
+    failedDetails.delete(event.toolCallId);
+    return { details };
+  });
+
+  pi.registerTool({
+    name: APPLY_PATCH_TOOL_NAME,
+    label: APPLY_PATCH_TOOL_NAME,
+    description:
+      "The `apply_patch` tool can be used to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.",
+    promptSnippet: "Apply Codex-format patches to add, edit, move, or delete files",
+    promptGuidelines: [
+      "Use apply_patch for local file edits.",
+      "Do not create or edit files with cat or other shell write tricks.",
+      "Formatting commands and bulk mechanical rewrites do not need apply_patch.",
+      "Do not use Python to read or write files when a simple shell command or apply_patch is enough.",
+    ],
+    parameters: Type.Object({
+      patch: Type.String({ description: "Raw patch text beginning with *** Begin Patch" }),
+    }),
+    constrainedSampling: {
+      type: "grammar",
+      variants: { openai_lark: APPLY_PATCH_LARK_GRAMMAR },
+    },
+    executionMode: "sequential",
+    renderShell: "self",
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      let executionStartedAt: number | undefined;
+      const executionDurationMs = (): number => {
+        if (executionStartedAt === undefined) {
+          throw new Error("apply_patch execution timing was not initialized.");
+        }
+        return performance.now() - executionStartedAt;
+      };
+      try {
+        const details = await applyPatch(ctx.cwd, params.patch, signal, {
+          onExecutionStart() {
+            executionStartedAt = performance.now();
+          },
+          onProgress(partialDetails) {
+            onUpdate?.({
+              content: [{ type: "text", text: "" }],
+              details: partialDetails,
+            });
+          },
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatApplyPatchModelOutput(
+                0,
+                executionDurationMs(),
+                formatApplyPatchSummary(details),
+              ),
+            },
+          ],
+          details,
+        };
+      } catch (error) {
+        if (error instanceof ApplyPatchExecutionError) {
+          failedDetails.set(toolCallId, error.details);
+          throw new Error(
+            formatApplyPatchModelOutput(1, executionDurationMs(), `${error.message}\n`),
+          );
+        }
+        throw error;
+      }
+    },
+    renderCall(args, theme, context) {
+      return renderApplyPatchCall(args, theme, context, resolveToolBackground);
+    },
+    renderResult(result, options, theme, context) {
+      return renderApplyPatchResult(result, options, theme, context, resolveToolBackground);
+    },
+  });
+}