pi-crew 0.9.68 → 0.10.2

package/src/utils/project-detector.ts

@@ -1,160 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-/**
- * Information about a detected project.
- */
-export interface ProjectInfo {
-	projectId: string;
-	projectName: string;
-}
-
-/**
- * Create a SHA256 hash of a string, returning the first 16 characters.
- */
-function hashPath(input: string): string {
-	return createHash("sha256").update(input).digest("hex").slice(0, 16);
-}
-
-/**
- * Extract the repository name from a git remote URL.
- * Handles formats like:
- *   - https://github.com/user/repo.git
- *   - https://github.com/user/repo
- *   - git@github.com:user/repo.git
- *   - ssh://git@github.com/user/repo.git
- */
-function extractRepoName(remoteUrl: string): string | null {
-	// Remove .git suffix
-	const withoutGit = remoteUrl.replace(/\.git$/, "");
-
-	// Handle SSH format: git@github.com:user/repo
-	const sshMatch = withoutGit.match(/^git@[^:]+:(.+)$/);
-	if (sshMatch) {
-		const parts = sshMatch[1].split("/");
-		return parts[parts.length - 1] ?? null;
-	}
-
-	// Handle HTTPS/HTTP/SSH URL format
-	try {
-		const url = new URL(withoutGit);
-		const pathParts = url.pathname.split("/").filter(Boolean);
-		return pathParts[pathParts.length - 1] ?? null;
-	} catch {
-		// Not a valid URL, try to extract from path-like string
-		const parts = withoutGit.split("/").filter(Boolean);
-		return parts[parts.length - 1] ?? null;
-	}
-}
-
-/**
- * Try to get the repository name from git remote origin.
- */
-function tryGitRemote(cwd: string): string | null {
-	try {
-		const remoteUrl = execFileSync("git", ["remote", "get-url", "origin"], {
-			cwd,
-			encoding: "utf-8",
-			stdio: ["pipe", "pipe", "ignore"],
-		}).trim();
-
-		if (!remoteUrl) return null;
-
-		const repoName = extractRepoName(remoteUrl);
-		if (!repoName) return null;
-
-		// Verify it's a valid directory name (no path traversal attempts)
-		if (repoName.includes("..") || repoName.includes("/")) return null;
-
-		return repoName;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Try to get the directory name from git toplevel.
- */
-function tryGitToplevel(cwd: string): string | null {
-	try {
-		const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-			cwd,
-			encoding: "utf-8",
-			stdio: ["pipe", "pipe", "ignore"],
-		}).trim();
-
-		if (!toplevel || !fs.existsSync(toplevel)) return null;
-
-		const dirName = path.basename(toplevel);
-		// Verify it's a valid directory name
-		if (!dirName || dirName.includes("..") || dirName.includes("/")) return null;
-
-		return dirName;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Detect project information from a working directory.
- * Uses a hierarchy of detection methods, falling through on failure.
- *
- * Detection hierarchy (first successful wins):
- * 1. CLAUDE_PROJECT_DIR env var → hash the path, use dir name as name
- * 2. git remote get-url origin → extract repo name from URL
- * 3. git rev-parse --show-toplevel → use dir name
- * 4. Fallback: hash(cwd) for projectId, path.basename(cwd) for name
- */
-export function detectProjectId(cwd: string): ProjectInfo {
-	// Normalize the cwd path
-	const normalizedCwd = path.resolve(cwd);
-
-	// Method 1: Check CLAUDE_PROJECT_DIR env var
-	const claudeProjectDir = process.env.CLAUDE_PROJECT_DIR;
-	if (claudeProjectDir?.trim()) {
-		const resolvedPath = path.resolve(claudeProjectDir.trim());
-		const projectName = path.basename(resolvedPath);
-		const projectId = hashPath(resolvedPath);
-		return { projectId, projectName };
-	}
-
-	// Method 2: Try git remote origin
-	const repoName = tryGitRemote(normalizedCwd);
-	if (repoName) {
-		const projectId = hashPath(normalizedCwd);
-		return { projectId, projectName: repoName };
-	}
-
-	// Method 3: Try git toplevel
-	const toplevelName = tryGitToplevel(normalizedCwd);
-	if (toplevelName) {
-		const projectId = hashPath(normalizedCwd);
-		return { projectId, projectName: toplevelName };
-	}
-
-	// Method 4: Fallback - hash the cwd and use basename
-	const projectId = hashPath(normalizedCwd);
-	const projectName = path.basename(normalizedCwd) || "unknown";
-	return { projectId, projectName };
-}
-
-/**
- * Get the storage directory for a specific project's instincts.
- * @param projectId - The project identifier (from detectProjectId)
- * @param crewRoot - The crew root directory (e.g., from projectCrewRoot)
- * @returns The path to the project's storage directory
- */
-export function getProjectStorageDir(projectId: string, crewRoot: string): string {
-	return path.join(crewRoot, "instincts", "projects", projectId);
-}
-
-/**
- * Get the global storage directory for instincts.
- * @param crewRoot - The crew root directory
- * @returns The path to the global storage directory
- */
-export function getGlobalStorageDir(crewRoot: string): string {
-	return path.join(crewRoot, "instincts", "global");
-}

package/src/utils/sse-parser.ts

@@ -1,131 +0,0 @@
-/** 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;
-
-/** L2: Maximum data size per line to prevent unbounded memory usage. */
-const MAX_DATA_SIZE = 100000; // 100KB per line
-
-/** 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 (line count)
-		if (currentRaw.length > MAX_EVENT_LINES) {
-			const evt = flush();
-			if (evt) yield evt;
-			continue;
-		}
-
-		// L2: Guard against unbounded memory growth (data size per line)
-		if (value.length > MAX_DATA_SIZE) {
-			// Truncate oversized data to prevent memory issues
-			value = value.slice(0, MAX_DATA_SIZE);
-		}
-
-		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 {
-			// intentional parse fallback
-		}
-	}
-}

package/src/workflows/cost-estimator.ts

@@ -1,34 +0,0 @@
-import type { WorkflowConfig } from "./workflow-config.ts";
-
-// Rough token estimates per role (input + output combined)
-const ROLE_TOKEN_ESTIMATES: Record<string, number> = {
-	explorer: 15000,
-	planner: 20000,
-	executor: 25000,
-	reviewer: 12000,
-	"security-reviewer": 12000,
-	"test-engineer": 15000,
-	analyst: 18000,
-	writer: 15000,
-	verifier: 10000,
-	critic: 12000,
-};
-
-// Rough cost per 1K tokens (USD) — using a mid-range model price
-const COST_PER_1K_TOKENS = 0.003;
-
-export interface CostEstimate {
-	totalTokens: number;
-	estimatedCostUSD: number;
-	perStep: Array<{ stepId: string; role: string; tokens: number }>;
-}
-
-export function estimateWorkflowCost(workflow: WorkflowConfig): CostEstimate {
-	const perStep = workflow.steps.map((step) => {
-		const tokens = ROLE_TOKEN_ESTIMATES[step.role] ?? 15000; // default 15K
-		return { stepId: step.id, role: step.role, tokens };
-	});
-	const totalTokens = perStep.reduce((sum, s) => sum + s.tokens, 0);
-	const estimatedCostUSD = (totalTokens / 1000) * COST_PER_1K_TOKENS;
-	return { totalTokens, estimatedCostUSD, perStep };
-}

package/src/workflows/intermediate-store.ts

@@ -1,166 +0,0 @@
-/**
- * Phase-gated intermediate store — persist workflow step outputs to disk.
- *
- * Pattern origin: Understand-Anything 7-phase pipeline where each phase
- * writes structured JSON to intermediate/ directory. Phase N reads Phase N-1
- * output from disk (not context). Enables:
- * - Context isolation between steps
- * - Incremental re-runs (skip completed phases)
- * - Debugging (inspect intermediate outputs)
- */
-
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { logInternalError } from "../utils/internal-error.ts";
-import { isSafePathId } from "../utils/safe-paths.ts";
-
-// ── Types ────────────────────────────────────────────────────────────────
-
-export interface IntermediateOutput {
-	phase: string;
-	stepId: string;
-	timestamp: string;
-	data: unknown;
-}
-
-export interface IntermediateStoreConfig {
-	/** Root directory for intermediates (e.g., ".crew/intermediate/") */
-	intermediateDir: string;
-	/** File patterns to preserve across runs (e.g., ["scan-result.json"]) */
-	preservePatterns: string[];
-}
-
-// ── Store Operations ─────────────────────────────────────────────────────
-
-const DEFAULT_CONFIG: IntermediateStoreConfig = {
-	intermediateDir: ".crew/intermediate",
-	preservePatterns: [],
-};
-
-/**
- * Ensure the intermediate directory exists.
- */
-export function ensureIntermediateDir(config: Partial<IntermediateStoreConfig> = {}): string {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	mkdirSync(dir, { recursive: true });
-	return dir;
-}
-
-/**
- * Write an intermediate output for a phase.
- *
- * @param config - Store configuration
- * @param phase - Phase name (e.g., "explore", "analyze")
- * @param stepId - Step ID for correlation
- * @param data - Phase output data
- * @returns Path to the written file
- */
-export function writeIntermediate(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string, data: unknown): string {
-	// Security: validate phase/stepId before building the filename to prevent
-	// path traversal via poisoned phase or stepId.
-	if (!isSafePathId(phase) || !isSafePathId(stepId)) {
-		throw new Error("Invalid phase or stepId for intermediate store");
-	}
-	const dir = ensureIntermediateDir(config);
-	const filename = `${phase}-${stepId}.json`;
-	const filePath = path.join(dir, filename);
-
-	const output: IntermediateOutput = {
-		phase,
-		stepId,
-		timestamp: new Date().toISOString(),
-		data,
-	};
-
-	writeFileSync(filePath, JSON.stringify(output, null, 2), "utf-8");
-	return filePath;
-}
-
-/**
- * Read an intermediate output for a phase.
- *
- * @param config - Store configuration
- * @param phase - Phase name
- * @param stepId - Step ID
- * @returns Parsed intermediate output, or undefined if not found
- */
-export function readIntermediate(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string): IntermediateOutput | undefined {
-	// M-2 fix (code-review 2026-06-23): validate phase/stepId before building the
-	// filename to prevent path traversal via a poisoned stepId.
-	if (!isSafePathId(phase) || !isSafePathId(stepId)) return undefined;
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	const filename = `${phase}-${stepId}.json`;
-	const filePath = path.join(dir, filename);
-
-	if (!existsSync(filePath)) return undefined;
-
-	try {
-		const content = readFileSync(filePath, "utf-8");
-		return JSON.parse(content) as IntermediateOutput;
-	} catch (error) {
-		logInternalError("intermediate-store.read", error, `filePath=${filePath}`);
-		return undefined;
-	}
-}
-
-/**
- * Read the most recent intermediate output for any phase.
- *
- * Useful when you don't know the exact stepId but want the latest
- * output from a phase (e.g., for incremental re-runs).
- */
-export function readLatestIntermediate(config: Partial<IntermediateStoreConfig>, phase: string): IntermediateOutput | undefined {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	if (!existsSync(dir)) return undefined;
-
-	const files = readdirSync(dir)
-		.filter((f) => f.startsWith(`${phase}-`) && f.endsWith(".json"))
-		.sort()
-		.reverse(); // most recent first
-
-	if (files.length === 0) return undefined;
-
-	try {
-		const content = readFileSync(path.join(dir, files[0]!), "utf-8");
-		return JSON.parse(content) as IntermediateOutput;
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Clean up intermediate files, preserving specified patterns.
- *
- * @param config - Store configuration
- * @returns Number of files removed
- */
-export function cleanupIntermediates(config: Partial<IntermediateStoreConfig> = {}): number {
-	const dir = config.intermediateDir ?? DEFAULT_CONFIG.intermediateDir;
-	const preserve = config.preservePatterns ?? DEFAULT_CONFIG.preservePatterns;
-
-	if (!existsSync(dir)) return 0;
-
-	const files = readdirSync(dir);
-	let removed = 0;
-
-	for (const file of files) {
-		const shouldPreserve = preserve.some((pattern) => file.includes(pattern));
-		if (!shouldPreserve) {
-			try {
-				unlinkSync(path.join(dir, file));
-				removed++;
-			} catch (error) {
-				logInternalError("intermediate-store.cleanup", error, `file=${file}`);
-			}
-		}
-	}
-
-	return removed;
-}
-
-/**
- * Check if a phase has completed (intermediate exists).
- */
-export function hasPhaseCompleted(config: Partial<IntermediateStoreConfig>, phase: string, stepId: string): boolean {
-	return readIntermediate(config, phase, stepId) !== undefined;
-}