pi-crew 0.1.45 → 0.1.49

package/src/ui/transcript-entries.ts

@@ -0,0 +1,258 @@
+import { truncate } from "../utils/visual.ts";
+
+export interface TranscriptEntry {
+	id: number;
+	type: "message" | "tool_call" | "tool_result" | "system";
+	role?: string;
+	toolName?: string;
+	summary: string;
+	content: string;
+	expanded: boolean;
+	timestamp?: number;
+}
+
+/** Extract plain text from Pi-style content (string or array of content parts). */
+function textFromContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part: unknown) => {
+			if (!part || typeof part !== "object" || Array.isArray(part)) return "";
+			const obj = part as Record<string, unknown>;
+			if (typeof obj.text === "string") return obj.text;
+			if (typeof obj.content === "string") return obj.content;
+			if (typeof obj.name === "string") return `[tool:${obj.name}]`;
+			return "";
+		})
+		.filter(Boolean)
+		.join("\n");
+}
+
+/** Safely cast unknown to a record for property access. */
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+/** Detect if an event type is a tool invocation (call/use/start). */
+function isToolCallType(type: string): boolean {
+	return type === "tool_call" || type === "tool_use" || type === "toolCall" || type === "tool_execution_start";
+}
+
+/** Detect if an event type is a tool response (result/end). */
+function isToolResultType(type: string): boolean {
+	return type === "tool_result" || type === "toolCallEnd" || type === "tool_result_end";
+}
+
+/** Extract tool name from various event shapes. */
+function extractToolName(obj: Record<string, unknown>): string | undefined {
+	const name =
+		typeof obj.toolName === "string" ? obj.toolName :
+		typeof obj.name === "string" ? obj.name :
+		typeof obj.tool === "string" ? obj.tool :
+		undefined;
+	return name;
+}
+
+/** Create a single-line summary from text, truncating if needed. */
+function summarize(text: string, maxLength: number): string {
+	const oneLine = text.replace(/\r?\n/g, " ").trim();
+	if (oneLine.length <= maxLength) return oneLine;
+	return oneLine.slice(0, maxLength - 1) + "…";
+}
+
+const SUMMARY_MAX = 120;
+
+/** Parse raw JSONL lines into TranscriptEntry[].
+ *
+ * Grouping rules:
+ * - tool_call events are grouped with their subsequent tool_result into one entry.
+ * - message events (message_end, etc.) become their own entry.
+ * - Everything else becomes a system entry.
+ */
+export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
+	const entries: TranscriptEntry[] = [];
+	let id = 0;
+
+	// Pre-parse valid JSON lines
+	const parsed: Array<{ raw: string; obj: Record<string, unknown> }> = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const json: unknown = JSON.parse(trimmed);
+			const obj = asRecord(json);
+			if (obj) parsed.push({ raw: trimmed, obj });
+		} catch {
+			// Non-JSON line → treat as a system entry
+			entries.push({
+				id: id++,
+				type: "system",
+				summary: summarize(trimmed, SUMMARY_MAX),
+				content: trimmed,
+				expanded: false,
+			});
+		}
+	}
+
+	let i = 0;
+	while (i < parsed.length) {
+		const { obj } = parsed[i]!;
+		const type = typeof obj.type === "string" ? obj.type : "";
+		const timestamp = typeof obj.timestamp === "number" ? obj.timestamp : undefined;
+
+		if (isToolCallType(type)) {
+			// Look ahead for matching tool_result
+			const toolName = extractToolName(obj) ?? "unknown";
+			const inputText =
+				typeof obj.input === "string" ? obj.input :
+				obj.input !== undefined ? JSON.stringify(obj.input) : "";
+			let resultText = "";
+			let isError = false;
+			let resultTimestamp = timestamp;
+
+			// Consume consecutive tool_result lines
+			let j = i + 1;
+			while (j < parsed.length) {
+				const nextTypeVal = parsed[j]!.obj.type;
+				const nextType = typeof nextTypeVal === "string" ? nextTypeVal : "";
+				if (isToolResultType(nextType) || /tool/i.test(nextType)) {
+					const robj = parsed[j]!.obj;
+					const rt =
+						typeof robj.text === "string" ? robj.text :
+						typeof robj.result === "string" ? robj.result :
+						robj.result !== undefined ? JSON.stringify(robj.result) : "";
+					resultText = rt;
+					isError = robj.isError === true;
+					resultTimestamp = typeof robj.timestamp === "number" ? robj.timestamp : resultTimestamp;
+					j++;
+					break;
+				}
+				if (isToolCallType(nextType)) break; // next tool call, stop looking
+				j++;
+			}
+
+			const callSummary = summarize(`🔧 ${toolName}${inputText ? ": " + summarize(inputText, 60) : ""}`, SUMMARY_MAX);
+			const callContent = [
+				`[Tool Call: ${toolName}]`,
+				inputText || "(no input)",
+				`[Result${isError ? " ✗" : " ✓"}]`,
+				resultText || "(no output)",
+			].join("\n");
+
+			entries.push({
+				id: id++,
+				type: "tool_call",
+				toolName,
+				summary: callSummary,
+				content: callContent,
+				expanded: false,
+				timestamp: resultTimestamp ?? timestamp,
+			});
+			i = j;
+			continue;
+		}
+
+		if (isToolResultType(type) || /tool/i.test(type)) {
+			// Standalone tool result (no preceding tool_call consumed it)
+			const toolName = extractToolName(obj) ?? "unknown";
+			const isError = obj.isError === true;
+			const text =
+				typeof obj.text === "string" ? obj.text :
+				typeof obj.result === "string" ? obj.result :
+				obj.result !== undefined ? JSON.stringify(obj.result) : "";
+
+			const summary = summarize(`${isError ? "✗" : "✓"} ${toolName}${text ? ": " + summarize(text, 60) : ""}`, SUMMARY_MAX);
+			const content = [
+				`[Tool Result: ${toolName}${isError ? " (error)" : ""}]`,
+				text || "(no output)",
+			].join("\n");
+
+			entries.push({
+				id: id++,
+				type: "tool_result",
+				toolName,
+				summary,
+				content,
+				expanded: false,
+				timestamp,
+			});
+			i++;
+			continue;
+		}
+
+		// Message events (message_end, message_start, etc.)
+		const message = asRecord(obj.message);
+		if (message || type.startsWith("message")) {
+			const msg = message ?? obj;
+			const role = typeof msg.role === "string" ? msg.role : "unknown";
+			const text = textFromContent(msg.content);
+
+			const label = role === "assistant" ? "🤖" : role === "user" ? "👤" : "💬";
+			const summary = summarize(`${label} ${role}${text ? ": " + summarize(text, 80) : ""}`, SUMMARY_MAX);
+			const content = `[${role.charAt(0).toUpperCase()}${role.slice(1)}]:\n${text || "(empty)"}`;
+
+			entries.push({
+				id: id++,
+				type: "message",
+				role,
+				summary,
+				content,
+				expanded: false,
+				timestamp,
+			});
+			i++;
+			continue;
+		}
+
+		// Everything else → system entry
+		const text = textFromContent(obj.content) || (typeof obj.text === "string" ? obj.text : "");
+		const displayText = text || type || JSON.stringify(obj);
+		entries.push({
+			id: id++,
+			type: "system",
+			summary: summarize(`⚙ ${type ? `[${type}]` : ""} ${summarize(displayText, 80)}`, SUMMARY_MAX),
+			content: displayText,
+			expanded: false,
+			timestamp,
+		});
+		i++;
+	}
+
+	return entries;
+}
+
+/** Toggle expand/collapse for an entry by index. Returns a new array. */
+export function toggleEntry(entries: TranscriptEntry[], index: number): TranscriptEntry[] {
+	return entries.map((entry, i) =>
+		i === index ? { ...entry, expanded: !entry.expanded } : entry,
+	);
+}
+
+/** Render entries into display lines, respecting expand/collapse.
+ *  Collapsed entries produce 1 line (summary). Expanded entries produce multi-line content.
+ *  Every line is truncated to maxWidth.
+ */
+export function renderEntries(entries: TranscriptEntry[], maxWidth: number): string[] {
+	const effectiveWidth = Math.max(1, maxWidth);
+	const lines: string[] = [];
+
+	for (const entry of entries) {
+		if (entry.expanded) {
+			const contentLines = entry.content.split(/\r?\n/);
+			if (contentLines.length === 0 || (contentLines.length === 1 && contentLines[0] === "")) {
+				lines.push(truncate(`▸ ${entry.summary}`, effectiveWidth));
+			} else {
+				lines.push(truncate(`▾ ${entry.summary}`, effectiveWidth));
+				for (const line of contentLines) {
+					lines.push(truncate(`  ${line}`, effectiveWidth));
+				}
+			}
+		} else {
+			lines.push(truncate(`▸ ${entry.summary}`, effectiveWidth));
+		}
+	}
+
+	return lines;
+}

