@selesai/code 0.9.15 → 0.10.1

package/dist/extensions/pi-zentui/extensions/zentui/project-refresh.ts

@@ -0,0 +1,120 @@
+export type StopProjectRefreshInterval = () => void;
+
+export type ScheduleProjectRefreshOptions = {
+	force?: boolean;
+};
+
+export type ProjectRefreshRun = {
+	isCurrent: () => boolean;
+};
+
+export type ProjectRefreshScheduler<T> = {
+	schedule: (target: T, options?: ScheduleProjectRefreshOptions) => void;
+	invalidate: () => 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, run: ProjectRefreshRun) => Promise<void>,
+	afterRefresh: () => void,
+	throttleMs = PROJECT_REFRESH_THROTTLE_MS,
+): ProjectRefreshScheduler<T> {
+	let refreshInFlight = false;
+	let refreshPending = false;
+	let pendingForce = 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, options: ScheduleProjectRefreshOptions = {}) => {
+		clearDelayedRefresh();
+		if (refreshInFlight) {
+			refreshPending = true;
+			pendingForce ||= options.force === true;
+			pendingTarget = target;
+			return;
+		}
+
+		const currentGeneration = generation;
+		const run: ProjectRefreshRun = {
+			isCurrent: () => currentGeneration === generation,
+		};
+		refreshInFlight = true;
+		lastRefreshStartedAt = Date.now();
+		void refresh(target, run)
+			.catch(() => undefined)
+			.finally(() => {
+				if (currentGeneration !== generation) return;
+				refreshInFlight = false;
+				afterRefresh();
+				if (refreshPending) {
+					refreshPending = false;
+					const nextForce = pendingForce;
+					pendingForce = false;
+					const nextTarget = pendingTarget ?? target;
+					pendingTarget = undefined;
+					schedule(nextTarget, { force: nextForce });
+				}
+			});
+	};
+
+	const schedule = (target: T, options: ScheduleProjectRefreshOptions = {}) => {
+		if (options.force || throttleMs <= 0 || lastRefreshStartedAt === undefined) {
+			runRefresh(target, options);
+			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?.();
+	};
+
+	const invalidate = () => {
+		generation += 1;
+		clearDelayedRefresh();
+		refreshInFlight = false;
+		refreshPending = false;
+		pendingForce = false;
+		pendingTarget = undefined;
+		lastRefreshStartedAt = undefined;
+	};
+
+	return {
+		schedule,
+		invalidate,
+		stop: invalidate,
+	};
+}

package/dist/extensions/pi-zentui/extensions/zentui/project-state.ts

