pi-subagents 0.79.2 → 0.81.0

package/bundle/chunk-7F6RKT6W.js

@@ -0,0 +1,132 @@
+// src/shared/launch-contract.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+var AGENT_DEFINITION_PROJECTION_VERSION = 2;
+var LAUNCH_BINDING_PROJECTION_VERSION = 2;
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function stableJsonDigest(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+function fileDigest(filePath) {
+  try {
+    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  } catch {
+    return void 0;
+  }
+}
+function projectAgentDefinition(agent) {
+  return {
+    version: AGENT_DEFINITION_PROJECTION_VERSION,
+    name: agent.name,
+    localName: agent.localName,
+    packageName: agent.packageName,
+    filePath: agent.filePath,
+    fileContentDigest: fileDigest(agent.filePath),
+    runner: agent.runner,
+    systemPrompt: agent.systemPrompt,
+    systemPromptMode: agent.systemPromptMode,
+    inheritProjectContext: agent.inheritProjectContext,
+    inheritGlobalContext: agent.inheritGlobalContext,
+    inheritSkills: agent.inheritSkills,
+    model: agent.model,
+    modelProvider: agent.modelProvider,
+    fast: agent.fast,
+    thinking: agent.thinking,
+    tools: agent.tools,
+    excludeTools: agent.excludeTools,
+    allowNestedSubagents: agent.allowNestedSubagents,
+    allowedAgents: agent.allowedAgents,
+    mcpDirectTools: agent.mcpDirectTools,
+    extensions: agent.extensions,
+    subagentOnlyExtensions: agent.subagentOnlyExtensions,
+    mutationTools: agent.mutationTools,
+    skills: agent.skills,
+    skillPath: agent.skillPath,
+    output: agent.output,
+    outputSchema: agent.outputSchema,
+    defaultReads: agent.defaultReads,
+    defaultProgress: agent.defaultProgress,
+    defaultContext: agent.defaultContext,
+    defaultAsync: agent.defaultAsync,
+    defaultTimeoutMs: agent.defaultTimeoutMs,
+    defaultAcceptance: agent.defaultAcceptance,
+    acceptanceRole: agent.acceptanceRole,
+    interactive: agent.interactive,
+    maxSubagentDepth: agent.maxSubagentDepth,
+    toolBudget: agent.toolBudget,
+    memory: agent.memory
+  };
+}
+function agentDefinitionDigest(agent) {
+  return agent.definitionDigest ?? stableJsonDigest(projectAgentDefinition(agent));
+}
+function projectLaunchBinding(input) {
+  return {
+    version: LAUNCH_BINDING_PROJECTION_VERSION,
+    definitionDigest: input.definitionDigest,
+    taskDigest: input.task === void 0 ? void 0 : stableJsonDigest(input.task),
+    model: input.model,
+    fast: input.fast,
+    thinking: input.thinking,
+    systemPromptDigest: input.systemPrompt === void 0 || input.systemPrompt === null ? void 0 : stableJsonDigest(input.systemPrompt),
+    systemPromptMode: input.systemPromptMode,
+    inheritProjectContext: input.inheritProjectContext,
+    inheritGlobalContext: input.inheritGlobalContext,
+    inheritSkills: input.inheritSkills,
+    skills: input.skills,
+    tools: input.tools,
+    excludeTools: input.excludeTools,
+    extensions: input.extensions,
+    subagentOnlyExtensions: input.subagentOnlyExtensions,
+    mcpDirectTools: input.mcpDirectTools,
+    outputPath: input.outputPath,
+    outputMode: input.outputMode,
+    structuredOutputSchema: input.structuredOutputSchema,
+    extensionBindings: input.extensionBindings
+  };
+}
+function launchBindingDigest(input) {
+  return stableJsonDigest(projectLaunchBinding(input));
+}
+function resolveLaunchBinding(source) {
+  const identity = "agent" in source ? {
+    definitionDigest: agentDefinitionDigest(source.agent),
+    systemPromptMode: source.agent.systemPromptMode,
+    inheritProjectContext: source.agent.inheritProjectContext,
+    inheritGlobalContext: source.agent.inheritGlobalContext,
+    inheritSkills: source.agent.inheritSkills
+  } : source;
+  return {
+    definitionDigest: identity.definitionDigest,
+    launchContractDigest: launchBindingDigest({
+      ...identity,
+      task: source.task,
+      model: source.model,
+      fast: source.fast,
+      thinking: source.thinking || void 0,
+      systemPrompt: source.systemPrompt,
+      skills: source.skills,
+      tools: source.toolPlan.effectiveToolAllowlist,
+      excludeTools: source.toolPlan.excludeTools.length > 0 ? source.toolPlan.excludeTools : void 0,
+      extensions: source.toolPlan.extensionArgs,
+      mcpDirectTools: source.toolPlan.effectiveMcpTools,
+      outputPath: source.outputPath || void 0,
+      outputMode: source.outputMode,
+      structuredOutputSchema: source.structuredOutputSchema,
+      extensionBindings: source.extensionBindings || void 0
+    })
+  };
+}
+
+export {
+  AGENT_DEFINITION_PROJECTION_VERSION,
+  stableJsonDigest,
+  agentDefinitionDigest,
+  resolveLaunchBinding
+};

package/bundle/chunk-7J4ZXMY7.js

@@ -0,0 +1,18 @@
+// src/inspectors/shell-command.ts
+function shellQuote(value, platform) {
+  if (platform === "win32") return `"${value.replaceAll('"', '\\"')}"`;
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function isBareExecutable(value) {
+  return /^[\w./@:-]+$/.test(value);
+}
+function formatShellCommand(exe, args, platform = process.platform) {
+  const quotedArgs = args.map((arg) => shellQuote(arg, platform));
+  if (platform === "win32") return `& ${[shellQuote(exe, platform), ...quotedArgs].join(" ")}`;
+  const invocation = isBareExecutable(exe) ? exe : `sh -c 'exec "$0" "$@"' ${shellQuote(exe, platform)}`;
+  return [invocation, ...quotedArgs].join(" ");
+}
+
+export {
+  formatShellCommand
+};

package/bundle/chunk-ARRKBB2B.js

@@ -0,0 +1,179 @@
+import {
+  appendAgentRefinementOverlay
+} from "./chunk-EYNJ6VL6.js";
+import {
+  buildAgentMemoryInjection,
+  buildSkillInjection
+} from "./chunk-ZBC44JJ3.js";
+
+// src/runs/shared/effective-system-prompt.ts
+function appendSection(prompt, section) {
+  return prompt ? `${prompt}
+
+${section}` : section;
+}
+function buildEffectiveSystemPrompt(input) {
+  let prompt = input.agent.systemPrompt?.trim() ?? "";
+  if (input.resolvedSkills.length > 0) prompt = appendSection(prompt, buildSkillInjection(input.resolvedSkills));
+  const memoryInjection = buildAgentMemoryInjection(input.agent, input.cwd);
+  if (memoryInjection) prompt = appendSection(prompt, memoryInjection);
+  prompt = appendAgentRefinementOverlay(prompt, { cwd: input.cwd, agentName: input.agent.name });
+  return prompt;
+}
+
+// src/shared/fork-context.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+function resolveSubagentContext(value) {
+  return value === "fork" ? "fork" : "fresh";
+}
+function resolveSubagentLaunchContext(input) {
+  if (input.explicitContext !== void 0) return input.explicitContext;
+  const preferredContext = input.defaultSubagentContext ?? input.agentDefaultContext ?? "fresh";
+  return preferredContext === "fork" && input.canUseImplicitFork ? "fork" : "fresh";
+}
+function canPreferFork(sessionManager) {
+  return canPreferForkFromSnapshot({
+    parentSessionFile: sessionManager.getSessionFile(),
+    leafId: sessionManager.getLeafId?.() ?? null
+  });
+}
+function canPreferForkFromSnapshot(input) {
+  if (!input.parentSessionFile || !input.leafId) return false;
+  try {
+    return fs.existsSync(input.parentSessionFile);
+  } catch {
+    return false;
+  }
+}
+function isUnsafeAnthropicThinkingBlock(message, block, verbatim) {
+  if (!message || !block || typeof block !== "object" || !("type" in block)) return false;
+  if (verbatim) return block.type === "redacted_thinking";
+  const provider = typeof message.provider === "string" ? message.provider.toLowerCase() : "";
+  const api = typeof message.api === "string" ? message.api.toLowerCase() : "";
+  const model = typeof message.model === "string" ? message.model.toLowerCase() : "";
+  const isAnthropic = provider === "anthropic" || api === "anthropic-messages" || model.startsWith("anthropic/");
+  if (block.type === "redacted_thinking") return true;
+  if (block.type !== "thinking" || !isAnthropic) return false;
+  const record = block;
+  const signature = "thinkingSignature" in record ? record.thinkingSignature : "signature" in record ? record.signature : void 0;
+  return record.redacted === true || typeof signature === "string" && signature.length > 0;
+}
+function sanitizeUnsafeThinkingBlocks(entries, rewritten) {
+  let sanitized = false;
+  const entriesById = new Map(entries.flatMap((entry) => entry.id ? [[entry.id, entry]] : []));
+  for (const entry of entries) {
+    const targetMessage = entry.type === "context_edit" && entry.targetId ? entriesById.get(entry.targetId)?.message : entry.message;
+    const contentOwner = entry.type === "context_edit" ? entry.replacement : targetMessage;
+    if (targetMessage?.role !== "assistant" || !contentOwner || !Array.isArray(contentOwner.content)) continue;
+    const verbatim = !rewritten && entry.type !== "context_edit";
+    const filtered = contentOwner.content.filter((block) => !isUnsafeAnthropicThinkingBlock(targetMessage, block, verbatim));
+    if (filtered.length === contentOwner.content.length) continue;
+    contentOwner.content = filtered;
+    sanitized = true;
+  }
+  return sanitized;
+}
+function readSessionEntries(sessionFile) {
+  const lines = fs.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  return lines.map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      const cause = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Unable to inspect forked session ${sessionFile}: invalid JSONL on line ${index + 1}: ${cause.message}`, { cause });
+    }
+  });
+}
+function createForkContextResolver(sessionManager, requestedContext, options) {
+  if (resolveSubagentContext(requestedContext) !== "fork") {
+    return {
+      prepareSessionForIndex: async () => {
+      },
+      sessionFileForIndex: () => void 0
+    };
+  }
+  const parentSessionFile = sessionManager.getSessionFile();
+  if (!parentSessionFile) {
+    throw new Error("Forked subagent context requires a persisted parent session.");
+  }
+  const leafId = sessionManager.getLeafId();
+  if (!leafId) {
+    throw new Error("Forked subagent context requires a current leaf to fork from.");
+  }
+  const openSession = options.openSession ?? sessionManager.openSession ?? ((file, dir) => SessionManager.open(file, dir));
+  const forksDir = path.join(
+    path.dirname(parentSessionFile),
+    path.basename(parentSessionFile, ".jsonl"),
+    "forks"
+  );
+  const cachedSessionFiles = /* @__PURE__ */ new Map();
+  const preparedIndexes = /* @__PURE__ */ new Set();
+  const preparationPromises = /* @__PURE__ */ new Map();
+  const resolveFork = (index = 0) => {
+    const cached = cachedSessionFiles.get(index);
+    if (cached) return cached;
+    try {
+      if (!fs.existsSync(parentSessionFile)) {
+        throw new Error(`Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`);
+      }
+      const sessionDir = path.join(forksDir, options.runDirName());
+      const sourceManager = openSession(parentSessionFile, sessionDir);
+      const sessionFile = sourceManager.createBranchedSession(leafId);
+      if (!sessionFile) {
+        throw new Error("Session manager did not return a forked session file.");
+      }
+      if (!fs.existsSync(sessionFile)) {
+        const header = sourceManager.getHeader?.();
+        const entries = sourceManager.getEntries?.();
+        if (!header || !entries) {
+          throw new Error(`Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`);
+        }
+        sanitizeUnsafeThinkingBlocks(entries, Boolean(options.pruneSession));
+        fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+        fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join("\n")}
+`, "utf-8");
+      } else {
+        const entries = readSessionEntries(sessionFile);
+        if (sanitizeUnsafeThinkingBlocks(entries, Boolean(options.pruneSession))) {
+          fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
+`, "utf-8");
+        }
+      }
+      cachedSessionFiles.set(index, sessionFile);
+      return sessionFile;
+    } catch (error) {
+      const cause = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
+    }
+  };
+  return {
+    async prepareSessionForIndex(index = 0) {
+      const sessionFile = resolveFork(index);
+      if (!options.pruneSession || preparedIndexes.has(index)) return;
+      let preparation = preparationPromises.get(index);
+      if (!preparation) {
+        preparation = options.pruneSession(sessionFile).then(() => {
+          preparedIndexes.add(index);
+        });
+        preparationPromises.set(index, preparation);
+      }
+      await preparation;
+    },
+    sessionFileForIndex(index = 0) {
+      if (options.pruneSession && !preparedIndexes.has(index)) {
+        throw new Error(`Pruned fork session ${index} was used before pruning completed.`);
+      }
+      return resolveFork(index);
+    }
+  };
+}
+
+export {
+  buildEffectiveSystemPrompt,
+  resolveSubagentLaunchContext,
+  canPreferFork,
+  canPreferForkFromSnapshot,
+  createForkContextResolver
+};