package/src/utils/ids.ts

@@ -1,4 +1,5 @@
 import { randomBytes } from "node:crypto";
+import { generateTaskName } from "./task-name-generator.ts";
 
 export function createRunId(prefix = "team"): string {
 	const stamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
@@ -10,3 +11,7 @@ export function createTaskId(stepId: string, index: number): string {
 	const normalized = stepId.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "task";
 	return `${String(index + 1).padStart(2, "0")}_${normalized}`;
 }
+
+export function createDisplayName(): string {
+	return generateTaskName();
+}

package/src/utils/incremental-reader.ts

@@ -0,0 +1,104 @@
+import * as fs from "node:fs";
+
+export interface IncrementalReadState {
+	byteOffset: number;
+	lineCount: number;
+}
+
+export interface IncrementalReadResult {
+	lines: string[];
+	state: IncrementalReadState;
+	eof: boolean;
+}
+
+const CHUNK_SIZE = 64 * 1024;
+
+/**
+ * Read new lines from a text file since last known byte offset.
+ * Uses fs.openSync + fs.readSync for efficient incremental reading.
+ */
+export function readLinesSince(filePath: string, state: IncrementalReadState): IncrementalReadResult {
+	let fd: number | undefined;
+	try {
+		fd = fs.openSync(filePath, "r");
+	} catch {
+		return { lines: [], state: { byteOffset: state.byteOffset, lineCount: state.lineCount }, eof: true };
+	}
+
+	try {
+		const stat = fs.fstatSync(fd);
+		const fileSize = stat.size;
+
+		if (fileSize <= state.byteOffset) {
+			return {
+				lines: [],
+				state: { byteOffset: fileSize, lineCount: state.lineCount },
+				eof: true,
+			};
+		}
+
+		const bytesToRead = fileSize - state.byteOffset;
+		const buf = Buffer.alloc(bytesToRead);
+		let totalRead = 0;
+
+		while (totalRead < bytesToRead) {
+			const chunkSize = Math.min(CHUNK_SIZE, bytesToRead - totalRead);
+			const bytesRead = fs.readSync(fd, buf, totalRead, chunkSize, state.byteOffset + totalRead);
+			if (bytesRead === 0) break;
+			totalRead += bytesRead;
+		}
+
+		const content = buf.toString("utf-8", 0, totalRead);
+		const lines: string[] = [];
+		let lineCount = state.lineCount;
+		let committedOffset = state.byteOffset;
+
+		let searchFrom = 0;
+		let newlineIdx: number;
+
+		while ((newlineIdx = content.indexOf("\n", searchFrom)) !== -1) {
+			const lineText = content.slice(searchFrom, newlineIdx);
+			committedOffset = state.byteOffset + newlineIdx + 1;
+			searchFrom = newlineIdx + 1;
+			if (lineText.length > 0) {
+				lines.push(lineText);
+				lineCount++;
+			}
+		}
+
+		const eof = committedOffset >= fileSize;
+
+		return {
+			lines,
+			state: { byteOffset: committedOffset, lineCount },
+			eof,
+		};
+	} finally {
+		if (fd !== undefined) {
+			try { fs.closeSync(fd); } catch { /* ignore */ }
+		}
+	}
+}
+
+/**
+ * Read parsed JSON objects from a JSONL file since last known byte offset.
+ * Skips malformed lines.
+ */
+export function readJsonlSince<T>(filePath: string, state: IncrementalReadState): { items: T[]; state: IncrementalReadState; eof: boolean } {
+	const result = readLinesSince(filePath, state);
+	const items: T[] = [];
+
+	for (const line of result.lines) {
+		try {
+			items.push(JSON.parse(line) as T);
+		} catch {
+			// Skip malformed lines
+		}
+	}
+
+	return {
+		items,
+		state: result.state,
+		eof: result.eof,
+	};
+}

package/src/utils/paths.ts

@@ -48,12 +48,14 @@ export function projectPiRoot(cwd: string): string {
 
 export function projectCrewRoot(cwd: string): string {
 	const repoRoot = findRepoRoot(cwd) ?? cwd;
+	const crewDir = path.join(repoRoot, ".crew");
+	// Keep an existing .crew/ stable even when .pi/ exists for project config.
+	if (fs.existsSync(crewDir)) return crewDir;
 	// Legacy reuse: if .pi/ already exists for the project, namespace under .pi/teams/
 	// to avoid creating a parallel .crew/ alongside an existing pi project layout.
 	const piDir = path.join(repoRoot, ".pi");
 	if (fs.existsSync(piDir)) return path.join(piDir, "teams");
-	// Otherwise default to .crew/ (also kept stable if it already exists).
-	return path.join(repoRoot, ".crew");
+	return crewDir;
 }
 
 export function userCrewRoot(): string {

package/src/utils/scan-cache.ts

@@ -0,0 +1,137 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface ScanEntry {
+	/** Unique key for this entry (e.g., runId, artifactPath) */
+	key: string;
+	/** Filesystem path */
+	path: string;
+	/** Raw content (parsed JSON or text) */
+	raw: unknown;
+	/** File modification time */
+	mtimeMs: number;
+	/** File size in bytes */
+	sizeBytes: number;
+	/** When this entry was loaded */
+	loadedAtMs: number;
+}
+
+export interface ScanCacheOptions {
+	/** TTL in ms for cached entries. Default 1000. */
+	ttlMs?: number;
+	/** Maximum number of entries. Default 100. */
+	maxEntries?: number;
+}
+
+interface CacheBucket {
+	entries: Map<string, ScanEntry>;
+	expireAtMs: number;
+}
+
+/**
+ * Shared raw scan-entry cache for runs, artifacts, mailbox, transcripts.
+ * Provides deterministic sort order and invalidation on mutation.
+ */
+export class SharedScanCache {
+	#buckets = new Map<string, CacheBucket>();
+	#ttlMs: number;
+	#maxEntries: number;
+	#now: () => number;
+
+	constructor(options: ScanCacheOptions = {}) {
+		this.#ttlMs = options.ttlMs ?? 1000;
+		this.#maxEntries = options.maxEntries ?? 100;
+		this.#now = () => Date.now();
+	}
+
+	/** Get a cached entry by bucket and key. Returns undefined if not cached or expired. */
+	get(bucket: string, key: string): ScanEntry | undefined {
+		const b = this.#buckets.get(bucket);
+		if (!b) return undefined;
+		if (this.#now() > b.expireAtMs) {
+			this.#buckets.delete(bucket);
+			return undefined;
+		}
+		return b.entries.get(key);
+	}
+
+	/** Get all entries in a bucket. Returns empty array if expired or missing. */
+	list(bucket: string): ScanEntry[] {
+		const b = this.#buckets.get(bucket);
+		if (!b) return [];
+		if (this.#now() > b.expireAtMs) {
+			this.#buckets.delete(bucket);
+			return [];
+		}
+		return [...b.entries.values()].sort((a, b) => a.key.localeCompare(b.key));
+	}
+
+	/** Set an entry in a bucket. */
+	set(bucket: string, entry: ScanEntry): void {
+		let b = this.#buckets.get(bucket);
+		if (!b || this.#now() > b.expireAtMs) {
+			b = { entries: new Map(), expireAtMs: this.#now() + this.#ttlMs };
+			this.#buckets.set(bucket, b);
+		}
+		if (b.entries.size >= this.#maxEntries) {
+			// Evict oldest entry
+			const firstKey = b.entries.keys().next().value;
+			if (firstKey !== undefined) b.entries.delete(firstKey);
+		}
+		b.entries.set(entry.key, entry);
+	}
+
+	/** Invalidate a specific key in a bucket. */
+	invalidate(bucket: string, key: string): void {
+		const b = this.#buckets.get(bucket);
+		if (b) b.entries.delete(key);
+	}
+
+	/** Invalidate an entire bucket. */
+	invalidateBucket(bucket: string): void {
+		this.#buckets.delete(bucket);
+	}
+
+	/** Invalidate all buckets. */
+	clear(): void {
+		this.#buckets.clear();
+	}
+
+	/** Read a file, parse if JSON, and cache the result. */
+	readAndCache(bucket: string, key: string, filePath: string, parseJson = true): ScanEntry | undefined {
+		try {
+			if (!fs.existsSync(filePath)) return undefined;
+			const stat = fs.statSync(filePath);
+			const cached = this.get(bucket, key);
+			if (cached && cached.mtimeMs >= stat.mtimeMs && cached.sizeBytes === stat.size) return cached;
+			const content = fs.readFileSync(filePath, "utf-8");
+			const raw = parseJson ? JSON.parse(content) : content;
+			const entry: ScanEntry = { key, path: filePath, raw, mtimeMs: stat.mtimeMs, sizeBytes: stat.size, loadedAtMs: this.#now() };
+			this.set(bucket, entry);
+			return entry;
+		} catch {
+			return undefined;
+		}
+	}
+
+	/** Read a directory and cache entries for each file. */
+	scanAndCache(bucket: string, dirPath: string, parseJson = true): ScanEntry[] {
+		try {
+			if (!fs.existsSync(dirPath)) return [];
+			const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+			const results: ScanEntry[] = [];
+			for (const entry of entries) {
+				if (!entry.isFile()) continue;
+				const filePath = path.join(dirPath, entry.name);
+				const cached = this.readAndCache(bucket, entry.name, filePath, parseJson);
+				if (cached) results.push(cached);
+			}
+			return results.sort((a, b) => a.key.localeCompare(b.key));
+		} catch {
+			return [];
+		}
+	}
+}
+
+/** Global shared scan cache instance. */
+export const sharedScanCache = new SharedScanCache();

package/src/utils/sse-parser.ts

@@ -0,0 +1,134 @@
+/** A single Server-Sent Event */
+export interface ServerSentEvent {
+	event: string | null;
+	data: string;
+	raw: string[];
+}
+
+/** L1: Maximum number of raw lines before discarding an oversized event. */
+const MAX_EVENT_LINES = 1000;
+
+/** Read newline-delimited lines from a text ReadableStream, buffering partial chunks. */
+async function* readLines(
+	stream: ReadableStream<string>,
+	signal?: AbortSignal,
+): AsyncGenerator<string> {
+	const reader = stream.getReader();
+	let buffer = "";
+	try {
+		while (true) {
+			if (signal?.aborted) return;
+			const { done, value } = await reader.read();
+			if (done) {
+				if (buffer.length > 0) yield buffer;
+				return;
+			}
+			buffer += value;
+			let idx: number;
+			while ((idx = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.endsWith("\r\n", idx + 1)
+					? buffer.slice(0, idx - 1)
+					: buffer.slice(0, idx);
+				yield line;
+				buffer = buffer.slice(idx + 1);
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+/** Parse SSE events from a byte stream */
+export async function* readSseEvents(
+	stream: ReadableStream<Uint8Array>,
+	signal?: AbortSignal,
+): AsyncGenerator<ServerSentEvent> {
+	const textStream = stream.pipeThrough(new TextDecoderStream() as unknown as TransformStream<Uint8Array, string>);
+	let currentEvent: string | null = null;
+	let currentData: string[] = [];
+	let currentRaw: string[] = [];
+
+	function flush(): ServerSentEvent | null {
+		if (currentData.length === 0 && currentEvent === null) return null;
+		const evt: ServerSentEvent = {
+			event: currentEvent,
+			data: currentData.join("\n"),
+			raw: currentRaw,
+		};
+		currentEvent = null;
+		currentData = [];
+		currentRaw = [];
+		return evt;
+	}
+
+	for await (const line of readLines(textStream, signal)) {
+		if (signal?.aborted) return;
+
+		// Empty line → dispatch
+		if (line === "") {
+			const evt = flush();
+			if (evt) yield evt;
+			continue;
+		}
+
+		// Comment
+		if (line.startsWith(":")) continue;
+
+		// [DONE] sentinel
+		if (line === "[DONE]") return;
+
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) {
+			// Field with no value
+			const field = line;
+			if (field === "event") {
+				currentEvent = "";
+			} else if (field === "data") {
+				currentData.push("");
+			}
+			currentRaw.push(line);
+			continue;
+		}
+
+		const field = line.slice(0, colonIdx);
+		let value = line.slice(colonIdx + 1);
+		// Remove leading space after colon per SSE spec
+		if (value.startsWith(" ")) value = value.slice(1);
+
+		currentRaw.push(line);
+
+		// L1: Guard against unbounded memory growth
+		if (currentRaw.length > MAX_EVENT_LINES) {
+			const evt = flush();
+			if (evt) yield evt;
+			continue;
+		}
+
+		if (field === "event") {
+			currentEvent = value;
+		} else if (field === "data") {
+			currentData.push(value);
+		}
+		// id / retry fields ignored
+	}
+
+	// Flush any remaining event at end of stream
+	const evt = flush();
+	if (evt) yield evt;
+}
+
+/** Parse SSE events and yield parsed JSON data objects */
+export async function* readSseJson<T>(
+	stream: ReadableStream<Uint8Array>,
+	signal?: AbortSignal,
+): AsyncGenerator<T> {
+	for await (const evt of readSseEvents(stream, signal)) {
+		try {
+			const parsed: T = JSON.parse(evt.data) as T;
+			yield parsed;
+		} catch {
+			// Skip non-JSON SSE data events (e.g., ping, error messages, sentinels)
+			continue;
+		}
+	}
+}