ultimate-pi 0.18.1 → 0.19.0

package/.pi/lib/harness-lens/clients/runtime-agent-end.ts

@@ -0,0 +1,112 @@
+import * as nodeFs from "node:fs";
+import type { FormatService } from "./format-service.js";
+import { logLatency } from "./latency-logger.js";
+import { resyncLspFile, runFormatPhase } from "./pipeline.js";
+import type { RuntimeCoordinator } from "./runtime-coordinator.js";
+
+interface AgentEndDeps {
+	ctxCwd?: string;
+	getFlag: (name: string) => boolean | string | undefined;
+	notify: (msg: string, level: "info" | "warning" | "error") => void;
+	dbg: (msg: string) => void;
+	runtime: RuntimeCoordinator;
+	getFormatService: () => FormatService;
+}
+
+export interface AgentEndFormatSummary {
+	queued: number;
+	formatted: number;
+	changed: string[];
+	failed: Array<{ filePath: string; errors: string[] }>;
+	skipped: Array<{ filePath: string; reason: string }>;
+}
+
+export async function handleAgentEnd({
+	ctxCwd,
+	getFlag,
+	notify,
+	dbg,
+	runtime,
+	getFormatService,
+}: AgentEndDeps): Promise<AgentEndFormatSummary | undefined> {
+	const records = runtime.consumeDeferredFormatFiles();
+	if (records.length === 0) return undefined;
+
+	const startedAt = Date.now();
+	const summary: AgentEndFormatSummary = {
+		queued: records.length,
+		formatted: 0,
+		changed: [],
+		failed: [],
+		skipped: [],
+	};
+
+	if (getFlag("no-autoformat")) {
+		for (const record of records) {
+			summary.skipped.push({
+				filePath: record.filePath,
+				reason: "no-autoformat",
+			});
+		}
+		return summary;
+	}
+
+	for (const record of records) {
+		const filePath = record.filePath;
+		if (!nodeFs.existsSync(filePath)) {
+			summary.skipped.push({ filePath, reason: "missing" });
+			continue;
+		}
+		try {
+			const result = await runFormatPhase(filePath, getFormatService, dbg);
+			summary.formatted++;
+			if (result.formatFailures.length > 0) {
+				summary.failed.push({ filePath, errors: result.formatFailures });
+			}
+			if (result.formatChanged) summary.changed.push(filePath);
+			if (result.fileContent) {
+				await resyncLspFile(
+					filePath,
+					result.fileContent,
+					true,
+					false,
+					getFlag,
+					dbg,
+					result.formatChanged,
+				);
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			summary.failed.push({ filePath, errors: [message] });
+			dbg(`agent_end deferred_format failed for ${filePath}: ${message}`);
+		}
+	}
+
+	logLatency({
+		type: "tool_result",
+		toolName: "agent_end",
+		filePath: ctxCwd ?? runtime.projectRoot,
+		durationMs: Date.now() - startedAt,
+		result: "deferred_format_complete",
+		metadata: {
+			queued: summary.queued,
+			formatted: summary.formatted,
+			changed: summary.changed.length,
+			failed: summary.failed.length,
+		},
+	});
+
+	if (summary.failed.length > 0) {
+		notify(
+			`harness-lens deferred format: ${summary.changed.length} changed, ${summary.failed.length} failed`,
+			"warning",
+		);
+	} else if (summary.changed.length > 0) {
+		notify(
+			`harness-lens deferred format applied to ${summary.changed.length} file(s)`,
+			"info",
+		);
+	}
+
+	return summary;
+}

package/.pi/lib/harness-lens/clients/runtime-config.ts

@@ -0,0 +1,33 @@
+/**
+ * Central runtime tuning knobs for pipeline/dispatch behavior.
+ * Keep these values in one place so behavior is consistent and easy to tune.
+ */
+
+export const RUNTIME_CONFIG = {
+	pipeline: {
+		lspMaxFileBytes: 2 * 1024 * 1024,
+		lspMaxFileLines: 5000,
+		cascadeMaxFiles: 5,
+		cascadeMaxDiagnosticsPerFile: 20,
+		// Hard cap on how long the pipeline will wait for an LSP client to spawn.
+		// Keeps tool_result from blocking the TUI during cold LSP start (e.g.
+		// pyright workspace indexing). The LSP server continues spawning in the
+		// background; subsequent edits get full diagnostics once it is ready.
+		lspSpawnBudgetMs: 5_000,
+	},
+	dispatch: {
+		runnerTimeoutMs: 30_000,
+	},
+	crashNotice: {
+		alwaysShowFirstN: 2,
+		showEveryNth: 5,
+	},
+	reviewGraph: {
+		maxFiles: 1_000,
+		maxFileBytes: 1 * 1024 * 1024,
+	},
+	turnEnd: {
+		maxLines: 20,
+		maxChars: 1000,
+	},
+} as const;

package/.pi/lib/harness-lens/clients/runtime-coordinator.ts

@@ -0,0 +1,186 @@
+import { randomBytes } from "node:crypto";
+import * as path from "node:path";
+import { normalizeMapKey } from "./path-utils.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+
+export interface DeferredFormatRecord {
+	filePath: string;
+	cwd: string;
+	firstTouchedAt: number;
+	lastTouchedAt: number;
+	toolNames: Set<"write" | "edit">;
+}
+
+export class RuntimeCoordinator {
+	private _projectRoot = normalizeMapKey(process.cwd());
+	private _sessionGeneration = 0;
+	private _pipelineCrashCounts = new Map<string, number>();
+	private _telemetrySessionId = `harness-lens-${Date.now().toString(36)}`;
+	private _telemetryModel = "unknown";
+	private _turnIndex = 0;
+	private _writeIndex = 0;
+	private _gitGuardHasBlockers = false;
+	private _gitGuardSummary = "";
+	private readonly _pendingDeferredFormatFiles = new Map<
+		string,
+		DeferredFormatRecord
+	>();
+	private readonly _lspReadWarmState = new Map<
+		string,
+		{ status: "warming" | "ready"; ts: number }
+	>();
+
+	resetForSession(): void {
+		this._sessionGeneration += 1;
+		this._pipelineCrashCounts.clear();
+		this._telemetrySessionId = `harness-lens-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+		this._telemetryModel = "unknown";
+		this._turnIndex = 0;
+		this._writeIndex = 0;
+		this._gitGuardHasBlockers = false;
+		this._gitGuardSummary = "";
+		this._pendingDeferredFormatFiles.clear();
+		this._lspReadWarmState.clear();
+	}
+
+	updateGitGuardStatus(hasBlockers: boolean, output: string): void {
+		this._gitGuardHasBlockers = hasBlockers;
+		if (!hasBlockers) {
+			this._gitGuardSummary = "";
+			return;
+		}
+		const firstLine = output
+			.split("\n")
+			.map((line) => line.trim())
+			.find((line) => line.length > 0);
+		this._gitGuardSummary = (firstLine ?? "Unresolved blockers detected").slice(
+			0,
+			160,
+		);
+	}
+
+	get gitGuardHasBlockers(): boolean {
+		return this._gitGuardHasBlockers;
+	}
+
+	get gitGuardSummary(): string {
+		return this._gitGuardSummary;
+	}
+
+	beginTurn(): void {
+		this._turnIndex += 1;
+		this._writeIndex = 0;
+	}
+
+	nextWriteIndex(): number {
+		this._writeIndex += 1;
+		return this._writeIndex;
+	}
+
+	setTelemetryIdentity(identity: {
+		sessionId?: string;
+		model?: string;
+		provider?: string;
+	}): void {
+		if (identity.sessionId?.trim()) {
+			this._telemetrySessionId = identity.sessionId.trim();
+		}
+		const model = identity.model?.trim();
+		const provider = identity.provider?.trim();
+		if (model && provider) this._telemetryModel = `${provider}/${model}`;
+		else if (model) this._telemetryModel = model;
+		else if (provider) this._telemetryModel = provider;
+	}
+
+	get telemetrySessionId(): string {
+		return this._telemetrySessionId;
+	}
+
+	get telemetryModel(): string {
+		return this._telemetryModel;
+	}
+
+	get turnIndex(): number {
+		return this._turnIndex;
+	}
+
+	get sessionGeneration(): number {
+		return this._sessionGeneration;
+	}
+
+	formatPipelineCrashNotice(filePath: string, err: unknown): string {
+		const key = path.resolve(filePath);
+		const count = (this._pipelineCrashCounts.get(key) ?? 0) + 1;
+		this._pipelineCrashCounts.set(key, count);
+		const message = err instanceof Error ? err.message : String(err);
+		const shortMessage = message.split("\n")[0].slice(0, 220);
+		const shouldSurface =
+			count <= RUNTIME_CONFIG.crashNotice.alwaysShowFirstN ||
+			count % RUNTIME_CONFIG.crashNotice.showEveryNth === 0;
+		if (!shouldSurface) return "";
+		return [
+			"⚠️ harness-lens pipeline crashed while analyzing this write.",
+			`File: ${path.basename(filePath)} | crash count this session: ${count}`,
+			`Error: ${shortMessage}`,
+			"Recovery: LSP service was reset. If this repeats, rerun with --no-lsp.",
+		].join("\n");
+	}
+
+	get projectRoot(): string {
+		return this._projectRoot;
+	}
+
+	set projectRoot(value: string) {
+		this._projectRoot = normalizeMapKey(value);
+	}
+
+	deferFormat(filePath: string, cwd: string, toolName: "write" | "edit"): void {
+		const key = path.resolve(filePath);
+		const now = Date.now();
+		const existing = this._pendingDeferredFormatFiles.get(key);
+		if (existing) {
+			existing.lastTouchedAt = now;
+			existing.cwd = cwd;
+			existing.toolNames.add(toolName);
+			return;
+		}
+		this._pendingDeferredFormatFiles.set(key, {
+			filePath: key,
+			cwd,
+			firstTouchedAt: now,
+			lastTouchedAt: now,
+			toolNames: new Set([toolName]),
+		});
+	}
+
+	consumeDeferredFormatFiles(): DeferredFormatRecord[] {
+		const records = [...this._pendingDeferredFormatFiles.values()];
+		this._pendingDeferredFormatFiles.clear();
+		return records;
+	}
+
+	shouldWarmLspOnRead(filePath: string, maxAgeMs = 120_000): boolean {
+		const state = this._lspReadWarmState.get(path.resolve(filePath));
+		if (!state) return true;
+		if (state.status === "warming") return false;
+		return Date.now() - state.ts > maxAgeMs;
+	}
+
+	markLspReadWarmStarted(filePath: string): void {
+		this._lspReadWarmState.set(path.resolve(filePath), {
+			status: "warming",
+			ts: Date.now(),
+		});
+	}
+
+	markLspReadWarmCompleted(filePath: string): void {
+		this._lspReadWarmState.set(path.resolve(filePath), {
+			status: "ready",
+			ts: Date.now(),
+		});
+	}
+
+	clearLspReadWarmState(filePath: string): void {
+		this._lspReadWarmState.delete(path.resolve(filePath));
+	}
+}

package/.pi/lib/harness-lens/clients/runtime-tool-result.ts

@@ -0,0 +1,171 @@
+import * as nodeCrypto from "node:crypto";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { isPathIgnoredByProject } from "./file-utils.js";
+import { getFormatService } from "./format-service.js";
+import { logLatency } from "./latency-logger.js";
+import { isExternalOrVendorFile } from "./path-utils.js";
+import { type PipelineResult, runPipeline } from "./pipeline.js";
+import { resolveProjectRootForFile } from "./project-profile.js";
+import type { RuntimeCoordinator } from "./runtime-coordinator.js";
+
+interface ToolResultEvent {
+	toolName: string;
+	input: unknown;
+	content: Array<{ type: string; text?: string }>;
+	provider?: string;
+	model?: string;
+	sessionId?: string;
+	session?: { id?: string };
+}
+
+interface ToolResultDeps {
+	event: ToolResultEvent;
+	getFlag: (name: string) => boolean | string | undefined;
+	dbg: (msg: string) => void;
+	runtime: RuntimeCoordinator;
+	resetLSPService: () => void;
+}
+
+const inFlightPipelines = new Map<string, Promise<unknown>>();
+const lastAnalyzedStateByFile = new Map<
+	string,
+	{ turnIndex: number; stateHash: string }
+>();
+
+export function clearLastAnalyzedStateCache(): void {
+	lastAnalyzedStateByFile.clear();
+}
+
+function getFileStateHash(filePath: string): string {
+	try {
+		const content = nodeFs.readFileSync(filePath);
+		return nodeCrypto.createHash("sha256").update(content).digest("hex");
+	} catch (err) {
+		const code = (err as { code?: string }).code ?? "unknown";
+		return `unreadable:${code}`;
+	}
+}
+
+export async function handleToolResult(deps: ToolResultDeps): Promise<{
+	content: Array<{ type: string; text?: string }>;
+	isError?: boolean;
+} | void> {
+	const { event, getFlag, dbg, runtime, resetLSPService } = deps;
+
+	const rawFilePath = (event.input as { path?: string }).path;
+	const workspaceRoot = runtime.projectRoot || process.cwd();
+	const filePath = rawFilePath
+		? path.isAbsolute(rawFilePath)
+			? rawFilePath
+			: path.resolve(workspaceRoot, rawFilePath)
+		: rawFilePath;
+
+	if (event.toolName !== "write" && event.toolName !== "edit") return;
+	if (!filePath) return;
+	if (isExternalOrVendorFile(filePath, workspaceRoot)) return;
+	if (isPathIgnoredByProject(filePath, workspaceRoot, false)) return;
+
+	const initialStateHash = getFileStateHash(filePath);
+	const pipelineDedupeKey = `${filePath}:${initialStateHash}`;
+
+	if (inFlightPipelines.has(pipelineDedupeKey)) {
+		await inFlightPipelines.get(pipelineDedupeKey);
+		return;
+	}
+
+	const lastAnalyzed = lastAnalyzedStateByFile.get(filePath);
+	if (
+		lastAnalyzed?.turnIndex === runtime.turnIndex &&
+		lastAnalyzed.stateHash === initialStateHash
+	) {
+		return;
+	}
+
+	const toolResultStart = Date.now();
+	const cwd = resolveProjectRootForFile(filePath, workspaceRoot);
+
+	if (event.model || event.provider || event.sessionId || event.session?.id) {
+		runtime.setTelemetryIdentity({
+			model: event.model,
+			provider: event.provider,
+			sessionId: event.sessionId ?? event.session?.id,
+		});
+	}
+
+	const writeIndex = runtime.nextWriteIndex();
+	let result: PipelineResult;
+	const pipelinePromise = runPipeline(
+		{
+			filePath,
+			cwd,
+			toolName: event.toolName,
+			telemetry: {
+				model: runtime.telemetryModel,
+				sessionId: runtime.telemetrySessionId,
+				turnIndex: runtime.turnIndex,
+				writeIndex,
+			},
+			getFlag,
+			dbg,
+		},
+		{ getFormatService },
+	);
+	inFlightPipelines.set(pipelineDedupeKey, pipelinePromise);
+	try {
+		result = await pipelinePromise;
+	} catch (pipelineErr) {
+		if (!getFlag("no-lsp")) resetLSPService();
+		logLatency({
+			type: "tool_result",
+			toolName: event.toolName,
+			filePath,
+			durationMs: Date.now() - toolResultStart,
+			result: "pipeline_crash",
+		});
+		const notice = runtime.formatPipelineCrashNotice(filePath, pipelineErr);
+		if (!notice) return;
+		return {
+			content: [...event.content, { type: "text", text: notice }],
+		};
+	} finally {
+		inFlightPipelines.delete(pipelineDedupeKey);
+	}
+
+	lastAnalyzedStateByFile.set(filePath, {
+		turnIndex: runtime.turnIndex,
+		stateHash: getFileStateHash(filePath),
+	});
+
+	if (
+		!result.isError &&
+		!getFlag("no-autoformat") &&
+		!getFlag("immediate-format") &&
+		nodeFs.existsSync(filePath)
+	) {
+		runtime.deferFormat(filePath, cwd, event.toolName);
+		dbg(`tool_result: queued deferred format for ${filePath}`);
+	}
+
+	if (result.isError) {
+		return {
+			content: [...event.content, { type: "text", text: result.output }],
+			isError: true,
+		};
+	}
+
+	runtime.updateGitGuardStatus(result.hasBlockers, result.output);
+
+	logLatency({
+		type: "tool_result",
+		toolName: event.toolName,
+		filePath,
+		durationMs: Date.now() - toolResultStart,
+		result: result.output ? "completed" : "no_output",
+	});
+
+	if (!result.output) return;
+	return {
+		content: [...event.content, { type: "text", text: result.output }],
+	};
+}