pi-taskflow 0.0.4 → 0.0.6

package/extensions/interpolate.ts

@@ -149,3 +149,234 @@ export function coerceArray(value: unknown): unknown[] | null {
 	}
 	return null;
 }
+
+// ---------------------------------------------------------------------------
+// Conditional expressions (phase.when)
+// ---------------------------------------------------------------------------
+//
+// A tiny, safe boolean expression language — NO eval / Function. Operands are
+// either interpolation placeholders `{...}` (resolved to their raw value) or
+// literals (quoted string, number, true/false/null, or a bare word treated as
+// a string). Operators, by precedence (low → high):
+//
+//   ||   logical or
+//   &&   logical and
+//   ==  != == >= <= > <   comparison
+//   !    logical not / unary
+//   ( )  grouping
+//
+// A bare operand is evaluated for truthiness. Parse errors fail OPEN (return
+// true) so a malformed guard never silently drops a phase.
+
+type Tok =
+	| { t: "ref"; v: string }
+	| { t: "str"; v: string }
+	| { t: "num"; v: number }
+	| { t: "bool"; v: boolean }
+	| { t: "null" }
+	| { t: "op"; v: string };
+
+const OPS = ["&&", "||", "==", "!=", ">=", "<=", ">", "<", "!", "(", ")"];
+
+function tokenize(input: string): Tok[] {
+	const toks: Tok[] = [];
+	let i = 0;
+	const n = input.length;
+	while (i < n) {
+		const c = input[i];
+		if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		// placeholder {path.to.value}
+		if (c === "{") {
+			const end = input.indexOf("}", i);
+			if (end === -1) throw new Error("unterminated placeholder");
+			toks.push({ t: "ref", v: input.slice(i + 1, end).trim() });
+			i = end + 1;
+			continue;
+		}
+		// quoted string
+		if (c === '"' || c === "'") {
+			const end = input.indexOf(c, i + 1);
+			if (end === -1) throw new Error("unterminated string");
+			toks.push({ t: "str", v: input.slice(i + 1, end) });
+			i = end + 1;
+			continue;
+		}
+		// multi/single char operators
+		const op = OPS.find((o) => input.startsWith(o, i));
+		if (op) {
+			toks.push({ t: "op", v: op });
+			i += op.length;
+			continue;
+		}
+		// number
+		const numMatch = /^-?\d+(?:\.\d+)?/.exec(input.slice(i));
+		if (numMatch) {
+			toks.push({ t: "num", v: Number(numMatch[0]) });
+			i += numMatch[0].length;
+			continue;
+		}
+		// bareword → literal (true/false/null keywords, else string)
+		const word = /^[^\s&|!=<>()"'{}]+/.exec(input.slice(i));
+		if (word) {
+			const w = word[0];
+			if (w === "true") toks.push({ t: "bool", v: true });
+			else if (w === "false") toks.push({ t: "bool", v: false });
+			else if (w === "null") toks.push({ t: "null" });
+			else toks.push({ t: "str", v: w });
+			i += w.length;
+			continue;
+		}
+		throw new Error(`unexpected char '${c}'`);
+	}
+	return toks;
+}
+
+function isNumeric(v: unknown): boolean {
+	if (typeof v === "number") return Number.isFinite(v);
+	if (typeof v === "string" && v.trim() !== "") return Number.isFinite(Number(v));
+	return false;
+}
+
+function truthy(v: unknown): boolean {
+	if (v === undefined || v === null) return false;
+	if (typeof v === "boolean") return v;
+	if (typeof v === "number") return v !== 0;
+	if (typeof v === "string") {
+		const s = v.trim().toLowerCase();
+		return !(s === "" || s === "false" || s === "0" || s === "no" || s === "off" || s === "null");
+	}
+	if (Array.isArray(v)) return v.length > 0;
+	if (typeof v === "object") return Object.keys(v as object).length > 0;
+	return Boolean(v);
+}
+
+function compare(a: unknown, op: string, b: unknown): boolean {
+	if (isNumeric(a) && isNumeric(b)) {
+		const x = Number(a);
+		const y = Number(b);
+		switch (op) {
+			case "==": return x === y;
+			case "!=": return x !== y;
+			case ">": return x > y;
+			case "<": return x < y;
+			case ">=": return x >= y;
+			case "<=": return x <= y;
+		}
+	}
+	const sa = a === undefined || a === null ? "" : String(a);
+	const sb = b === undefined || b === null ? "" : String(b);
+	switch (op) {
+		case "==": return sa === sb;
+		case "!=": return sa !== sb;
+		case ">": return sa > sb;
+		case "<": return sa < sb;
+		case ">=": return sa >= sb;
+		case "<=": return sa <= sb;
+	}
+	return false;
+}
+
+/** Recursive-descent parser/evaluator over the token stream. */
+class CondParser {
+	private pos = 0;
+	private readonly toks: Tok[];
+	private readonly ctx: InterpolationContext;
+	constructor(toks: Tok[], ctx: InterpolationContext) {
+		this.toks = toks;
+		this.ctx = ctx;
+	}
+
+	parse(): unknown {
+		const v = this.parseOr();
+		if (this.pos < this.toks.length) throw new Error("trailing tokens");
+		return v;
+	}
+	private peek(): Tok | undefined {
+		return this.toks[this.pos];
+	}
+	private eat(op: string): boolean {
+		const t = this.peek();
+		if (t && t.t === "op" && t.v === op) {
+			this.pos++;
+			return true;
+		}
+		return false;
+	}
+	private parseOr(): unknown {
+		let left = this.parseAnd();
+		while (this.eat("||")) {
+			const right = this.parseAnd();
+			left = truthy(left) || truthy(right);
+		}
+		return left;
+	}
+	private parseAnd(): unknown {
+		let left = this.parseNot();
+		while (this.eat("&&")) {
+			const right = this.parseNot();
+			left = truthy(left) && truthy(right);
+		}
+		return left;
+	}
+	private parseNot(): unknown {
+		if (this.eat("!")) return !truthy(this.parseNot());
+		return this.parseComparison();
+	}
+	private parseComparison(): unknown {
+		const left = this.parsePrimary();
+		const t = this.peek();
+		if (t && t.t === "op" && ["==", "!=", ">", "<", ">=", "<="].includes(t.v)) {
+			this.pos++;
+			const right = this.parsePrimary();
+			return compare(left, t.v, right);
+		}
+		return left;
+	}
+	private parsePrimary(): unknown {
+		if (this.eat("(")) {
+			const v = this.parseOr();
+			if (!this.eat(")")) throw new Error("missing )");
+			return v;
+		}
+		const t = this.peek();
+		if (!t) throw new Error("unexpected end");
+		this.pos++;
+		switch (t.t) {
+			case "ref": return resolvePath(t.v, this.ctx);
+			case "str": return t.v;
+			case "num": return t.v;
+			case "bool": return t.v;
+			case "null": return null;
+			default: throw new Error(`unexpected operator '${(t as { v: string }).v}'`);
+		}
+	}
+}
+
+/**
+ * Evaluate a `when` expression to a boolean. Returns `{ value, error }`.
+ * Parse errors set `error` and fail OPEN (`value: true`) so a broken guard
+ * never silently drops a phase.
+ */
+export function tryEvaluateCondition(
+	expr: string,
+	ctx: InterpolationContext,
+): { value: boolean; error?: string } {
+	const trimmed = (expr ?? "").trim();
+	if (!trimmed) return { value: true };
+	try {
+		const toks = tokenize(trimmed);
+		if (toks.length === 0) return { value: true };
+		const result = new CondParser(toks, ctx).parse();
+		return { value: truthy(result) };
+	} catch (e) {
+		return { value: true, error: e instanceof Error ? e.message : String(e) };
+	}
+}
+
+/** Boolean convenience wrapper over {@link tryEvaluateCondition}. */
+export function evaluateCondition(expr: string, ctx: InterpolationContext): boolean {
+	return tryEvaluateCondition(expr, ctx).value;
+}

package/extensions/render.ts

@@ -7,7 +7,7 @@
 
 import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { formatTokens, type UsageStats } from "./runner.ts";
+import { formatTokens, type UsageStats } from "./usage.ts";
 import type { PhaseState, RunState } from "./store.ts";
 import { dependenciesOf, type Phase, topoLayers } from "./schema.ts";
 
@@ -121,7 +121,7 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 		return theme.fg("muted", `skipped · ${snip}`);
 	}
 
