pi-crew 0.1.46 → 0.1.49

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;
+		}
+	}
+}

package/src/utils/task-name-generator.ts

@@ -0,0 +1,337 @@
+/**
+ * Human-readable task name generator.
+ * Format: AdjectiveNoun (e.g., "SwiftFalcon", "CalmPanda")
+ *
+ * Curated lists of ~120 adjectives and ~120 animals/nouns.
+ * 120 × 120 = 14,400 combinations.
+ */
+
+const ADJECTIVES = [
+	"active",
+	"agile",
+	"alert",
+	"ancient",
+	"bold",
+	"brave",
+	"bright",
+	"brilliant",
+	"calm",
+	"capable",
+	"careful",
+	"charming",
+	"cheerful",
+	"clever",
+	"cloudy",
+	"cold",
+	"cool",
+	"curious",
+	"cute",
+	"daring",
+	"dark",
+	"deep",
+	"direct",
+	"eager",
+	"early",
+	"electric",
+	"elegant",
+	"energetic",
+	"enormous",
+	"epic",
+	"exact",
+	"exotic",
+	"fair",
+	"fancy",
+	"fast",
+	"fierce",
+	"firm",
+	"flat",
+	"flexible",
+	"fresh",
+	"friendly",
+	"full",
+	"fun",
+	"funny",
+	"gentle",
+	"global",
+	"golden",
+	"good",
+	"grand",
+	"grateful",
+	"great",
+	"green",
+	"happy",
+	"hard",
+	"heavy",
+	"hidden",
+	"honest",
+	"hot",
+	"huge",
+	"icy",
+	"ideal",
+	"keen",
+	"kind",
+	"large",
+	"lazy",
+	"light",
+	"lively",
+	"local",
+	"loud",
+	"lucky",
+	"magic",
+	"mighty",
+	"mild",
+	"modern",
+	"neat",
+	"new",
+	"nice",
+	"noble",
+	"odd",
+	"old",
+	"open",
+	"patient",
+	"perfect",
+	"plain",
+	"polite",
+	"popular",
+	"powerful",
+	"precise",
+	"pretty",
+	"proud",
+	"pure",
+	"quick",
+	"quiet",
+	"rapid",
+	"rare",
+	"real",
+	"rich",
+	"robust",
+	"round",
+	"royal",
+	"safe",
+	"sharp",
+	"short",
+	"shy",
+	"silent",
+	"simple",
+	"slim",
+	"smart",
+	"smooth",
+	"soft",
+	"solar",
+	"solid",
+	"steady",
+	"strange",
+	"strong",
+	"sunny",
+	"swift",
+	"tall",
+	"tame",
+	"tiny",
+	"tough",
+	"true",
+	"unique",
+	"vast",
+	"warm",
+	"wild",
+	"wise",
+	"zany",
+	"zen",
+] as const;
+
+const NOUNS = [
+	"albatross",
+	"ant",
+	"antelope",
+	"ape",
+	"archer",
+	"badger",
+	"bass",
+	"bat",
+	"bear",
+	"beaver",
+	"bee",
+	"beetle",
+	"bird",
+	"bison",
+	"boar",
+	"bobcat",
+	"bull",
+	"buzzard",
+	"camel",
+	"canary",
+	"carp",
+	"cat",
+	"cedar",
+	"cheetah",
+	"chicken",
+	"cobra",
+	"cod",
+	"condor",
+	"coral",
+	"cougar",
+	"crab",
+	"crane",
+	"cricket",
+	"crow",
+	"deer",
+	"dolphin",
+	"dove",
+	"dragon",
+	"duck",
+	"eagle",
+	"eel",
+	"elk",
+	"falcon",
+	"ferret",
+	"finch",
+	"flamingo",
+	"fox",
+	"frog",
+	"gazelle",
+	"gecko",
+	"ghost",
+	"gibbon",
+	"goat",
+	"goldfish",
+	"goose",
+	"gorilla",
+	"halibut",
+	"hamster",
+	"hare",
+	"hawk",
+	"heron",
+	"horse",
+	"hummingbird",
+	"hyena",
+	"ibis",
+	"iguana",
+	"impala",
+	"jackal",
+	"jaguar",
+	"jay",
+	"jellyfish",
+	"kangaroo",
+	"kite",
+	"kiwi",
+	"koala",
+	"krill",
+	"lark",
+	"lemur",
+	"leopard",
+	"lion",
+	"lizard",
+	"llama",
+	"lobster",
+	"lynx",
+	"macaw",
+	"magnet",
+	"mammoth",
+	"marmot",
+	"mink",
+	"mole",
+	"monkey",
+	"moose",
+	"moth",
+	"mouse",
+	"newt",
+	"ocelot",
+	"octopus",
+	"orca",
+	"ostrich",
+	"otter",
+	"owl",
+	"ox",
+	"panda",
+	"panther",
+	"parrot",
+	"peacock",
+	"pelican",
+	"penguin",
+	"pike",
+	"pony",
+	"python",
+	"quail",
+	"rabbit",
+	"raccoon",
+	"ram",
+	"raven",
+	"robin",
+	"rook",
+	"sable",
+	"salmon",
+	"scorpion",
+	"seal",
+	"shark",
+	"sheep",
+	"snail",
+	"sparrow",
+	"spider",
+	"squid",
+	"squirrel",
+	"stork",
+	"swan",
+	"tiger",
+	"toad",
+	"tortoise",
+	"toucan",
+	"trout",
+	"tuna",
+	"turkey",
+	"turtle",
+	"viper",
+	"vulture",
+	"walrus",
+	"wasp",
+	"whale",
+	"wolf",
+	"wombat",
+	"woodpecker",
+	"wren",
+	"yak",
+	"zebra",
+] as const;
+
+function capitalize(s: string): string {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+let usedNames = new Set<string>();
+
+/**
+ * Generate a unique two-word identifier (e.g., "SwiftFalcon").
+ * Resets and starts over if all combinations exhausted.
+ */
+export function generateTaskName(): string {
+	// Try random combinations first (50 attempts)
+	for (let attempt = 0; attempt < 50; attempt++) {
+		const adj = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]!;
+		const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)]!;
+		const name = `${capitalize(adj)}${capitalize(noun)}`;
+		if (!usedNames.has(name)) {
+			usedNames.add(name);
+			return name;
+		}
+	}
+
+	// Exhaustive search if random fails
+	for (const adj of ADJECTIVES) {
+		for (const noun of NOUNS) {
+			const name = `${capitalize(adj)}${capitalize(noun)}`;
+			if (!usedNames.has(name)) {
+				usedNames.add(name);
+				return name;
+			}
+		}
+	}
+
+	// All combinations exhausted — reset and start over
+	usedNames.clear();
+	return generateTaskName();
+}
+
+/**
+ * Reset name generator state (for testing).
+ */
+export function resetTaskNames(): void {
+	usedNames = new Set<string>();
+}

