pi-crew 0.1.7 → 0.1.9

package/src/ui/transcript-viewer.ts

@@ -0,0 +1,204 @@
+import * as fs from "node:fs";
+type Component = { invalidate(): void; render(width: number): string[]; handleInput(data: string): void };
+type TranscriptTheme = { fg?: (color: string, text: string) => string; bold?: (text: string) => string };
+import type { TeamRunManifest } from "../state/types.ts";
+import { agentOutputPath, readCrewAgents } from "../runtime/crew-agent-records.ts";
+
+function visibleWidth(text: string): number {
+	return text.replace(/\u001b\[[0-?]*[ -/]*[@-~]/g, "").length;
+}
+
+function truncate(text: string, width: number): string {
+	if (width <= 0) return "";
+	if (visibleWidth(text) <= width) return text;
+	return width <= 1 ? "…" : `${text.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function wrap(text: string, width: number): string[] {
+	const source = text.split(/\r?\n/);
+	const lines: string[] = [];
+	for (const raw of source) {
+		const line = raw || " ";
+		if (line.length <= width) {
+			lines.push(line);
+			continue;
+		}
+		for (let index = 0; index < line.length; index += width) lines.push(line.slice(index, index + width));
+	}
+	return lines;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function textFromContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((part) => {
+		const obj = asRecord(part);
+		if (!obj) return "";
+		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");
+}
+
+export function formatTranscriptEvent(event: unknown): string[] {
+	const obj = asRecord(event);
+	if (!obj) return [String(event)];
+	const type = typeof obj.type === "string" ? obj.type : undefined;
+	const toolName = typeof obj.toolName === "string" ? obj.toolName : typeof obj.name === "string" ? obj.name : undefined;
+	if (type && /tool/i.test(type)) {
+		const text = textFromContent(obj.content) || (typeof obj.text === "string" ? obj.text : typeof obj.result === "string" ? obj.result : "");
+		return [`[tool${toolName ? `:${toolName}` : ""} ${type}]: ${text.trim() || "(no output)"}`];
+	}
+	const message = asRecord(obj.message);
+	if (message) {
+		const role = typeof message.role === "string" ? message.role : "message";
+		const text = textFromContent(message.content);
+		if (text.trim()) return [`[${role}]: ${text.trim()}`];
+	}
+	if (type) {
+		const text = textFromContent(obj.content) || (typeof obj.text === "string" ? obj.text : "");
+		return text.trim() ? [`[${type}]: ${text.trim()}`] : [`[${type}]`];
+	}
+	return [JSON.stringify(event)];
+}
+
+export function formatTranscriptText(text: string): string[] {
+	const lines: string[] = [];
+	for (const raw of text.split(/\r?\n/).filter(Boolean)) {
+		try {
+			lines.push(...formatTranscriptEvent(JSON.parse(raw)));
+		} catch {
+			lines.push(raw);
+		}
+	}
+	return lines.length ? lines : ["(no transcript content)"];
+}
+
+export function readRunTranscript(manifest: TeamRunManifest, taskId?: string): { title: string; path: string; lines: string[] } {
+	const agents = readCrewAgents(manifest);
+	const agent = taskId ? agents.find((item) => item.taskId === taskId || item.id === taskId) : agents.find((item) => item.transcriptPath) ?? agents[0];
+	const selectedTaskId = agent?.taskId ?? taskId ?? "unknown";
+	const transcriptPath = agent?.transcriptPath && fs.existsSync(agent.transcriptPath) ? agent.transcriptPath : agentOutputPath(manifest, selectedTaskId);
+	const text = fs.existsSync(transcriptPath) ? fs.readFileSync(transcriptPath, "utf-8") : "";
+	return { title: `${manifest.runId}:${selectedTaskId}`, path: transcriptPath, lines: formatTranscriptText(text) };
+}
+
+export class DurableTextViewer implements Component {
+	private scroll = 0;
+	private lastHeight = 10;
+	private title: string;
+	private subtitle: string;
+	private lines: string[];
+	private theme: unknown;
+	private done: (result: undefined) => void;
+
+	constructor(title: string, subtitle: string, lines: string[], theme: unknown, done: (result: undefined) => void) {
+		this.title = title;
+		this.subtitle = subtitle;
+		this.lines = lines.length ? lines : ["(empty)"];
+		this.theme = theme;
+		this.done = done;
+	}
+
+	invalidate(): void {}
+
+	handleInput(data: string): void {
+		if (data === "q" || data === "\u001b") {
+			this.done(undefined);
+			return;
+		}
+		const maxScroll = Math.max(0, this.lines.length - this.lastHeight);
+		if (data === "k" || data === "\u001b[A") this.scroll = Math.max(0, this.scroll - 1);
+		else if (data === "j" || data === "\u001b[B") this.scroll = Math.min(maxScroll, this.scroll + 1);
+		else if (data === "g") this.scroll = 0;
+		else if (data === "G") this.scroll = maxScroll;
+	}
+
+	render(width: number): string[] {
+		const th = this.theme as TranscriptTheme;
+		const fg = th.fg?.bind(th) ?? ((_color: string, text: string) => text);
+		const bold = th.bold?.bind(th) ?? ((text: string) => text);
+		const inner = Math.max(20, width - 4);
+		this.lastHeight = 16;
+		const body = this.lines.flatMap((line) => wrap(line, inner));
+		const maxScroll = Math.max(0, body.length - this.lastHeight);
+		this.scroll = Math.min(this.scroll, maxScroll);
+		const visible = body.slice(this.scroll, this.scroll + this.lastHeight);
+		const pad = (text: string) => `${text}${" ".repeat(Math.max(0, inner - visibleWidth(text)))}`;
+		const row = (text: string) => `${fg("border", "│")} ${truncate(pad(text), inner)} ${fg("border", "│")}`;
+		return [
+			fg("border", `╭${"─".repeat(inner + 2)}╮`),
+			row(`${bold(this.title)} ${fg("dim", this.subtitle)}`),
+			row(fg("dim", "j/k scroll · g/G top/bottom · q close")),
+			fg("border", `├${"─".repeat(inner + 2)}┤`),
+			...visible.map(row),
+			fg("border", `├${"─".repeat(inner + 2)}┤`),
+			row(fg("dim", `${body.length} lines · ${body.length ? Math.round(((this.scroll + visible.length) / body.length) * 100) : 100}%`)),
+			fg("border", `╰${"─".repeat(inner + 2)}╯`),
+		];
+	}
+}
+
+export class DurableTranscriptViewer implements Component {
+	private scroll = 0;
+	private lastHeight = 10;
+	private manifest: TeamRunManifest;
+	private theme: unknown;
+	private done: (result: undefined) => void;
+	private taskId?: string;
+
+	constructor(manifest: TeamRunManifest, theme: unknown, done: (result: undefined) => void, taskId?: string) {
+		this.manifest = manifest;
+		this.theme = theme;
+		this.done = done;
+		this.taskId = taskId;
+	}
+
+	invalidate(): void {}
+
+	handleInput(data: string): void {
+		if (data === "q" || data === "\u001b") {
+			this.done(undefined);
+			return;
+		}
+		const content = readRunTranscript(this.manifest, this.taskId).lines;
+		const maxScroll = Math.max(0, content.length - this.lastHeight);
+		if (data === "k" || data === "\u001b[A") this.scroll = Math.max(0, this.scroll - 1);
+		else if (data === "j" || data === "\u001b[B") this.scroll = Math.min(maxScroll, this.scroll + 1);
+		else if (data === "g") this.scroll = 0;
+		else if (data === "G") this.scroll = maxScroll;
+	}
+
+	render(width: number): string[] {
+		const th = this.theme as TranscriptTheme;
+		const fg = th.fg?.bind(th) ?? ((_color: string, text: string) => text);
+		const bold = th.bold?.bind(th) ?? ((text: string) => text);
+		const inner = Math.max(20, width - 4);
+		const data = readRunTranscript(this.manifest, this.taskId);
+		const body = data.lines.flatMap((line) => wrap(line, inner));
+		this.lastHeight = 16;
+		const maxScroll = Math.max(0, body.length - this.lastHeight);
+		this.scroll = Math.min(this.scroll, maxScroll);
+		const visible = body.slice(this.scroll, this.scroll + this.lastHeight);
+		const pad = (text: string) => `${text}${" ".repeat(Math.max(0, inner - visibleWidth(text)))}`;
+		const row = (text: string) => `${fg("border", "│")} ${truncate(pad(text), inner)} ${fg("border", "│")}`;
+		const lines = [
+			fg("border", `╭${"─".repeat(inner + 2)}╮`),
+			row(`${bold("pi-crew transcript")} ${fg("dim", data.title)}`),
+			row(fg("dim", data.path)),
+			row(fg("dim", "j/k scroll · g/G top/bottom · q close")),
+			fg("border", `├${"─".repeat(inner + 2)}┤`),
+			...visible.map(row),
+			fg("border", `├${"─".repeat(inner + 2)}┤`),
+			row(fg("dim", `${body.length} lines · ${body.length ? Math.round(((this.scroll + visible.length) / body.length) * 100) : 100}%`)),
+			fg("border", `╰${"─".repeat(inner + 2)}╯`),
+		];
+		return lines;
+	}
+}
+

package/src/utils/file-coalescer.ts

@@ -0,0 +1,33 @@
+interface TimerApi {
+	setTimeout(handler: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+}
+
+const defaultTimerApi: TimerApi = {
+	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+export interface FileCoalescer {
+	schedule(file: string, delayMs?: number): boolean;
+	clear(): void;
+}
+
+export function createFileCoalescer(handler: (file: string) => void, defaultDelayMs: number, timerApi: TimerApi = defaultTimerApi): FileCoalescer {
+	const pending = new Map<string, unknown>();
+	return {
+		schedule(file, delayMs = defaultDelayMs) {
+			if (pending.has(file)) return false;
+			const timer = timerApi.setTimeout(() => {
+				pending.delete(file);
+				handler(file);
+			}, delayMs);
+			pending.set(file, timer);
+			return true;
+		},
+		clear() {
+			for (const timer of pending.values()) timerApi.clearTimeout(timer);
+			pending.clear();
+		},
+	};
+}

package/src/worktree/worktree-manager.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadConfig } from "../config/config.ts";
@@ -9,6 +9,15 @@ export interface PreparedTaskWorkspace {
 	worktreePath?: string;
 	branch?: string;
 	reused?: boolean;
+	nodeModulesLinked?: boolean;
+	syntheticPaths?: string[];
+}
+
+export interface WorktreeDiffStat {
+	filesChanged: number;
+	insertions: number;
+	deletions: number;
+	diffStat: string;
 }
 
 function git(cwd: string, args: string[]): string {
@@ -30,6 +39,47 @@ export function assertCleanLeader(repoRoot: string): void {
 	}
 }
 
+function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
+	const source = path.join(repoRoot, "node_modules");
+	const target = path.join(worktreePath, "node_modules");
+	if (!fs.existsSync(source) || fs.existsSync(target)) return false;
+	try {
+		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
+	const resolved = path.resolve(worktreePath, rawPath);
+	const relative = path.relative(worktreePath, resolved);
+	if (!relative || relative === "." || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`synthetic path escapes worktree: ${rawPath}`);
+	return path.normalize(relative);
+}
+
+function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot: string, worktreePath: string, branch: string): string[] {
+	const cfg = loadConfig(manifest.cwd).config.worktree;
+	if (!cfg?.setupHook) return [];
+	const hookPath = path.isAbsolute(cfg.setupHook) ? cfg.setupHook : path.resolve(repoRoot, cfg.setupHook);
+	if (!fs.existsSync(hookPath) || fs.statSync(hookPath).isDirectory()) throw new Error(`worktree setup hook not found or not a file: ${hookPath}`);
+	const nodeHook = hookPath.endsWith(".js") || hookPath.endsWith(".cjs") || hookPath.endsWith(".mjs");
+	const result = spawnSync(nodeHook ? process.execPath : hookPath, nodeHook ? [hookPath] : [], {
+		cwd: worktreePath,
+		encoding: "utf-8",
+		input: JSON.stringify({ version: 1, repoRoot, worktreePath, agentCwd: worktreePath, branch, runId: manifest.runId, taskId: task.id, agent: task.agent }),
+		timeout: cfg.setupHookTimeoutMs ?? 30_000,
+		shell: false,
+	});
+	if (result.error) throw new Error(`worktree setup hook failed: ${result.error.message}`);
+	if (result.status !== 0) throw new Error(`worktree setup hook failed with exit code ${result.status}: ${result.stderr || result.stdout || "no output"}`);
+	const trimmed = result.stdout.trim();
+	if (!trimmed) return [];
+	const parsed = JSON.parse(trimmed) as { syntheticPaths?: unknown };
+	if (!Array.isArray(parsed.syntheticPaths)) return [];
+	return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
+}
+
 export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskState): PreparedTaskWorkspace {
 	if (manifest.workspaceMode !== "worktree") return { cwd: task.cwd };
 	const repoRoot = findGitRoot(manifest.cwd);
@@ -47,7 +97,28 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		return { cwd: worktreePath, worktreePath, branch, reused: true };
 	}
 	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-	return { cwd: worktreePath, worktreePath, branch, reused: false };
+	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
+	const nodeModulesLinked = loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, reused: false, nodeModulesLinked, syntheticPaths };
+}
+
+export function captureWorktreeDiffStat(worktreePath: string): WorktreeDiffStat {
+	try {
+		const diffStat = git(worktreePath, ["diff", "--stat"]);
+		const numstat = git(worktreePath, ["diff", "--numstat"]);
+		let filesChanged = 0;
+		let insertions = 0;
+		let deletions = 0;
+		for (const line of numstat.split(/\r?\n/).filter(Boolean)) {
+			const [add, del] = line.split(/\s+/);
+			filesChanged += 1;
+			insertions += Number(add) || 0;
+			deletions += Number(del) || 0;
+		}
+		return { filesChanged, insertions, deletions, diffStat };
+	} catch {
+		return { filesChanged: 0, insertions: 0, deletions: 0, diffStat: "" };
+	}
 }
 
 export function captureWorktreeDiff(worktreePath: string): string {