pi-subagents 0.80.0 → 0.82.0

package/bundle/chunk-XSWOTIA3.js

@@ -0,0 +1,175 @@
+import {
+  agentDefinitionDigest
+} from "./chunk-7F6RKT6W.js";
+import {
+  getAgentDir
+} from "./chunk-CIZQXJ5Q.js";
+
+// src/intercom/intercom-bridge.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var NATIVE_INTERCOM_EXTENSION_DIR = "native:pi-subagents-supervisor-channel";
+function defaultAgentDir() {
+  return getAgentDir();
+}
+function defaultSubagentConfigDir(agentDir = defaultAgentDir()) {
+  return path.join(agentDir, "extensions", "subagent");
+}
+var DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
+var PI_INTERCOM_SESSION_ID_ENV = "PI_INTERCOM_SESSION_ID";
+var INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
+var ORCHESTRATOR_TARGET_PLACEHOLDER = "{orchestratorTarget}";
+var DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
+
+Use contact_supervisor first. It resolves the supervisor session and run metadata automatically.
+- Need a decision, blocked, approval, or product/API/scope ambiguity: contact_supervisor({ reason: "need_decision", message: "<question>" })
+- Need structured supervisor input rather than a freeform reply: contact_supervisor({ reason: "interview_request", message: "<what input is needed>", interview: { title: "...", questions: [] } })
+- After contact_supervisor with reason "need_decision" or "interview_request", stay alive and continue only after the reply arrives. Do not finish your final response with a choose-one question.
+- Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. If an output path is configured but no write-capable tool is available, return the complete artifact in your final response; the runtime will persist it. Do not contact the supervisor merely because you cannot write that output path directly.
+- Meaningful progress or unexpected discoveries that change the plan: contact_supervisor({ reason: "progress_update", message: "UPDATE: <summary>" })
+
+Do not use contact_supervisor for routine completion handoffs. If no coordination is needed, return a focused task result.`;
+function validateIntercomBridgeConfig({ value, label }) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { ok: false, error: `${label} must be an object.` };
+  const bridge = value;
+  for (const field of Object.keys(bridge)) {
+    if (field !== "mode" && field !== "instructionFile" && field !== "resultDelivery") return { ok: false, error: `${label}.${field} is not supported.` };
+  }
+  if (bridge.mode !== void 0 && bridge.mode !== "off" && bridge.mode !== "fork-only" && bridge.mode !== "always") return { ok: false, error: `${label}.mode is invalid.` };
+  if (bridge.instructionFile !== void 0 && typeof bridge.instructionFile !== "string") return { ok: false, error: `${label}.instructionFile must be a string.` };
+  if (bridge.resultDelivery !== void 0 && typeof bridge.resultDelivery !== "boolean") return { ok: false, error: `${label}.resultDelivery must be a boolean.` };
+  return {
+    ok: true,
+    value: {
+      ...bridge.mode !== void 0 ? { mode: bridge.mode } : {},
+      ...bridge.instructionFile !== void 0 ? { instructionFile: bridge.instructionFile } : {},
+      ...bridge.resultDelivery !== void 0 ? { resultDelivery: bridge.resultDelivery } : {}
+    }
+  };
+}
+function resolveIntercomSessionTarget(sessionName, sessionId, intercomSessionId = process.env[PI_INTERCOM_SESSION_ID_ENV]) {
+  const trimmedName = sessionName?.trim();
+  if (trimmedName) return trimmedName;
+  const fallbackSessionId = intercomSessionId?.trim() || sessionId;
+  const normalizedSessionId = fallbackSessionId.startsWith("session-") ? fallbackSessionId.slice("session-".length) : fallbackSessionId;
+  return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 18)}`;
+}
+function sanitizeIntercomTargetPart(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function resolveSubagentIntercomTarget(runId, agent, index) {
+  const stepSuffix = index !== void 0 ? `-${index + 1}` : "";
+  return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
+}
+function resolveIntercomBridgeMode(value) {
+  if (value === "off" || value === "always" || value === "fork-only") return value;
+  return "always";
+}
+function resolveIntercomBridgeConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { mode: "always", instructionFile: "", resultDelivery: false };
+  }
+  return {
+    mode: resolveIntercomBridgeMode(value.mode),
+    instructionFile: typeof value.instructionFile === "string" ? value.instructionFile : "",
+    resultDelivery: value.resultDelivery === true
+  };
+}
+function expandTilde(filePath) {
+  return filePath.startsWith("~/") ? path.join(os.homedir(), filePath.slice(2)) : filePath;
+}
+function resolveInstructionTemplate(instructionFile, settingsDir) {
+  if (!instructionFile) return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
+  const expandedPath = expandTilde(instructionFile);
+  const resolvedPath = path.isAbsolute(expandedPath) ? expandedPath : path.resolve(settingsDir, expandedPath);
+  try {
+    return fs.readFileSync(resolvedPath, "utf-8");
+  } catch (error) {
+    console.warn(`Failed to read intercom bridge instructionFile at '${resolvedPath}'. Using default instructions.`, error);
+    return DEFAULT_INTERCOM_BRIDGE_TEMPLATE;
+  }
+}
+function buildIntercomBridgeInstruction(orchestratorTarget, template) {
+  const instruction = template.replaceAll(ORCHESTRATOR_TARGET_PLACEHOLDER, orchestratorTarget).trim();
+  if (instruction.startsWith(INTERCOM_BRIDGE_MARKER)) return instruction;
+  return `${INTERCOM_BRIDGE_MARKER}
+${instruction}`;
+}
+function inactiveReason(mode, context, orchestratorTarget) {
+  if (mode === "off") return "bridge mode is off";
+  if (mode === "fork-only" && context !== "fork") return "bridge mode is fork-only and context is not fork";
+  if (!orchestratorTarget) return "orchestrator target is not available";
+  return void 0;
+}
+function diagnoseIntercomBridge(input) {
+  const config = resolveIntercomBridgeConfig(input.config);
+  const mode = config.mode;
+  const orchestratorTarget = input.orchestratorTarget?.trim();
+  const wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork");
+  const reason = inactiveReason(mode, input.context, orchestratorTarget);
+  return {
+    active: reason === void 0,
+    mode,
+    wantsIntercom,
+    supervisorChannelAvailable: true,
+    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+    ...orchestratorTarget ? { orchestratorTarget } : {},
+    ...reason ? { reason } : {}
+  };
+}
+function resolveIntercomBridge(input) {
+  const config = resolveIntercomBridgeConfig(input.override !== void 0 ? input.override : input.config);
+  const mode = config.mode;
+  const orchestratorTarget = input.orchestratorTarget?.trim();
+  const agentDir = path.resolve(input.agentDir ?? defaultAgentDir());
+  const settingsDir = path.resolve(input.settingsDir ?? defaultSubagentConfigDir(agentDir));
+  const reason = inactiveReason(mode, input.context, orchestratorTarget);
+  if (reason || !orchestratorTarget) {
+    return {
+      active: false,
+      mode,
+      resultDelivery: config.resultDelivery,
+      extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+      instruction: buildIntercomBridgeInstruction(ORCHESTRATOR_TARGET_PLACEHOLDER, DEFAULT_INTERCOM_BRIDGE_TEMPLATE),
+      interpolatesOrchestratorTarget: false
+    };
+  }
+  const template = resolveInstructionTemplate(config.instructionFile, settingsDir);
+  return {
+    active: true,
+    mode,
+    resultDelivery: config.resultDelivery,
+    orchestratorTarget,
+    extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
+    instruction: buildIntercomBridgeInstruction(orchestratorTarget, template),
+    interpolatesOrchestratorTarget: template.includes(ORCHESTRATOR_TARGET_PLACEHOLDER)
+  };
+}
+function applyIntercomBridgeToAgent(agent, bridge) {
+  if (!bridge.active || !bridge.orchestratorTarget) return agent;
+  const bridgeTools = ["contact_supervisor"];
+  const tools = agent.tools && agent.tools.length > 0 ? [...agent.tools, ...bridgeTools.filter((tool) => !agent.tools?.includes(tool))] : agent.tools;
+  const instruction = bridge.instruction;
+  const trimmedPrompt = agent.systemPrompt?.trim() || "";
+  const systemPrompt = trimmedPrompt.includes(INTERCOM_BRIDGE_MARKER) ? trimmedPrompt : trimmedPrompt ? `${trimmedPrompt}
+
+${instruction}` : instruction;
+  if (tools === agent.tools && systemPrompt === agent.systemPrompt) return agent;
+  return {
+    ...agent,
+    definitionDigest: agentDefinitionDigest(agent),
+    tools,
+    systemPrompt
+  };
+}
+
+export {
+  INTERCOM_BRIDGE_MARKER,
+  validateIntercomBridgeConfig,
+  resolveIntercomSessionTarget,
+  resolveSubagentIntercomTarget,
+  diagnoseIntercomBridge,
+  resolveIntercomBridge,
+  applyIntercomBridgeToAgent
+};

