@rosetears/aili-pi 0.1.0 → 0.1.1

package/extensions/zentui/project-refresh.ts

@@ -0,0 +1,104 @@
+export type StopProjectRefreshInterval = () => void;
+
+export type ScheduleProjectRefreshOptions = {
+	force?: boolean;
+};
+
+export type ProjectRefreshScheduler<T> = {
+	schedule: (target: T, options?: ScheduleProjectRefreshOptions) => void;
+	stop: () => void;
+};
+
+export const PROJECT_REFRESH_THROTTLE_MS = 5_000;
+
+export function startProjectRefreshInterval(
+	intervalMs: number,
+	refresh: () => void,
+): StopProjectRefreshInterval {
+	if (intervalMs <= 0) return () => {};
+
+	const timer = setInterval(refresh, intervalMs);
+	timer.unref?.();
+
+	return () => clearInterval(timer);
+}
+
+export function createProjectRefreshScheduler<T>(
+	refresh: (target: T) => Promise<void>,
+	afterRefresh: () => void,
+	throttleMs = PROJECT_REFRESH_THROTTLE_MS,
+): ProjectRefreshScheduler<T> {
+	let refreshInFlight = false;
+	let refreshPending = false;
+	let pendingTarget: T | undefined;
+	let delayedRefresh: ReturnType<typeof setTimeout> | undefined;
+	let lastRefreshStartedAt: number | undefined;
+	let generation = 0;
+
+	const clearDelayedRefresh = () => {
+		if (!delayedRefresh) return;
+		clearTimeout(delayedRefresh);
+		delayedRefresh = undefined;
+	};
+
+	const runRefresh = (target: T) => {
+		clearDelayedRefresh();
+		if (refreshInFlight) {
+			refreshPending = true;
+			pendingTarget = target;
+			return;
+		}
+
+		const currentGeneration = generation;
+		refreshInFlight = true;
+		lastRefreshStartedAt = Date.now();
+		void refresh(target)
+			.catch(() => undefined)
+			.finally(() => {
+				if (currentGeneration !== generation) return;
+				refreshInFlight = false;
+				afterRefresh();
+				if (refreshPending) {
+					refreshPending = false;
+					const nextTarget = pendingTarget ?? target;
+					pendingTarget = undefined;
+					schedule(nextTarget);
+				}
+			});
+	};
+
+	const schedule = (target: T, options: ScheduleProjectRefreshOptions = {}) => {
+		if (options.force || throttleMs <= 0 || lastRefreshStartedAt === undefined) {
+			runRefresh(target);
+			return;
+		}
+
+		const delayMs = Math.max(0, throttleMs - (Date.now() - lastRefreshStartedAt));
+		if (delayMs === 0) {
+			runRefresh(target);
+			return;
+		}
+
+		pendingTarget = target;
+		if (delayedRefresh) return;
+		delayedRefresh = setTimeout(() => {
+			delayedRefresh = undefined;
+			const nextTarget = pendingTarget ?? target;
+			pendingTarget = undefined;
+			runRefresh(nextTarget);
+		}, delayMs);
+		delayedRefresh.unref?.();
+	};
+
+	return {
+		schedule,
+		stop() {
+			generation += 1;
+			clearDelayedRefresh();
+			refreshInFlight = false;
+			refreshPending = false;
+			pendingTarget = undefined;
+			lastRefreshStartedAt = undefined;
+		},
+	};
+}

package/extensions/zentui/project-state.ts

@@ -0,0 +1,59 @@
+import type { GitReadResult } from "./git.js";
+import { emptyGitStatus } from "./git.js";
+import type { PackageVersionReadResult } from "./package-version.js";
+import type { RuntimeReadResult } from "./runtime.js";
+import type { FooterState } from "./state.js";
+
+/**
+ * Apply a project refresh (git + runtime) onto footer state, preserving
+ * last-good values on transient errors and clearing on cwd change / not-a-repo.
+ *
+ * Returns the cwd to store as `previousCwd` for the next refresh.
+ */
+export function applyProjectRefreshToState(
+	state: FooterState,
+	args: {
+		cwd: string;
+		previousCwd: string | undefined;
+		git: GitReadResult;
+		runtime: RuntimeReadResult;
+		packageVersion?: PackageVersionReadResult;
+	},
+): string {
+	const cwdChanged = args.previousCwd !== undefined && args.previousCwd !== args.cwd;
+
+	if (cwdChanged) {
+		Object.assign(state, emptyGitStatus());
+		state.runtime = undefined;
+		state.packageVersion = undefined;
+	}
+
+	if (args.git.kind === "ok") {
+		Object.assign(state, args.git.status);
+	} else if (args.git.kind === "not_a_repo") {
+		Object.assign(state, emptyGitStatus());
+	}
+	// kind === "error": keep previous git fields (unless cwdChanged already cleared)
+
+	if (args.runtime.kind === "ok") {
+		state.runtime = args.runtime.runtime;
+	} else if (cwdChanged && args.runtime.kind === "error") {
+		// Already cleared above; keep undefined.
+		state.runtime = undefined;
+	}
+	// error + same cwd: keep previous runtime
+
+	if (args.packageVersion !== undefined) {
+		if (args.packageVersion.kind === "ok") {
+			// `null` means "no manifest in this cwd"; clear so the segment disappears
+			// even on the same cwd when the user removes their manifest.
+			state.packageVersion = args.packageVersion.result ?? undefined;
+		} else if (!cwdChanged) {
+			// error + same cwd: keep previous packageVersion (last-good semantics)
+		} else {
+			state.packageVersion = undefined;
+		}
+	}
+
+	return args.cwd;
+}

