@d3ara1n/pi-subagent 0.6.0 → 0.7.0

package/src/utils.ts

@@ -13,22 +13,22 @@ import type { ActivityEntry, SubagentRole, SubagentResult, ToolStatus } from "./
 export const MAX_OUTPUT_CHARS = 50_000;
 
 export function formatTokens(count: number): string {
-	if (count < 1000) return count.toString();
-	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-	if (count < 1000000) return `${Math.round(count / 1000)}k`;
-	return `${(count / 1000000).toFixed(1)}M`;
+  if (count < 1000) return count.toString();
+  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1000000) return `${Math.round(count / 1000)}k`;
+  return `${(count / 1000000).toFixed(1)}M`;
 }
 
 export function formatUsageStats(usage: SubagentResult["usage"], model?: string): string {
-	const parts: string[] = [];
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`\u2191${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`\u2193${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	if (model) parts.push(model);
-	return parts.join(" ");
+  const parts: string[] = [];
+  if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+  if (usage.input) parts.push(`\u2191${formatTokens(usage.input)}`);
+  if (usage.output) parts.push(`\u2193${formatTokens(usage.output)}`);
+  if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+  if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+  if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+  if (model) parts.push(model);
+  return parts.join(" ");
 }
 
 /**
@@ -41,157 +41,168 @@ export function formatUsageStats(usage: SubagentResult["usage"], model?: string)
  * and tested in pure-helper contexts without importing the full type.
  */
 export function elapsedSeconds(r: {
-	exitCode: number;
-	startTime?: number;
-	elapsedMs?: number;
+  exitCode: number;
+  startTime?: number;
+  elapsedMs?: number;
 }): number | undefined {
-	if (r.exitCode === -1 && typeof r.startTime === "number") {
-		return Math.max(0, Math.round((Date.now() - r.startTime) / 1000));
-	}
-	if (r.exitCode !== -1 && typeof r.elapsedMs === "number") {
-		return Math.round(r.elapsedMs / 1000);
-	}
-	return undefined;
+  if (r.exitCode === -1 && typeof r.startTime === "number") {
+    return Math.max(0, Math.round((Date.now() - r.startTime) / 1000));
+  }
+  if (r.exitCode !== -1 && typeof r.elapsedMs === "number") {
+    return Math.round(r.elapsedMs / 1000);
+  }
+  return undefined;
 }
 
 export type DisplayItem =
-	| { type: "toolCall"; name: string; args: Record<string, any>; status?: ToolStatus }
-	| { type: "thinking"; status?: ToolStatus };
+  | { type: "toolCall"; name: string; args: Record<string, any>; status?: ToolStatus }
+  | { type: "thinking"; status?: ToolStatus };
 
 /** Map the real-time activity log into renderable display items (in order). */
 export function buildDisplayItems(activityLog: ActivityEntry[]): DisplayItem[] {
-	return activityLog.map((a) =>
-		a.kind === "thinking"
-			? { type: "thinking", status: a.status }
-			: { type: "toolCall", name: a.toolName ?? "?", args: a.args ?? {}, status: a.status },
-	);
+  return activityLog.map((a) =>
+    a.kind === "thinking"
+      ? { type: "thinking", status: a.status }
+      : { type: "toolCall", name: a.toolName ?? "?", args: a.args ?? {}, status: a.status },
+  );
 }
 
 export function shortenPath(p: string): string {
-	const home = os.homedir();
-	if (process.platform === "win32") {
-		return p.toLowerCase().startsWith(home.toLowerCase()) ? `~${p.slice(home.length)}` : p;
-	}
-	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+  const home = os.homedir();
+  if (process.platform === "win32") {
+    return p.toLowerCase().startsWith(home.toLowerCase()) ? `~${p.slice(home.length)}` : p;
+  }
+  return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
 }
 
 export function formatToolCall(
-	toolName: string,
-	args: Record<string, unknown>,
-	fg: (color: string, text: string) => string,
+  toolName: string,
+  args: Record<string, unknown>,
+  fg: (color: string, text: string) => string,
 ): string {
-	switch (toolName) {
-		case "delegate": {
-			const subRole = args.role as string | undefined;
-			return fg("muted", "delegate ") + fg("accent", subRole ?? "...");
-		}
-		case "bash": {
-			const command = (args.command as string) || "...";
-			const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
-			return fg("muted", "$ ") + fg("toolOutput", preview);
-		}
-		case "read": {
-			const rawPath = (args.file_path || args.path || "...") as string;
-			const filePath = shortenPath(rawPath);
-			const offset = args.offset as number | undefined;
-			const limit = args.limit as number | undefined;
-			let text = fg("accent", filePath);
-			if (offset !== undefined || limit !== undefined) {
-				const startLine = offset ?? 1;
-				const endLine = limit !== undefined ? startLine + limit - 1 : "";
-				text += fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
-			}
-			return fg("muted", "read ") + text;
-		}
-		case "write": {
-			const rawPath = (args.file_path || args.path || "...") as string;
-			const content = (args.content || "") as string;
-			const lines = content.split("\n").length;
-			let text = fg("muted", "write ") + fg("accent", shortenPath(rawPath));
-			if (lines > 1) text += fg("dim", ` (${lines} lines)`);
-			return text;
-		}
-		case "edit": {
-			const rawPath = (args.file_path || args.path || "...") as string;
-			return fg("muted", "edit ") + fg("accent", shortenPath(rawPath));
-		}
-		case "grep": {
-			const pattern = (args.pattern || "") as string;
-			const rawPath = (args.path || ".") as string;
-			return fg("muted", "grep ") + fg("accent", `/${pattern}/`) + fg("dim", ` in ${shortenPath(rawPath)}`);
-		}
-		case "find": {
-			const pattern = (args.pattern || "*") as string;
-			return fg("muted", "find ") + fg("accent", pattern);
-		}
-		case "glob": {
-			const pattern = (args.pattern || "*") as string;
-			return fg("muted", "glob ") + fg("accent", pattern);
-		}
-		default: {
-			const preview = previewArgs(args);
-			return fg("accent", toolName) + (preview ? fg("dim", ` ${preview}`) : "");
-		}
-	}
+  switch (toolName) {
+    case "delegate": {
+      const subRole = args.role as string | undefined;
+      return fg("muted", "delegate ") + fg("accent", subRole ?? "...");
+    }
+    case "bash": {
+      const command = (args.command as string) || "...";
+      const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
+      return fg("muted", "$ ") + fg("toolOutput", preview);
+    }
+    case "read": {
+      const rawPath = (args.file_path || args.path || "...") as string;
+      const filePath = shortenPath(rawPath);
+      const offset = args.offset as number | undefined;
+      const limit = args.limit as number | undefined;
+      let text = fg("accent", filePath);
+      if (offset !== undefined || limit !== undefined) {
+        const startLine = offset ?? 1;
+        const endLine = limit !== undefined ? startLine + limit - 1 : "";
+        text += fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+      }
+      return fg("muted", "read ") + text;
+    }
+    case "write": {
+      const rawPath = (args.file_path || args.path || "...") as string;
+      const content = (args.content || "") as string;
+      const lines = content.split("\n").length;
+      let text = fg("muted", "write ") + fg("accent", shortenPath(rawPath));
+      if (lines > 1) text += fg("dim", ` (${lines} lines)`);
+      return text;
+    }
+    case "edit": {
+      const rawPath = (args.file_path || args.path || "...") as string;
+      return fg("muted", "edit ") + fg("accent", shortenPath(rawPath));
+    }
+    case "grep": {
+      const pattern = (args.pattern || "") as string;
+      const rawPath = (args.path || ".") as string;
+      return (
+        fg("muted", "grep ") +
+        fg("accent", `/${pattern}/`) +
+        fg("dim", ` in ${shortenPath(rawPath)}`)
+      );
+    }
+    case "find": {
+      const pattern = (args.pattern || "*") as string;
+      return fg("muted", "find ") + fg("accent", pattern);
+    }
+    case "glob": {
+      const pattern = (args.pattern || "*") as string;
+      return fg("muted", "glob ") + fg("accent", pattern);
+    }
+    default: {
+      const preview = previewArgs(args);
+      return fg("accent", toolName) + (preview ? fg("dim", ` ${preview}`) : "");
+    }
+  }
 }
 
 /** Per-tool-call visual styling: prefix glyph + color function keyed by status. */
 export function statusStyle(
-	status: ToolStatus | undefined,
-	fg: (color: string, text: string) => string,
+  status: ToolStatus | undefined,
+  fg: (color: string, text: string) => string,
 ): { prefix: string; color: (c: string, text: string) => string } {
-	switch (status) {
-		case "running":
-			return { prefix: fg("accent", "\u2192 "), color: fg };
-		case "failed":
-			return { prefix: fg("error", "\u2717 "), color: (_c, text) => fg("error", text) };
-		case "done":
-		default:
-			return { prefix: fg("dim", "\u2022 "), color: (_c, text) => fg("dim", text) };
-	}
+  switch (status) {
+    case "running":
+      return { prefix: fg("accent", "\u2192 "), color: fg };
+    case "failed":
+      return { prefix: fg("error", "\u2717 "), color: (_c, text) => fg("error", text) };
+    case "done":
+    default:
+      return { prefix: fg("dim", "\u2022 "), color: (_c, text) => fg("dim", text) };
+  }
 }
 
 /** Render a thinking-block row: diamond glyph + label, colored by status.
  * Running = hollow diamond (unformed thought); done = solid diamond (settled). */
 export function formatThinking(
-	status: ToolStatus | undefined,
-	fg: (color: string, text: string) => string,
+  status: ToolStatus | undefined,
+  fg: (color: string, text: string) => string,
 ): string {
-	if (status === "running") {
-		return fg("accent", "\u25C7 thinking");
-	}
-	// done (or unknown) — dim past tense, solid diamond
-	return fg("dim", "\u25C6 thought");
+  if (status === "running") {
+    return fg("accent", "\u25C7 thinking");
+  }
+  // done (or unknown) — dim past tense, solid diamond
+  return fg("dim", "\u25C6 thought");
 }
 
 export function renderDisplayItems(
-	items: DisplayItem[],
-	limit: number | undefined,
-	fg: (color: string, text: string) => string,
+  items: DisplayItem[],
+  limit: number | undefined,
+  fg: (color: string, text: string) => string,
 ): string {
-	const toShow = limit ? items.slice(-limit) : items;
-	const skipped = limit && items.length > limit ? items.length - limit : 0;
-	let text = "";
-	if (skipped > 0) text += fg("muted", `... ${skipped} earlier items\n`);
-	for (const item of toShow) {
-		if (item.type === "thinking") {
-			text += `${formatThinking(item.status, fg)}\n`;
-		} else {
-			const { prefix, color } = statusStyle(item.status, fg);
-			text += `${prefix}${formatToolCall(item.name, item.args, color)}\n`;
-		}
-	}
-	return text.trimEnd();
+  const toShow = limit ? items.slice(-limit) : items;
+  const skipped = limit && items.length > limit ? items.length - limit : 0;
+  let text = "";
+  if (skipped > 0) text += fg("muted", `... ${skipped} earlier items\n`);
+  for (const item of toShow) {
+    if (item.type === "thinking") {
+      text += `${formatThinking(item.status, fg)}\n`;
+    } else {
+      const { prefix, color } = statusStyle(item.status, fg);
+      text += `${prefix}${formatToolCall(item.name, item.args, color)}\n`;
+    }
+  }
+  return text.trimEnd();
 }
 
 export function isFailedResult(r: SubagentResult): boolean {
-	return r.exitCode !== 0 || r.stopReason === "error" || r.stopReason === "aborted" || r.stopReason === "timeout";
+  return (
+    r.exitCode !== 0 ||
+    r.stopReason === "error" ||
+    r.stopReason === "aborted" ||
+    r.stopReason === "timeout"
+  );
 }
 
 /** Heuristic: does this result look like a provider-side failure worth retrying on the fallback role? */
 export function isProviderError(result: SubagentResult): boolean {
-	const haystack = `${result.stderr || ""}\n${result.errorMessage || ""}`;
-	return /429|quota|rate.?limit|auth|timeout|exhausted|unavailable|503|server error|temporary|declined|overloaded|econnreset|socket hang up|epipe|network|connection/i.test(haystack);
+  const haystack = `${result.stderr || ""}\n${result.errorMessage || ""}`;
+  return /429|quota|rate.?limit|auth|timeout|exhausted|unavailable|503|server error|temporary|declined|overloaded|econnreset|socket hang up|epipe|network|connection/i.test(
+    haystack,
+  );
 }
 
 /**
@@ -199,16 +210,16 @@ export function isProviderError(result: SubagentResult): boolean {
  * @internal — exported for testing; used internally by {@link formatToolCall}.
  */
 export function previewArgs(args: Record<string, unknown>): string {
-	const command = args.command as string | undefined;
-	if (command) return `$ ${command.length > 60 ? command.slice(0, 60) + "..." : command}`;
-	const fp = (args.file_path || args.path) as string | undefined;
-	if (fp) return shortenPath(fp);
-	const url = args.url as string | undefined;
-	if (url) return url.length > 60 ? url.slice(0, 60) + "..." : url;
-	const query = (args.query || args.pattern || args.regex || args.search) as string | undefined;
-	if (query) return `/${query.length > 60 ? query.slice(0, 60) + "..." : query}/`;
-	const argsStr = JSON.stringify(args);
-	return argsStr.length > 50 ? argsStr.slice(0, 50) + "..." : argsStr;
+  const command = args.command as string | undefined;
+  if (command) return `$ ${command.length > 60 ? command.slice(0, 60) + "..." : command}`;
+  const fp = (args.file_path || args.path) as string | undefined;
+  if (fp) return shortenPath(fp);
+  const url = args.url as string | undefined;
+  if (url) return url.length > 60 ? url.slice(0, 60) + "..." : url;
+  const query = (args.query || args.pattern || args.regex || args.search) as string | undefined;
+  if (query) return `/${query.length > 60 ? query.slice(0, 60) + "..." : query}/`;
+  const argsStr = JSON.stringify(args);
+  return argsStr.length > 50 ? argsStr.slice(0, 50) + "..." : argsStr;
 }
 
 // ── Concurrency gate ───────────────────────────────────────────────
@@ -219,44 +230,44 @@ export function previewArgs(args: Record<string, unknown>): string {
  * Pass an AbortSignal to cancel while waiting (rejects and removes the waiter).
  */
 export class AsyncSemaphore {
-	private active = 0;
-	private waiters: Array<() => void> = [];
-	private max: number;
-	constructor(max: number) {
-		this.max = max;
-	}
-	async acquire(signal?: AbortSignal): Promise<void> {
-		if (this.active < this.max) {
-			this.active++;
-			return;
-		}
-		return new Promise<void>((resolve, reject) => {
-			const wakeup = () => {
-				signal?.removeEventListener("abort", onAbort);
-				this.active++;
-				resolve();
-			};
-			const onAbort = () => {
-				signal?.removeEventListener("abort", onAbort);
-				const idx = this.waiters.indexOf(wakeup);
-				if (idx >= 0) this.waiters.splice(idx, 1);
-				reject(new Error("aborted while waiting for concurrency slot"));
-			};
-			this.waiters.push(wakeup);
-			if (signal) {
-				if (signal.aborted) {
-					onAbort();
-					return;
-				}
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
-		});
-	}
-	release(): void {
-		this.active = Math.max(0, this.active - 1);
-		const next = this.waiters.shift();
-		if (next) next();
-	}
+  private active = 0;
+  private waiters: Array<() => void> = [];
+  private max: number;
+  constructor(max: number) {
+    this.max = max;
+  }
+  async acquire(signal?: AbortSignal): Promise<void> {
+    if (this.active < this.max) {
+      this.active++;
+      return;
+    }
+    return new Promise<void>((resolve, reject) => {
+      const wakeup = () => {
+        signal?.removeEventListener("abort", onAbort);
+        this.active++;
+        resolve();
+      };
+      const onAbort = () => {
+        signal?.removeEventListener("abort", onAbort);
+        const idx = this.waiters.indexOf(wakeup);
+        if (idx >= 0) this.waiters.splice(idx, 1);
+        reject(new Error("aborted while waiting for concurrency slot"));
+      };
+      this.waiters.push(wakeup);
+      if (signal) {
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+  }
+  release(): void {
+    this.active = Math.max(0, this.active - 1);
+    const next = this.waiters.shift();
+    if (next) next();
+  }
 }
 
 // ── Timeout policy ────────────────────────────────────────
@@ -268,23 +279,23 @@ export class AsyncSemaphore {
  * All inputs/outputs are in SECONDS — convert to ms at the spawn boundary.
  */
 export function effectiveTimeout(roleDef: SubagentRole, baseTimeoutSec: number): number {
-	const canDelegate = (roleDef.tools ?? []).includes("delegate");
-	if (canDelegate && roleDef.timeout == null) {
-		return baseTimeoutSec * 2;
-	}
-	return roleDef.timeout ?? baseTimeoutSec;
+  const canDelegate = (roleDef.tools ?? []).includes("delegate");
+  if (canDelegate && roleDef.timeout == null) {
+    return baseTimeoutSec * 2;
+  }
+  return roleDef.timeout ?? baseTimeoutSec;
 }
 
 // ── Output truncation ────────────────────────────────────────
 
 /** Strip path separators / traversal so sessionId/toolCallId can't escape the history dir. */
 export function sanitizeFilename(s: string): string {
-	return s.replace(/[^\w.-]/g, "_").replace(/^[.]+/, "") || "unknown";
+  return s.replace(/[^\w.-]/g, "_").replace(/^[.]+/, "") || "unknown";
 }
 
 /** Mechanical fallback: keep head (findings) + tail (summary), drop the middle. */
 export function truncateOutput(t: string): string {
-	const head = t.slice(0, 30_000);
-	const tail = t.slice(-(MAX_OUTPUT_CHARS - 30_050));
-	return `[Output truncated — ${t.length} chars total]\n\n${head}\n\n... [truncated] ...\n\n${tail}`;
+  const head = t.slice(0, 30_000);
+  const tail = t.slice(-(MAX_OUTPUT_CHARS - 30_050));
+  return `[Output truncated — ${t.length} chars total]\n\n${head}\n\n... [truncated] ...\n\n${tail}`;
 }