-	const isFanout = type === "map" || type === "parallel";
+	const isFanout = type === "map" || type === "parallel" || type === "flow";
 
 	if (ps.status === "failed") {
 		const e = (ps.error ?? "failed").replace(/\s+/g, " ");
@@ -171,6 +171,14 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 	// single-agent done
 	const model = shortModel(ps.model);
 	const u = compactUsage(ps.usage, theme);
+	if (ps.approval) {
+		const d = ps.approval.decision;
+		const color = d === "reject" ? "error" : d === "edit" ? "warning" : "success";
+		let a = theme.fg(color as Parameters<typeof theme.fg>[0], theme.bold(d.toUpperCase()));
+		if (ps.approval.auto) a += theme.fg("dim", " auto");
+		if (time) a += `  ${time}`;
+		return a;
+	}
 	if (ps.gate) {
 		const badge =
 			ps.gate.verdict === "block" ? theme.fg("error", theme.bold("BLOCK")) : theme.fg("success", "PASS");
@@ -186,6 +194,7 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 	let s = "";
 	if (model) s += theme.fg("accent", model);
 	if (u) s += (s ? "  " : "") + u;
+	if (ps.attempts && ps.attempts > 1) s += theme.fg("warning", `  ↻${ps.attempts - 1}`);
 	if (time) s += `  ${time}`;
 	return s || theme.fg("dim", "done");
 }
@@ -217,7 +226,9 @@ function headerLine(state: RunState, theme: Theme): string {
 	if (failed) line += theme.fg("error", ` · ${failed}✗`);
 	if (state.status === "blocked") line += theme.fg("error", " · blocked");
 	const cost = aggregateCost(state);
-	if (cost) line += theme.fg("muted", ` · $${cost.toFixed(3)}`);
+	const budget = state.def.budget;
+	if (budget?.maxUSD !== undefined) line += theme.fg("muted", ` · $${cost.toFixed(3)}/$${budget.maxUSD}`);
+	else if (cost) line += theme.fg("muted", ` · $${cost.toFixed(3)}`);
 	const el = runElapsed(state);
 	if (el) line += theme.fg("dim", ` · ${elapsed(el)}`);
 	return line;

package/extensions/runner.ts

@@ -11,20 +11,7 @@ import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig } from "./agents.ts";
-
-export interface UsageStats {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	contextTokens: number;
-	turns: number;
-}
-
-export function emptyUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
-}
+import { emptyUsage, type UsageStats } from "./usage.ts";
 
 export interface RunResult {
 	agent: string;
@@ -36,6 +23,8 @@ export interface RunResult {
 	model?: string;
 	stopReason?: string;
 	errorMessage?: string;
+	/** Total subagent attempts incl. retries (set by the runtime's retry wrapper). */
+	attempts?: number;
 }
 
 export interface LiveUpdate {
@@ -71,6 +60,56 @@ function getFinalOutput(messages: Message[]): string {
 	return "";
 }
 
+/** Accumulated state folded from a subagent's NDJSON event stream. */
+export interface EventAccumulator {
+	messages: Message[];
+	usage: UsageStats;
+	model?: string;
+	stopReason?: string;
+	errorMessage?: string;
+	lastActivity: string;
+}
+
+export function newAccumulator(model?: string): EventAccumulator {
+	return { messages: [], usage: emptyUsage(), model, lastActivity: "" };
+}
+
+/**
+ * Fold one NDJSON line into the accumulator. Returns a LiveUpdate when an
+ * assistant message ended (for streaming), else null. Empty, malformed, and
+ * non-`message_end` lines are ignored — making the parser robust to partial
+ * buffers/noise and unit-testable without spawning a process.
+ */
+export function foldEventLine(acc: EventAccumulator, line: string): LiveUpdate | null {
+	if (!line.trim()) return null;
+	let event: any;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (event.type !== "message_end" || !event.message) return null;
+	const msg = event.message as Message;
+	acc.messages.push(msg);
+	if (msg.role !== "assistant") return null;
+	acc.usage.turns++;
+	const u = (msg as any).usage;
+	if (u) {
+		acc.usage.input += u.input || 0;
+		acc.usage.output += u.output || 0;
+		acc.usage.cacheRead += u.cacheRead || 0;
+		acc.usage.cacheWrite += u.cacheWrite || 0;
+		acc.usage.cost += u.cost?.total || 0;
+		acc.usage.contextTokens = u.totalTokens || 0;
+	}
+	if (!acc.model && (msg as any).model) acc.model = (msg as any).model;
+	if ((msg as any).stopReason) acc.stopReason = (msg as any).stopReason;
+	if ((msg as any).errorMessage) acc.errorMessage = (msg as any).errorMessage;
+	const activity = describeActivity(msg);
+	if (activity) acc.lastActivity = activity;
+	return { text: acc.lastActivity, usage: { ...acc.usage }, model: acc.model };
+}
+
 /** One-line description of the most recent assistant activity (text or tool call). */
 function describeActivity(msg: Message): string {
 	if (msg.role !== "assistant") return "";
@@ -177,8 +216,7 @@ export async function runAgentTask(
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;
 
-	const messages: Message[] = [];
-	let lastActivity = "";
+	const acc = newAccumulator(model);
 	const result: RunResult = {
 		agent: agentName,
 		task,
@@ -209,36 +247,8 @@ export async function runAgentTask(
 			let buffer = "";
 
 			const processLine = (line: string) => {
-				if (!line.trim()) return;
-				let event: any;
-				try {
-					event = JSON.parse(line);
-				} catch {
-					return;
-				}
-				if (event.type === "message_end" && event.message) {
-					const msg = event.message as Message;
-					messages.push(msg);
-					if (msg.role === "assistant") {
-						result.usage.turns++;
-						const u = (msg as any).usage;
-						if (u) {
-							result.usage.input += u.input || 0;
-							result.usage.output += u.output || 0;
-							result.usage.cacheRead += u.cacheRead || 0;
-							result.usage.cacheWrite += u.cacheWrite || 0;
-							result.usage.cost += u.cost?.total || 0;
-							result.usage.contextTokens = u.totalTokens || 0;
-						}
-						if (!result.model && (msg as any).model) result.model = (msg as any).model;
-						if ((msg as any).stopReason) result.stopReason = (msg as any).stopReason;
-						if ((msg as any).errorMessage) result.errorMessage = (msg as any).errorMessage;
-						const activity = describeActivity(msg);
-						if (activity) lastActivity = activity;
-						if (opts.onLive)
-							opts.onLive({ text: lastActivity, usage: { ...result.usage }, model: result.model });
-					}
-				}
+				const live = foldEventLine(acc, line);
+				if (live && opts.onLive) opts.onLive(live);
 			};
 
 			proc.stdout.on("data", (data) => {
@@ -270,7 +280,11 @@ export async function runAgentTask(
 		});
 
 		result.exitCode = exitCode;
-		result.output = getFinalOutput(messages);
+		result.usage = acc.usage;
+		result.model = acc.model;
+		result.stopReason = acc.stopReason;
+		result.errorMessage = acc.errorMessage;
+		result.output = getFinalOutput(acc.messages);
 		if (wasAborted) {
 			result.stopReason = "aborted";
 			result.errorMessage = "Subagent was aborted";
@@ -317,34 +331,3 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 	await Promise.all(workers);
 	return results;
 }
-
-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`;
-}
-
-export function formatUsage(usage: UsageStats, model?: string): string {
-	const parts: string[] = [];
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	if (model) parts.push(model);
-	return parts.join(" ");
-}
-
-export function aggregateUsage(usages: UsageStats[]): UsageStats {
-	const total = emptyUsage();
-	for (const u of usages) {
-		total.input += u.input;
-		total.output += u.output;
-		total.cacheRead += u.cacheRead;
-		total.cacheWrite += u.cacheWrite;
-		total.cost += u.cost;
-		total.turns += u.turns;
-	}
-	return total;
-}