package/extensions/zentui/prototype-patch-registry.ts

@@ -0,0 +1,111 @@
+export const ZENTUI_PROTOTYPE_PATCH_REGISTRY = Symbol.for("pi-zentui.prototype-patch-registry");
+
+type PrototypePatchAdapter =
+	| "user-message-render"
+	| "user-message-invalidate"
+	| "selector-border-render"
+	| "tool-execution-render"
+	| "tool-execution-invalidate"
+	| "assistant-thinking-content";
+
+type PrototypeMethodName = "render" | "invalidate" | "updateContent";
+type PrototypeMethod = (this: unknown, ...args: unknown[]) => unknown;
+
+type PatchInvocation = {
+	predecessor: PrototypeMethod;
+	receiver: unknown;
+	args: unknown[];
+};
+
+type PatchBehavior = (invocation: PatchInvocation) => unknown;
+
+type Registration = {
+	token: symbol;
+	behavior?: PatchBehavior;
+};
+
+type PatchRecord = {
+	method: PrototypeMethodName;
+	predecessor: PrototypeMethod;
+	wrapper: PrototypeMethod;
+	registration?: Registration;
+};
+
+type PatchRegistry = Map<PrototypePatchAdapter, PatchRecord>;
+
+type PatchTarget = Record<PropertyKey, unknown>;
+
+function registryFor(target: PatchTarget): PatchRegistry {
+	const existing = target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+	if (existing instanceof Map) return existing as PatchRegistry;
+	const registry: PatchRegistry = new Map();
+	Object.defineProperty(target, ZENTUI_PROTOTYPE_PATCH_REGISTRY, {
+		value: registry,
+		configurable: true,
+	});
+	return registry;
+}
+
+function createCleanup(
+	target: PatchTarget,
+	method: PrototypeMethodName,
+	adapter: PrototypePatchAdapter,
+	registry: PatchRegistry,
+	record: PatchRecord,
+	token: symbol,
+): () => void {
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		if (record.registration?.token !== token) return;
+		record.registration.behavior = undefined;
+		record.registration = undefined;
+
+		const current = registry.get(adapter);
+		if (current !== record) return;
+		if (target[method] === record.wrapper) target[method] = record.predecessor;
+		registry.delete(adapter);
+		if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+	};
+}
+
+export function installPrototypePatch(
+	targetValue: object,
+	method: PrototypeMethodName,
+	adapter: PrototypePatchAdapter,
+	behavior: PatchBehavior,
+): () => void {
+	const target = targetValue as PatchTarget;
+	const registry = registryFor(target);
+	let record = registry.get(adapter);
+
+	if (!(record && record.method === method && target[method] === record.wrapper)) {
+		const predecessor = target[method];
+		if (typeof predecessor !== "function") {
+			throw new TypeError(`Cannot patch ${method}: predecessor is not a function`);
+		}
+		const nextRecord: PatchRecord = {
+			method,
+			predecessor: predecessor as PrototypeMethod,
+			wrapper: () => undefined,
+		};
+		const wrapper: PrototypeMethod = function zentuiPrototypeWrapper(
+			this: unknown,
+			...args: unknown[]
+		): unknown {
+			const activeBehavior = nextRecord.registration?.behavior;
+			return activeBehavior
+				? activeBehavior({ predecessor: nextRecord.predecessor, receiver: this, args })
+				: Reflect.apply(nextRecord.predecessor, this, args);
+		};
+		nextRecord.wrapper = wrapper;
+		record = nextRecord;
+		registry.set(adapter, record);
+		target[method] = wrapper;
+	}
+
+	const token = Symbol(adapter);
+	record.registration = { token, behavior };
+	return createCleanup(target, method, adapter, registry, record, token);
+}