@tt-a1i/openpi 0.1.1 → 0.2.0

package/extensions/execution-convergence/workspace-provenance.ts

@@ -0,0 +1,338 @@
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+
+type Origin = "baseline" | "session_created";
+
+interface PendingEffects {
+  creations: Array<{
+    path: string;
+    existed: boolean;
+    observeOnCommandError: boolean;
+  }>;
+  removals: string[];
+}
+
+interface Options {
+  confirmDelete: (paths: readonly string[]) => Promise<boolean>;
+}
+
+interface BashAttempt {
+  id: string;
+  command: string;
+  cwd: string;
+}
+
+interface WriteAttempt {
+  id: string;
+  path: string;
+  cwd: string;
+}
+
+interface ShellInspection {
+  creations: string[];
+  removals: string[];
+  opaqueDestructiveCommand: boolean;
+}
+
+const DYNAMIC_PATH = /[*?[$`]/u;
+
+function splitShellSegments(command: string) {
+  const segments: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index] ?? "";
+    const next = command[index + 1] ?? "";
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (
+      char === "\n" ||
+      char === ";" ||
+      (char === "&" && next === "&") ||
+      (char === "|" && next === "|")
+    ) {
+      if (current.trim()) segments.push(current.trim());
+      current = "";
+      if ((char === "&" || char === "|") && next === char) index += 1;
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) segments.push(current.trim());
+  return segments;
+}
+
+function shellTokens(segment: string) {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaped = false;
+  const push = () => {
+    if (!current) return;
+    tokens.push(current);
+    current = "";
+  };
+  for (const char of segment) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = undefined;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      push();
+      continue;
+    }
+    if (char === ">") {
+      push();
+      tokens.push(">");
+      continue;
+    }
+    current += char;
+  }
+  push();
+  return tokens;
+}
+
+function literalPath(value: string | undefined) {
+  if (!value || value === "--" || DYNAMIC_PATH.test(value)) return undefined;
+  return value;
+}
+
+function inspectShell(command: string): ShellInspection {
+  const creations = new Set<string>();
+  const removals = new Set<string>();
+  let opaqueDestructiveCommand = false;
+  for (const segment of splitShellSegments(command)) {
+    const tokens = shellTokens(segment);
+    const nestedBash = tokens.findIndex(
+      (token, index) =>
+        token.split("/").at(-1) === "bash" && tokens[index + 1] === "-c",
+    );
+    if (nestedBash >= 0) {
+      const nestedCommand = tokens[nestedBash + 2];
+      if (nestedCommand) {
+        const nested: ShellInspection = inspectShell(nestedCommand);
+        for (const target of nested.creations) creations.add(target);
+        for (const target of nested.removals) removals.add(target);
+        opaqueDestructiveCommand ||= nested.opaqueDestructiveCommand;
+      }
+      continue;
+    }
+    for (let index = 0; index < tokens.length; index += 1) {
+      if (tokens[index] !== ">") continue;
+      const target = literalPath(tokens[index + 1]);
+      if (target) creations.add(target);
+    }
+
+    const executable = tokens[0]?.split("/").at(-1);
+    if (executable === "mkdir") {
+      const targets: string[] = [];
+      let afterOptions = false;
+      let supported = true;
+      for (const token of tokens.slice(1)) {
+        if (!afterOptions && token === "--") {
+          afterOptions = true;
+          continue;
+        }
+        if (!afterOptions && (token === "-p" || token === "--parents")) {
+          continue;
+        }
+        if (!afterOptions && token.startsWith("-")) {
+          supported = false;
+          break;
+        }
+        const target = literalPath(token);
+        if (!target) {
+          supported = false;
+          break;
+        }
+        targets.push(target);
+      }
+      if (supported) {
+        for (const target of targets) creations.add(target);
+      }
+    }
+    if (executable !== "rm") continue;
+    let sawLiteral = false;
+    let afterOptions = false;
+    for (const token of tokens.slice(1)) {
+      if (!afterOptions && token === "--") {
+        afterOptions = true;
+        continue;
+      }
+      if (!afterOptions && token.startsWith("-")) continue;
+      const target = literalPath(token);
+      if (!target) {
+        opaqueDestructiveCommand = true;
+        continue;
+      }
+      sawLiteral = true;
+      removals.add(target);
+    }
+    if (!sawLiteral) opaqueDestructiveCommand = true;
+  }
+  if (/\brm\b/u.test(command) && removals.size === 0) {
+    opaqueDestructiveCommand = true;
+  }
+  return {
+    creations: [...creations],
+    removals: [...removals],
+    opaqueDestructiveCommand,
+  };
+}
+
+function containedPath(cwd: string, candidate: string) {
+  const absolute = path.resolve(cwd, candidate);
+  const relative = path.relative(cwd, absolute);
+  if (
+    relative === "" ||
+    relative.startsWith("..") ||
+    path.isAbsolute(relative)
+  ) {
+    return undefined;
+  }
+  return { absolute, relative: relative.split(path.sep).join("/") };
+}
+
+async function exists(candidate: string) {
+  try {
+    await lstat(candidate);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+export function createWorkspaceCleanupGuard(options: Options) {
+  const origins = new Map<string, Origin>();
+  const pending = new Map<string, PendingEffects>();
+
+  const prepareCreation = async (
+    cwd: string,
+    candidate: string,
+    observeOnCommandError: boolean,
+  ) => {
+    const contained = containedPath(cwd, candidate);
+    if (!contained) return undefined;
+    const existed = await exists(contained.absolute);
+    if (existed && !origins.has(contained.absolute)) {
+      origins.set(contained.absolute, "baseline");
+    }
+    return { path: contained.absolute, existed, observeOnCommandError };
+  };
+
+  return {
+    async beforeWrite(attempt: WriteAttempt) {
+      const creation = await prepareCreation(attempt.cwd, attempt.path, false);
+      pending.set(attempt.id, {
+        creations: creation ? [creation] : [],
+        removals: [],
+      });
+    },
+
+    async before(attempt: BashAttempt) {
+      const inspected = inspectShell(attempt.command);
+      const creations: PendingEffects["creations"] = [];
+      for (const candidate of inspected.creations) {
+        const creation = await prepareCreation(attempt.cwd, candidate, true);
+        if (creation) creations.push(creation);
+      }
+
+      const removals: string[] = [];
+      const protectedPaths: string[] = [];
+      for (const candidate of inspected.removals) {
+        const contained = containedPath(attempt.cwd, candidate);
+        if (!contained) continue;
+        const origin = origins.get(contained.absolute);
+        const present = await exists(contained.absolute);
+        if (present && !origin) origins.set(contained.absolute, "baseline");
+        if (present && origins.get(contained.absolute) !== "session_created") {
+          protectedPaths.push(contained.relative);
+        }
+        removals.push(contained.absolute);
+      }
+
+      if (
+        protectedPaths.length > 0 &&
+        !(await options.confirmDelete(protectedPaths))
+      ) {
+        return {
+          kind: "block" as const,
+          protectedPaths,
+          reason: `Blocked cleanup: ${protectedPaths.join(", ")} existed before this agent changed it and is not proven session-created scratch. Retry the cleanup without that path, or obtain explicit user confirmation to delete it.`,
+          opaqueDestructiveCommand: inspected.opaqueDestructiveCommand,
+        };
+      }
+
+      pending.set(attempt.id, { creations, removals });
+      return {
+        kind: "allow" as const,
+        opaqueDestructiveCommand: inspected.opaqueDestructiveCommand,
+      };
+    },
+
+    async after(result: { id: string; isError: boolean }) {
+      const effects = pending.get(result.id);
+      pending.delete(result.id);
+      if (!effects) return;
+      for (const creation of effects.creations) {
+        if (
+          !creation.existed &&
+          (!result.isError || creation.observeOnCommandError) &&
+          !origins.has(creation.path) &&
+          (await exists(creation.path))
+        ) {
+          origins.set(creation.path, "session_created");
+        }
+      }
+      for (const removed of effects.removals) {
+        if (
+          origins.get(removed) === "session_created" &&
+          !(await exists(removed))
+        ) {
+          origins.delete(removed);
+        }
+      }
+    },
+
+    reset() {
+      origins.clear();
+      pending.clear();
+    },
+  };
+}

package/extensions/file-search/index.ts

@@ -9,7 +9,7 @@
  * before executing, and report a clear error if it failed.
  */
 
-import { NodeServices } from "@effect/platform-node";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type {
@@ -53,6 +53,10 @@ import {
   RG_TOOL_DESCRIPTION,
 } from "./src/prompt.ts";
 import { discardCapturedOutput, executeSearchProcess } from "./src/process.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 
 export function makeBinaryInitializers(
   binDir: string,
@@ -137,6 +141,9 @@ export default function fileSearchTools(pi: ExtensionAPI) {
   const initializers = makeBinaryInitializers(binDir, target, liveBinaryEnv);
 
   pi.on("session_start", async (_event, ctx) => {
+    patchOwnedTools(pi, "fileSearch", {
+      enable: OPENPI_TOOL_SURFACE.fileSearch.entry,
+    });
     const exit = await Effect.runPromiseExit(
       Effect.gen(function* () {
         const initialized = yield* Effect.all(

package/extensions/file-search/src/binaries.ts

@@ -12,7 +12,8 @@
  * network. `liveBinaryEnv` is the real implementation.
  */
 
-import { NodeHttpClient, NodeServices } from "@effect/platform-node";
+import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";

package/extensions/git-info/src/runtime.ts

@@ -1,4 +1,4 @@
-import { NodeServices } from "@effect/platform-node";
+import * as NodeServices from "@effect/platform-node/NodeServices";
 import { Cause, Exit, Layer, ManagedRuntime, type Effect } from "effect";
 import { CommandRunner, CommandRunnerLive } from "./process.ts";
 

package/extensions/goal/controller.ts

@@ -68,7 +68,8 @@ export function countAssistantTokens(messages: readonly unknown[]) {
 
 export function lastAssistantStopReason(messages: readonly unknown[]) {
   return lastAssistantMessage(messages)?.stopReason as
-    AssistantStopReason | undefined;
+    | AssistantStopReason
+    | undefined;
 }
 
 export function isUsageLimitError(messages: readonly unknown[]) {

package/extensions/goal/index.ts

@@ -6,6 +6,10 @@ import type {
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import { GOAL_CONTINUATION_TYPE, GoalController } from "./controller.ts";
 import {
   GOAL_LIMITS,
@@ -88,6 +92,14 @@ export function goalToolResponse(
 
 export default function sessionGoal(pi: ExtensionAPI) {
   const controller = new GoalController(pi);
+  const hideLifecycleTools = () =>
+    patchOwnedTools(pi, "goal", {
+      disable: OPENPI_TOOL_SURFACE.goal.deferred,
+    });
+  const showLifecycleTools = () =>
+    patchOwnedTools(pi, "goal", {
+      enable: OPENPI_TOOL_SURFACE.goal.deferred,
+    });
 
   const updateUi = (ctx: ExtensionContext) => {
     if (!ctx.hasUI) return;
@@ -130,6 +142,7 @@ export default function sessionGoal(pi: ExtensionAPI) {
       controller.createId(),
     );
     controller.replace(goal);
+    showLifecycleTools();
     const started = controller.kickoff(ctx);
     return { goal: controller.snapshot() ?? goal, started };
   };
@@ -325,9 +338,11 @@ export default function sessionGoal(pi: ExtensionAPI) {
           // contradicts.
           notify(ctx, goalUpdateMessage(controller.snapshot()!));
         } else if (parsed.action === "clear") {
+          const cleared = controller.clear();
+          if (cleared) hideLifecycleTools();
           notify(
             ctx,
-            controller.clear()
+            cleared
               ? "Goal cleared"
               : "No goal to clear\nThis thread does not currently have a goal.",
           );
@@ -387,6 +402,8 @@ export default function sessionGoal(pi: ExtensionAPI) {
 
   pi.on("session_start", async (event, ctx) => {
     controller.restore(ctx, event.reason === "fork");
+    if (controller.snapshot()) showLifecycleTools();
+    else hideLifecycleTools();
     if (controller.problem()) {
       notify(
         ctx,
@@ -419,6 +436,8 @@ export default function sessionGoal(pi: ExtensionAPI) {
 
   pi.on("session_tree", (_event, ctx) => {
     controller.restore(ctx, true);
+    if (controller.snapshot()) showLifecycleTools();
+    else hideLifecycleTools();
     updateUi(ctx);
   });
 

package/extensions/plan-mode/index.ts

@@ -36,6 +36,10 @@ import {
   PLAN_MODE_CHANNEL,
   type PlanModeState,
 } from "../shared/plan-mode-state.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import { planBashDecision } from "./bash-policy.ts";
 
@@ -231,6 +235,12 @@ export function planToolCallDecision(
 export default function planMode(pi: ExtensionAPI) {
   let planning = false;
   let readyPlan: string | undefined;
+  const syncPlanTool = () =>
+    patchOwnedTools(pi, "plan", {
+      ...(planning && !readyPlan
+        ? { enable: OPENPI_TOOL_SURFACE.plan.deferred }
+        : { disable: OPENPI_TOOL_SURFACE.plan.deferred }),
+    });
 
   /**
    * Publish the stance and reflect it in the footer. Every place `planning`
@@ -242,6 +252,7 @@ export default function planMode(pi: ExtensionAPI) {
     hasUI: boolean;
     ui: { setStatus: (key: string, value?: string) => void };
   }) => {
+    syncPlanTool();
     pi.events.emit(PLAN_MODE_CHANNEL, { planning } satisfies PlanModeState);
     if (!ctx.hasUI) return;
     ctx.ui.setStatus(
@@ -532,6 +543,7 @@ export default function planMode(pi: ExtensionAPI) {
   pi.on("session_shutdown", () => {
     planning = false;
     readyPlan = undefined;
+    syncPlanTool();
     // Broadcast without a ctx: subagents keeps its own copy of the stance, and
     // leaving it armed would restrict children in whatever session comes next.
     pi.events.emit(PLAN_MODE_CHANNEL, { planning } satisfies PlanModeState);