@@ -0,0 +1,59 @@
+import type { GitReadResult } from "./git";
+import { emptyGitStatus } from "./git";
+import type { PackageVersionReadResult } from "./package-version";
+import type { RuntimeReadResult } from "./runtime";
+import type { FooterState } from "./state";
+
+/**
+ * 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/dist/extensions/pi-zentui/extensions/zentui/prototype-patch-registry.ts

@@ -0,0 +1,166 @@
+export const ZENTUI_PROTOTYPE_PATCH_REGISTRY = Symbol.for("pi-zentui.prototype-patch-registry");
+
+type PrototypePatchAdapter =
+	| "user-message-render"
+	| "user-message-invalidate"
+	| "selector-border-render";
+
+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: "render" | "invalidate";
+	predecessor: PrototypeMethod;
+	predecessorDescriptor?: PropertyDescriptor;
+	wrapper: PrototypeMethod;
+	registration?: Registration;
+};
+
+type PatchRegistry = Map<PrototypePatchAdapter, PatchRecord>;
+
+type PatchTarget = Record<PropertyKey, unknown>;
+
+function existingRegistry(target: PatchTarget): PatchRegistry | undefined {
+	const existing = target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+	return existing instanceof Map ? (existing as PatchRegistry) : undefined;
+}
+
+function registryFor(target: PatchTarget): PatchRegistry {
+	const existing = existingRegistry(target);
+	if (existing) return existing;
+	const registry: PatchRegistry = new Map();
+	Object.defineProperty(target, ZENTUI_PROTOTYPE_PATCH_REGISTRY, {
+		value: registry,
+		configurable: true,
+	});
+	return registry;
+}
+
+function deactivateRecord(record: PatchRecord): void {
+	if (!record.registration) return;
+	record.registration.behavior = undefined;
+	record.registration = undefined;
+}
+
+function restorePredecessor(target: PatchTarget, record: PatchRecord): void {
+	if (target[record.method] !== record.wrapper) return;
+	if (record.predecessorDescriptor) {
+		Object.defineProperty(target, record.method, record.predecessorDescriptor);
+	} else {
+		delete target[record.method];
+	}
+}
+
+function installWrapper(target: PatchTarget, record: PatchRecord): void {
+	const descriptor = record.predecessorDescriptor;
+	if (descriptor && "value" in descriptor) {
+		Object.defineProperty(target, record.method, { ...descriptor, value: record.wrapper });
+		return;
+	}
+	Object.defineProperty(target, record.method, {
+		value: record.wrapper,
+		writable: true,
+		enumerable: descriptor?.enumerable ?? true,
+		configurable: true,
+	});
+}
+
+function createCleanup(
+	target: PatchTarget,
+	adapter: PrototypePatchAdapter,
+	registry: PatchRegistry,
+	record: PatchRecord,
+	token: symbol,
+): () => void {
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		if (record.registration?.token !== token) return;
+		deactivateRecord(record);
+
+		const current = registry.get(adapter);
+		if (current !== record) return;
+		restorePredecessor(target, record);
+		registry.delete(adapter);
+		if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+	};
+}
+
+export function installPrototypePatch(
+	targetValue: object,
+	method: "render" | "invalidate",
+	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 displacedRecord = record;
+		const predecessorDescriptor = Object.getOwnPropertyDescriptor(target, method);
+		const predecessor = target[method];
+		if (typeof predecessor !== "function") {
+			if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+			throw new TypeError(`Cannot patch ${method}: predecessor is not a function`);
+		}
+		const nextRecord: PatchRecord = {
+			method,
+			predecessor: predecessor as PrototypeMethod,
+			predecessorDescriptor,
+			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;
+		try {
+			installWrapper(target, nextRecord);
+		} catch (error) {
+			if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+			throw error;
+		}
+		record = nextRecord;
+		registry.set(adapter, record);
+		if (displacedRecord && displacedRecord !== record) deactivateRecord(displacedRecord);
+	}
+
+	const token = Symbol(adapter);
+	record.registration = { token, behavior };
+	return createCleanup(target, adapter, registry, record, token);
+}
+
+export function removePrototypePatch(
+	targetValue: object,
+	method: "render" | "invalidate",
+	adapter: PrototypePatchAdapter,
+): void {
+	const target = targetValue as PatchTarget;
+	const registry = existingRegistry(target);
+	const record = registry?.get(adapter);
+	if (!registry || !record || record.method !== method) return;
+
+	deactivateRecord(record);
+	restorePredecessor(target, record);
+	registry.delete(adapter);
+	if (registry.size === 0) delete target[ZENTUI_PROTOTYPE_PATCH_REGISTRY];
+}

package/dist/extensions/pi-zentui/extensions/zentui/repository-root.ts

@@ -0,0 +1,98 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export type RepositoryRootState = {
+	/** The cwd whose repository lookup produced this state. */
+	cwd: string;
+	root?: string;
+};
+
+export type RepositoryRootRequest = {
+	cwd: string;
+	generation: number;
+};
+
+/** Find the nearest ancestor containing either a .git directory or worktree .git file. */
+export function findRepositoryRoot(cwd: string): string | undefined {
+	let current = resolve(cwd);
+	while (true) {
+		if (existsSync(join(current, ".git"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return undefined;
+		current = parent;
+	}
+}
+
+export function updateRepositoryRootState(
+	cwd: string,
+	isRepository: boolean,
+	findRoot: (cwd: string) => string | undefined = findRepositoryRoot,
+): RepositoryRootState {
+	if (!isRepository) return { cwd };
+	try {
+		return { cwd, root: findRoot(cwd) };
+	} catch {
+		return { cwd };
+	}
+}
+
+/** Return only a current, still-present root produced for this exact cwd. */
+export function repositoryRootForCwd(
+	state: RepositoryRootState | undefined,
+	cwd: string,
+	markerExists: (path: string) => boolean = existsSync,
+): string | undefined {
+	if (!state?.root || state.cwd !== cwd) return undefined;
+	try {
+		return markerExists(join(state.root, ".git")) ? state.root : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Own repository-root request generations so returning to an older cwd cannot revive old state. */
+export class RepositoryRootController {
+	private generation = 0;
+	private requestedCwd: string | undefined;
+	private state: RepositoryRootState | undefined;
+
+	request(cwd: string): RepositoryRootRequest {
+		if (cwd !== this.requestedCwd) {
+			this.generation += 1;
+			this.requestedCwd = cwd;
+			this.state = undefined;
+		}
+		return { cwd, generation: this.generation };
+	}
+
+	isCurrent(request: RepositoryRootRequest): boolean {
+		return request.cwd === this.requestedCwd && request.generation === this.generation;
+	}
+
+	update(
+		request: RepositoryRootRequest,
+		isRepository: boolean,
+		findRoot: (cwd: string) => string | undefined = findRepositoryRoot,
+	): string | undefined {
+		if (!this.isCurrent(request)) return undefined;
+		this.state = updateRepositoryRootState(request.cwd, isRepository, findRoot);
+		return this.state.root;
+	}
+
+	cachedRootForCwd(cwd: string): string | undefined {
+		return this.state?.cwd === cwd ? this.state.root : undefined;
+	}
+
+	rootForCwd(
+		cwd: string,
+		markerExists: (path: string) => boolean = existsSync,
+	): string | undefined {
+		return repositoryRootForCwd(this.state, cwd, markerExists);
+	}
+
+	reset(): void {
+		this.generation += 1;
+		this.requestedCwd = undefined;
+		this.state = undefined;
+	}
+}