pi-crew 0.9.15 → 0.9.17

package/src/state/run-cache.ts

@@ -1,26 +1,26 @@
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as crypto from "node:crypto";
 import { projectCrewRoot } from "../utils/paths.ts";
-import type { TeamTaskState } from "./types.ts";
 import { atomicWriteFile } from "./atomic-write.ts";
 import { withFileLockSync } from "./locks.ts";
+import type { TeamTaskState } from "./types.ts";
 
 const DEFAULT_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 
 export interface CacheEntry {
-  key: string;
-  runId: string;
-  status: string;
-  tasks: TeamTaskState[];
-  cachedAt: number;
-  expiresAt: number;
-  goal: string;
-  team: string;
+	key: string;
+	runId: string;
+	status: string;
+	tasks: TeamTaskState[];
+	cachedAt: number;
+	expiresAt: number;
+	goal: string;
+	team: string;
 }
 
 interface CacheIndex {
-  [cacheKey: string]: string;
+	[cacheKey: string]: string;
 }
 
 /**
@@ -28,21 +28,15 @@ interface CacheIndex {
  * Uses SHA-256 hash of normalized goal + team + workflow.
  */
 export function computeRunCacheKey(goal: string, team: string, workflow: string, _cwd: string): string {
-  const normalized = goal.trim().toLowerCase().replace(/\s+/g, " ");
-  return crypto.createHash("sha256")
-    .update(normalized)
-    .update(team)
-    .update(workflow)
-    .update(_cwd)
-    .digest("hex")
-    .slice(0, 16);
+	const normalized = goal.trim().toLowerCase().replace(/\s+/g, " ");
+	return crypto.createHash("sha256").update(normalized).update(team).update(workflow).update(_cwd).digest("hex").slice(0, 16);
 }
 
 /**
  * Get the cache directory path.
  */
 function cacheDir(cwd: string): string {
-  return path.join(projectCrewRoot(cwd), "cache");
+	return path.join(projectCrewRoot(cwd), "cache");
 }
 
 /**
@@ -50,137 +44,150 @@ function cacheDir(cwd: string): string {
  * Returns null if cache miss or expired.
  */
 export function getCachedRun(cwd: string, cacheKey: string): CacheEntry | null {
-  const dir = cacheDir(cwd);
-  const indexPath = path.join(dir, "index.json");
-
-  if (!fs.existsSync(indexPath)) return null;
-
-  try {
-    const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
-    const entryPath = index[cacheKey];
-
-    if (!entryPath || !fs.existsSync(entryPath)) return null;
-
-    const entry = JSON.parse(fs.readFileSync(entryPath, "utf-8")) as CacheEntry;
-
-    if (Date.now() > entry.expiresAt) {
-      // Remove expired entry — use lock + atomic write to prevent index corruption
-      withFileLockSync(indexPath, () => {
-        try {
-          fs.unlinkSync(entryPath);
-        } catch { /* ignore */ }
-        const updatedIndex = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
-        delete updatedIndex[cacheKey];
-        atomicWriteFile(indexPath, JSON.stringify(updatedIndex));
-      });
-      return null;
-    }
-
-    return entry;
-  } catch {
-    return null;
-  }
+	const dir = cacheDir(cwd);
+	const indexPath = path.join(dir, "index.json");
+
+	if (!fs.existsSync(indexPath)) return null;
+
+	try {
+		const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
+		const entryPath = index[cacheKey];
+
+		if (!entryPath || !fs.existsSync(entryPath)) return null;
+
+		const entry = JSON.parse(fs.readFileSync(entryPath, "utf-8")) as CacheEntry;
+
+		if (Date.now() > entry.expiresAt) {
+			// Remove expired entry — use lock + atomic write to prevent index corruption
+			withFileLockSync(indexPath, () => {
+				try {
+					fs.unlinkSync(entryPath);
+				} catch {
+					/* ignore */
+				}
+				const updatedIndex = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
+				delete updatedIndex[cacheKey];
+				atomicWriteFile(indexPath, JSON.stringify(updatedIndex));
+			});
+			return null;
+		}
+
+		return entry;
+	} catch {
+		return null;
+	}
 }
 
 /**
  * Save run result to cache.
  */
 export function saveRunToCache(
-  cwd: string,
-  cacheKey: string,
-  runId: string,
-  status: string,
-  tasks: TeamTaskState[],
-  goal: string,
-  team: string,
-  ttlMs: number = DEFAULT_CACHE_TTL_MS,
+	cwd: string,
+	cacheKey: string,
+	runId: string,
+	status: string,
+	tasks: TeamTaskState[],
+	goal: string,
+	team: string,
+	ttlMs: number = DEFAULT_CACHE_TTL_MS,
 ): void {
-  const dir = cacheDir(cwd);
-
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  const entry: CacheEntry = {
-    key: cacheKey,
-    runId,
-    status,
-    tasks,
-    cachedAt: Date.now(),
-    expiresAt: Date.now() + ttlMs,
-    goal,
-    team,
-  };
-
-  const entryPath = path.join(dir, `${cacheKey}.json`);
-  fs.writeFileSync(entryPath, JSON.stringify(entry), "utf-8");
-
-  // Update index with atomic write: write to temp file then rename
-  const indexPath = path.join(dir, "index.json");
-  const index: CacheIndex = fs.existsSync(indexPath)
-    ? JSON.parse(fs.readFileSync(indexPath, "utf-8"))
-    : {};
-
-  index[cacheKey] = entryPath;
-  
-  // Atomic write: write to temp file first, then rename
-  const tempPath = path.join(dir, "index.json.tmp");
-  fs.writeFileSync(tempPath, JSON.stringify(index), "utf-8");
-  fs.renameSync(tempPath, indexPath);
+	const dir = cacheDir(cwd);
+
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+
+	const entry: CacheEntry = {
+		key: cacheKey,
+		runId,
+		status,
+		tasks,
+		cachedAt: Date.now(),
+		expiresAt: Date.now() + ttlMs,
+		goal,
+		team,
+	};
+
+	const entryPath = path.join(dir, `${cacheKey}.json`);
+	fs.writeFileSync(entryPath, JSON.stringify(entry), "utf-8");
+
+	// Update index with atomic write: write to temp file then rename
+	const indexPath = path.join(dir, "index.json");
+	const index: CacheIndex = fs.existsSync(indexPath) ? JSON.parse(fs.readFileSync(indexPath, "utf-8")) : {};
+
+	index[cacheKey] = entryPath;
+
+	// Atomic write: write to temp file first, then rename
+	const tempPath = path.join(dir, "index.json.tmp");
+	fs.writeFileSync(tempPath, JSON.stringify(index), "utf-8");
+	fs.renameSync(tempPath, indexPath);
 }
 
 /**
  * Clear all cache entries.
  */
 export function clearCache(cwd: string): void {
-  const dir = cacheDir(cwd);
-  if (!fs.existsSync(dir)) return;
-
-  const indexPath = path.join(dir, "index.json");
-  if (fs.existsSync(indexPath)) {
-    try {
-      const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
-      for (const entryPath of Object.values(index)) {
-        try {
-          fs.unlinkSync(entryPath);
-        } catch { /* ignore */ }
-      }
-      fs.unlinkSync(indexPath);
-    } catch { /* ignore */ }
-  }
-
-  // Remove entry files not in index
-  const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
-  for (const entry of entries) {
-    try {
-      fs.unlinkSync(path.join(dir, entry));
-    } catch { /* ignore */ }
-  }
+	const dir = cacheDir(cwd);
+	if (!fs.existsSync(dir)) return;
+
+	const indexPath = path.join(dir, "index.json");
+	if (fs.existsSync(indexPath)) {
+		try {
+			const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
+			for (const entryPath of Object.values(index)) {
+				try {
+					fs.unlinkSync(entryPath);
+				} catch {
+					/* ignore */
+				}
+			}
+			fs.unlinkSync(indexPath);
+		} catch {
+			/* ignore */
+		}
+	}
+
+	// Remove entry files not in index
+	const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+	for (const entry of entries) {
+		try {
+			fs.unlinkSync(path.join(dir, entry));
+		} catch {
+			/* ignore */
+		}
+	}
 }
 
 /**
  * Get cache stats.
  */