package/bundle/chunk-YFCK7H2S.js

@@ -0,0 +1,129 @@
+// src/shared/display-text.ts
+function codePointWidth(codePoint) {
+  return codePoint > 65535 ? 2 : 1;
+}
+function isWhitespaceOrControl(codePoint) {
+  if (codePoint <= 32 || codePoint >= 127 && codePoint <= 159) return true;
+  if (codePoint >= 55296 && codePoint <= 57343) return true;
+  return String.fromCodePoint(codePoint).trim().length === 0;
+}
+function consumeControlString(value, index, osc) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (osc && codePoint === 7) return index + width;
+    if (codePoint === 156) return index + width;
+    if (codePoint === 27 && value.charCodeAt(index + 1) === 92) return index + 2;
+    index += width;
+  }
+  return value.length;
+}
+function consumeCsi(value, index) {
+  while (index < value.length) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint >= 64 && codePoint <= 126) return index + width;
+    index += width;
+  }
+  return value.length;
+}
+function sanitizeDisplayText(value) {
+  const output = [];
+  let pendingSpace = false;
+  const appendSpace = () => {
+    if (output.length > 0) pendingSpace = true;
+  };
+  const appendText = (text) => {
+    if (pendingSpace) output.push(" ");
+    output.push(text);
+    pendingSpace = false;
+  };
+  for (let index = 0; index < value.length; ) {
+    const codePoint = value.codePointAt(index);
+    const width = codePointWidth(codePoint);
+    if (codePoint === 27) {
+      const next = value.charCodeAt(index + 1);
+      appendSpace();
+      if (next === 91) {
+        index = consumeCsi(value, index + 2);
+        continue;
+      }
+      if (next === 93 || next === 80 || next === 88 || next === 94 || next === 95) {
+        index = consumeControlString(value, index + 2, next === 93);
+        continue;
+      }
+      index += next ? 2 : 1;
+      continue;
+    }
+    if (codePoint === 155) {
+      appendSpace();
+      index = consumeCsi(value, index + width);
+      continue;
+    }
+    if (codePoint === 144 || codePoint === 152 || codePoint === 157 || codePoint === 158 || codePoint === 159) {
+      appendSpace();
+      index = consumeControlString(value, index + width, codePoint === 157);
+      continue;
+    }
+    if (isWhitespaceOrControl(codePoint)) appendSpace();
+    else appendText(String.fromCodePoint(codePoint));
+    index += width;
+  }
+  return output.join("");
+}
+function truncateDisplayText(value, maxLength) {
+  if (maxLength <= 0) return "";
+  if (value.length <= maxLength) return value;
+  let output = "";
+  for (const char of value) {
+    if (output.length + char.length > maxLength) break;
+    output += char;
+  }
+  return output;
+}
+function previewDisplayText(value, maxLength) {
+  const normalized = sanitizeDisplayText(value);
+  if (normalized.length <= maxLength) return normalized;
+  if (maxLength <= 3) return truncateDisplayText(normalized, maxLength);
+  return `${truncateDisplayText(normalized, maxLength - 3)}...`;
+}
+var BINARY_CONTENT_PLACEHOLDER = "[binary content omitted for safe display]";
+function isUnsafeTerminalCodePoint(codePoint) {
+  const terminalControl = codePoint <= 31 && codePoint !== 9 && codePoint !== 10 || codePoint >= 127 && codePoint <= 159;
+  const bidiControl = codePoint === 1564 || codePoint === 8206 || codePoint === 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8294 && codePoint <= 8297;
+  const privateUse = codePoint >= 57344 && codePoint <= 63743 || codePoint >= 983040 && codePoint <= 1048573 || codePoint >= 1048576 && codePoint <= 1114109;
+  const invalidScalar = codePoint >= 55296 && codePoint <= 57343;
+  const nonCharacter = codePoint >= 64976 && codePoint <= 65007 || (codePoint & 65535) === 65534 || (codePoint & 65535) === 65535;
+  return terminalControl || bidiControl || privateUse || invalidScalar || nonCharacter;
+}
+function looksLikeBinaryContent(text) {
+  if (text.includes("\0")) return true;
+  let suspiciousControls = 0;
+  let replacementCharacters = 0;
+  let codePoints = 0;
+  for (const character of text) {
+    codePoints++;
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint <= 8 || codePoint >= 14 && codePoint <= 31) suspiciousControls++;
+    if (codePoint === 65533) replacementCharacters++;
+  }
+  if (codePoints === 0) return false;
+  return suspiciousControls >= 4 && suspiciousControls / codePoints >= 0.1 || replacementCharacters >= 3 && replacementCharacters / codePoints >= 0.1;
+}
+function safeTerminalText(value) {
+  const normalized = value.replace(/\r\n/g, "\n");
+  if (looksLikeBinaryContent(normalized)) return BINARY_CONTENT_PLACEHOLDER;
+  let safe = "";
+  for (const character of normalized) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    safe += isUnsafeTerminalCodePoint(codePoint) ? `[U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}]` : character;
+  }
+  return safe;
+}
+
+export {
+  sanitizeDisplayText,
+  truncateDisplayText,
+  previewDisplayText,
+  safeTerminalText
+};