package/src/utils/visual.ts

@@ -3,12 +3,43 @@ export const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
 const WIDTH_CACHE_LIMIT = 256;
 const widthCache = new Map<string, number>();
 
+/** Code-point ranges that render as width 2 in most terminals (CJK + emoji). */
+const WIDE_RANGES: Array<[number, number]> = [
+	// CJK Unified Ideographs
+	[0x4E00, 0x9FFF],
+	// CJK Extension A
+	[0x3400, 0x4DBF],
+	// CJK Compatibility Ideographs
+	[0xF900, 0xFAFF],
+	// Hangul Syllables
+	[0xAC00, 0xD7AF],
+	// CJK Symbols and Punctuation, Hiragana, Katakana
+	[0x3000, 0x33FF],
+	// Fullwidth forms
+	[0xFF01, 0xFF60],
+	// Emoji blocks
+	[0x2600, 0x27BF],  // Miscellaneous Symbols + Dingbats (includes ✅)
+	[0x1F300, 0x1F9FF], // Misc Symbols, Emoticons, Transport, Map, Supplement
+	[0x1FA00, 0x1FAFF], // Symbols Extended-A
+	[0x1F000, 0x1F02F], // Mahjong, Dominos
+	[0x2702, 0x27B0],   // Dingbats
+	[0xFE00, 0xFE0F],   // Variation Selectors (emoji presentation)
+	[0x200D, 0x200D],   // Zero Width Joiner (creates compound emoji)
+];
+
+function isWideCodePoint(code: number): boolean {
+	for (const [lo, hi] of WIDE_RANGES) {
+		if (code >= lo && code <= hi) return true;
+	}
+	return false;
+}
+
 export function visibleWidth(value: string): number {
 	// Skip caching for very long strings to avoid memory pressure.
 	if (value.length > 4096) {
 		let length = 0;
 		for (const char of value.replace(ANSI_PATTERN, "")) {
-			if (char !== "\n") length += 1;
+			if (char !== "\n") length += isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1;
 		}
 		return length;
 	}
@@ -16,7 +47,7 @@ export function visibleWidth(value: string): number {
 	if (cached !== undefined) return cached;
 	let length = 0;
 	for (const char of value.replace(ANSI_PATTERN, "")) {
-		if (char !== "\n") length += 1;
+		if (char !== "\n") length += isWideCodePoint(char.codePointAt(0) ?? 0) ? 2 : 1;
 	}
 	if (widthCache.size >= WIDTH_CACHE_LIMIT) {
 		const firstKey = widthCache.keys().next().value;

package/src/workflows/validate-workflow.ts

@@ -1,40 +1,40 @@
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { WorkflowConfig } from "./workflow-config.ts";
-
-export function validateWorkflowForTeam(workflow: WorkflowConfig, team: TeamConfig): string[] {
-	const errors: string[] = [];
-	const roles = new Set(team.roles.map((role) => role.name));
-	const stepIds = new Set<string>();
-
-	for (const step of workflow.steps) {
-		if (stepIds.has(step.id)) errors.push(`Duplicate workflow step id '${step.id}'.`);
-		stepIds.add(step.id);
-		if (!roles.has(step.role)) errors.push(`Step '${step.id}' references unknown team role '${step.role}'.`);
-	}
-
-	for (const step of workflow.steps) {
-		for (const dep of step.dependsOn ?? []) {
-			if (!stepIds.has(dep)) errors.push(`Step '${step.id}' depends on unknown step '${dep}'.`);
-		}
-	}
-
-	const visiting = new Set<string>();
-	const visited = new Set<string>();
-	const byId = new Map(workflow.steps.map((step) => [step.id, step]));
-
-	function visit(id: string, trail: string[]): void {
-		if (visited.has(id)) return;
-		if (visiting.has(id)) {
-			errors.push(`Workflow dependency cycle detected: ${[...trail, id].join(" -> ")}.`);
-			return;
-		}
-		visiting.add(id);
-		const step = byId.get(id);
-		for (const dep of step?.dependsOn ?? []) visit(dep, [...trail, id]);
-		visiting.delete(id);
-		visited.add(id);
-	}
-
-	for (const step of workflow.steps) visit(step.id, []);
-	return [...new Set(errors)];
-}
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { WorkflowConfig } from "./workflow-config.ts";
+
+export function validateWorkflowForTeam(workflow: WorkflowConfig, team: TeamConfig): string[] {
+	const errors: string[] = [];
+	const roles = new Set(team.roles.map((role) => role.name));
+	const stepIds = new Set<string>();
+
+	for (const step of workflow.steps) {
+		if (stepIds.has(step.id)) errors.push(`Duplicate workflow step id '${step.id}'.`);
+		stepIds.add(step.id);
+		if (!roles.has(step.role)) errors.push(`Step '${step.id}' references unknown team role '${step.role}'.`);
+	}
+
+	for (const step of workflow.steps) {
+		for (const dep of step.dependsOn ?? []) {
+			if (!stepIds.has(dep)) errors.push(`Step '${step.id}' depends on unknown step '${dep}'.`);
+		}
+	}
+
+	const visiting = new Set<string>();
+	const visited = new Set<string>();
+	const byId = new Map(workflow.steps.map((step) => [step.id, step]));
+
+	function visit(id: string, trail: string[]): void {
+		if (visited.has(id)) return;
+		if (visiting.has(id)) {
+			errors.push(`Workflow dependency cycle detected: ${[...trail, id].join(" -> ")}.`);
+			return;
+		}
+		visiting.add(id);
+		const step = byId.get(id);
+		for (const dep of step?.dependsOn ?? []) visit(dep, [...trail, id]);
+		visiting.delete(id);
+		visited.add(id);
+	}
+
+	for (const step of workflow.steps) visit(step.id, []);
+	return [...new Set(errors)];
+}

package/src/worktree/branch-freshness.ts

@@ -1,45 +1,45 @@
-import { execFileSync } from "node:child_process";
-
-export type BranchFreshnessStatus = "fresh" | "stale" | "diverged" | "unknown";
-export type StaleBranchPolicy = "warn" | "block" | "auto_rebase" | "auto_merge_forward";
-
-export interface BranchFreshness {
-	status: BranchFreshnessStatus;
-	branch?: string;
-	mainRef: string;
-	ahead: number;
-	behind: number;
-	missingFixes: string[];
-	message: string;
-	error?: string;
-}
-
-function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
-}
-
-function count(cwd: string, range: string): number {
-	const raw = git(cwd, ["rev-list", "--count", range]);
-	const parsed = Number.parseInt(raw, 10);
-	return Number.isFinite(parsed) ? parsed : 0;
-}
-
-export function checkBranchFreshness(cwd: string, mainRef = "main"): BranchFreshness {
-	try {
-		git(cwd, ["rev-parse", "--is-inside-work-tree"]);
-		const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
-		const behind = count(cwd, `${branch}..${mainRef}`);
-		const ahead = count(cwd, `${mainRef}..${branch}`);
-		const missingFixes = behind > 0 ? git(cwd, ["log", "--format=%s", `${branch}..${mainRef}`]).split("\n").map((line) => line.trim()).filter(Boolean) : [];
-		if (behind === 0) return { status: "fresh", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' is fresh against ${mainRef}.` };
-		if (ahead > 0) return { status: "diverged", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' diverged from ${mainRef}: ahead=${ahead}, behind=${behind}.` };
-		return { status: "stale", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' is ${behind} commit(s) behind ${mainRef}.` };
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return { status: "unknown", mainRef, ahead: 0, behind: 0, missingFixes: [], message: "Branch freshness could not be determined.", error: message };
-	}
-}
-
-export function shouldBlockForBranchFreshness(freshness: BranchFreshness, policy: StaleBranchPolicy = "warn"): boolean {
-	return policy === "block" && (freshness.status === "stale" || freshness.status === "diverged");
-}
+import { execFileSync } from "node:child_process";
+
+export type BranchFreshnessStatus = "fresh" | "stale" | "diverged" | "unknown";
+export type StaleBranchPolicy = "warn" | "block" | "auto_rebase" | "auto_merge_forward";
+
+export interface BranchFreshness {
+	status: BranchFreshnessStatus;
+	branch?: string;
+	mainRef: string;
+	ahead: number;
+	behind: number;
+	missingFixes: string[];
+	message: string;
+	error?: string;
+}
+
+function git(cwd: string, args: string[]): string {
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function count(cwd: string, range: string): number {
+	const raw = git(cwd, ["rev-list", "--count", range]);
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+
+export function checkBranchFreshness(cwd: string, mainRef = "main"): BranchFreshness {
+	try {
+		git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+		const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+		const behind = count(cwd, `${branch}..${mainRef}`);
+		const ahead = count(cwd, `${mainRef}..${branch}`);
+		const missingFixes = behind > 0 ? git(cwd, ["log", "--format=%s", `${branch}..${mainRef}`]).split("\n").map((line) => line.trim()).filter(Boolean) : [];
+		if (behind === 0) return { status: "fresh", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' is fresh against ${mainRef}.` };
+		if (ahead > 0) return { status: "diverged", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' diverged from ${mainRef}: ahead=${ahead}, behind=${behind}.` };
+		return { status: "stale", branch, mainRef, ahead, behind, missingFixes, message: `Branch '${branch}' is ${behind} commit(s) behind ${mainRef}.` };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { status: "unknown", mainRef, ahead: 0, behind: 0, missingFixes: [], message: "Branch freshness could not be determined.", error: message };
+	}
+}
+
+export function shouldBlockForBranchFreshness(freshness: BranchFreshness, policy: StaleBranchPolicy = "warn"): boolean {
+	return policy === "block" && (freshness.status === "stale" || freshness.status === "diverged");
+}