-export function getCacheStats(cwd: string): { entries: number; sizeBytes: number } {
-  const dir = cacheDir(cwd);
-  if (!fs.existsSync(dir)) return { entries: 0, sizeBytes: 0 };
-
-  let sizeBytes = 0;
-  let entries = 0;
-  const indexPath = path.join(dir, "index.json");
-
-  if (fs.existsSync(indexPath)) {
-    try {
-      const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
-      entries = Object.keys(index).length;
-      for (const entryPath of Object.values(index)) {
-        try {
-          const stat = fs.statSync(entryPath);
-          sizeBytes += stat.size;
-        } catch { /* ignore */ }
-      }
-    } catch { /* ignore */ }
-  }
-
-  return { entries, sizeBytes };
+export function getCacheStats(cwd: string): {
+	entries: number;
+	sizeBytes: number;
+} {
+	const dir = cacheDir(cwd);
+	if (!fs.existsSync(dir)) return { entries: 0, sizeBytes: 0 };
+
+	let sizeBytes = 0;
+	let entries = 0;
+	const indexPath = path.join(dir, "index.json");
+
+	if (fs.existsSync(indexPath)) {
+		try {
+			const index = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
+			entries = Object.keys(index).length;
+			for (const entryPath of Object.values(index)) {
+				try {
+					const stat = fs.statSync(entryPath);
+					sizeBytes += stat.size;
+				} catch {
+					/* ignore */
+				}
+			}
+		} catch {
+			/* ignore */
+		}
+	}
+
+	return { entries, sizeBytes };
 }

package/src/state/run-graph.ts

@@ -40,10 +40,7 @@ export interface RunGraph {
  * Build a unified run graph from manifest + tasks.
  * Consolidates state into a single graph JSON for dashboard/API use.
  */
-export function buildRunGraph(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-): RunGraph {
+export function buildRunGraph(manifest: TeamRunManifest, tasks: TeamTaskState[]): RunGraph {
 	const nodes: RunGraphNode[] = [];
 	const edges: RunGraphEdge[] = [];
 	const nodeIds = new Set<string>();
@@ -106,12 +103,10 @@ export function buildRunGraph(
 		layerMap.get(layerName)!.push(`task:${task.id}`);
 	}
 
-	const layers: RunGraphLayer[] = [...layerMap.entries()].map(
-		([name, nodeIdList]) => ({
-			name,
-			nodeIds: nodeIdList,
-		}),
-	);
+	const layers: RunGraphLayer[] = [...layerMap.entries()].map(([name, nodeIdList]) => ({
+		name,
+		nodeIds: nodeIdList,
+	}));
 
 	return {
 		version: "1.0.0",
@@ -181,11 +176,7 @@ export function listRunGraphs(cwd: string): string[] {
 /**
  * Build and save run graph from manifest + tasks.
  */
-export function buildAndSaveRunGraph(
-	manifest: TeamRunManifest,
-	tasks: TeamTaskState[],
-	cwd: string,
-): string {
+export function buildAndSaveRunGraph(manifest: TeamRunManifest, tasks: TeamTaskState[], cwd: string): string {
 	const graph = buildRunGraph(manifest, tasks);
 	return saveRunGraph(graph, cwd);
 }

package/src/state/run-metrics.ts

@@ -37,10 +37,7 @@ function metricsFilePath(cwd: string, runId: string): string {
  * Collect metrics for a run by reading its manifest, tasks, and event log.
  * Returns undefined if the run cannot be loaded.
  */
-export function collectRunMetrics(
-	cwd: string,
-	runId: string,
-): RunMetrics | undefined {
+export function collectRunMetrics(cwd: string, runId: string): RunMetrics | undefined {
 	assertSafePathId("runId", runId);
 	const result = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 	if (!result) return undefined;
@@ -69,17 +66,11 @@ export function collectRunMetrics(
 	// Duration: from run createdAt to updatedAt (manifest timestamps), or 0 if unavailable.
 	const createdAt = new Date(manifest.createdAt).getTime();
 	const updatedAt = new Date(manifest.updatedAt).getTime();
-	const durationMs =
-		isNaN(createdAt) || isNaN(updatedAt)
-			? 0
-			: Math.max(0, updatedAt - createdAt);
+	const durationMs = isNaN(createdAt) || isNaN(updatedAt) ? 0 : Math.max(0, updatedAt - createdAt);
 
 	// Consistency score: proportion of tasks that completed successfully among all non-skipped tasks.
 	const nonSkippedTasks = tasks.filter((t) => t.status !== "skipped");
-	const consistencyScore =
-		nonSkippedTasks.length > 0
-			? completedCount / nonSkippedTasks.length
-			: 1.0;
+	const consistencyScore = nonSkippedTasks.length > 0 ? completedCount / nonSkippedTasks.length : 1.0;
 
 	return {
 		runId,
@@ -108,10 +99,7 @@ export function saveRunMetrics(cwd: string, metrics: RunMetrics): void {
  * Load a previously saved metrics snapshot.
  * Returns undefined if the file does not exist or cannot be parsed.
  */
-export function loadRunMetrics(
-	cwd: string,
-	runId: string,
-): RunMetrics | undefined {
+export function loadRunMetrics(cwd: string, runId: string): RunMetrics | undefined {
 	return readJsonFile<RunMetrics>(metricsFilePath(cwd, runId));
 }
 
@@ -140,8 +128,7 @@ export function getRunMetricsSummary(cwd: string, limit = 25): RunMetrics[] {
 
 	// Sort newest first (by timestamp, then runId as tiebreaker).
 	metrics.sort((a, b) => {
-		const diff =
-			new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
+		const diff = new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
 		if (diff !== 0) return diff;
 		return b.runId.localeCompare(a.runId);
 	});

package/src/state/schedule.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { logInternalError } from "../utils/internal-error.ts";
 
-import type { ScheduleStoreData, ScheduledTask } from "./types.ts";
+import type { ScheduledTask, ScheduleStoreData } from "./types.ts";
 
 export type DetectedSchedule =
 	| { type: "cron"; normalized: string }
@@ -34,7 +34,10 @@ export function parseInterval(s: string): number | null {
 }
 
 /** 6-field cron validation ("second minute hour dom month dow"). */
-export function validateCronExpression(expr: string): { valid: boolean; error?: string } {
+export function validateCronExpression(expr: string): {
+	valid: boolean;
+	error?: string;
+} {
 	const fields = expr.trim().split(/\s+/);
 	if (fields.length !== 6) {
 		return {
@@ -43,8 +46,11 @@ export function validateCronExpression(expr: string): { valid: boolean; error?:
 		};
 	}
 	// Basic format check: all fields must be non-empty
-	if (!fields.every(f => f.length > 0)) {
-		return { valid: false, error: "Cron expression contains empty fields." };
+	if (!fields.every((f) => f.length > 0)) {
+		return {
+			valid: false,
+			error: "Cron expression contains empty fields.",
+		};
 	}
 	// Accept any cron pattern — fail silently for malformed expressions
 	// (the croner library will reject at execution time)
@@ -122,11 +128,11 @@ export class ScheduleStore {
 	}
 
 	hasName(name: string): boolean {
-		return this.data.jobs.some(j => j.name === name);
+		return this.data.jobs.some((j) => j.name === name);
 	}
 
 	get(id: string): ScheduledTask | undefined {
-		return this.data.jobs.find(j => j.id === id);
+		return this.data.jobs.find((j) => j.id === id);
 	}
 
 	add(job: ScheduledTask): void {
@@ -135,7 +141,7 @@ export class ScheduleStore {
 	}
 
 	update(id: string, patch: Partial<ScheduledTask>): ScheduledTask | undefined {
-		const idx = this.data.jobs.findIndex(j => j.id === id);
+		const idx = this.data.jobs.findIndex((j) => j.id === id);
 		if (idx === -1) return undefined;
 		this.data.jobs[idx] = { ...this.data.jobs[idx], ...patch };
 		this.save();
@@ -144,11 +150,11 @@ export class ScheduleStore {
 
 	remove(id: string): boolean {
 		const before = this.data.jobs.length;
-		this.data.jobs = this.data.jobs.filter(j => j.id !== id);
+		this.data.jobs = this.data.jobs.filter((j) => j.id !== id);
 		if (this.data.jobs.length !== before) {
 			this.save();
 			return true;
 		}
 		return false;
 	}
-}
+}