pi-gentic 0.1.0

package/dist/runtime.js

@@ -0,0 +1,360 @@
+/**
+ * Runtime integration with Pi.
+ *
+ * This module owns live session hosts, background runtime lookup, recursive
+ * abort wiring, and the prototype bridges needed to resume live sessions.
+ */
+import { homedir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { defaultAgentDir } from "./config.js";
+let peerModule;
+/** Resolves Pi peer APIs from tests, local installs, or Pi managed installs. */
+async function piCodingAgent() {
+    const managedCli = path.join(homedir(), "AppData", "Local", "pi-managed", "node_modules", "@earendil-works", "pi-coding-agent", "dist", "cli.js");
+    const indexFiles = [process.env.PI_CLI, process.argv[1], managedCli]
+        .filter(Boolean)
+        .map((file) => path.join(path.dirname(String(file)), "index.js"));
+    peerModule ??= importFirst([
+        "@earendil-works/pi-coding-agent",
+        ...indexFiles.map((file) => pathToFileURL(file).href),
+    ]);
+    return peerModule;
+}
+async function importFirst(specifiers) {
+    for (const specifier of specifiers) {
+        try {
+            return (await import(specifier));
+        }
+        catch { }
+    }
+    return (await import("@earendil-works/pi-coding-agent"));
+}
+const LIVE_RUNTIME_STATE_KEY = Symbol.for("pi-gentic.live-runtime-state");
+export function getLiveRuntimeState() {
+    return (globalThis[LIVE_RUNTIME_STATE_KEY] ??= {
+        liveRuntimes: new Map(),
+        hostSwitchSession: undefined,
+        hostAbortSession: undefined,
+        hostSetupKeyHandlers: undefined,
+        activeContext: undefined,
+        activeSession: undefined,
+        bridgeInstalled: false,
+        abortBridgeInstalled: false,
+        escapeBridgeInstalled: false,
+    });
+}
+const activeCalls = new Map();
+let nextCallId = 0;
+export function registerAgentCall(call) {
+    const id = call.id ?? `agent-call:${++nextCallId}`;
+    activeCalls.set(id, { ...call, id, startedAt: Date.now() });
+    return {
+        id,
+        unregister: () => activeCalls.delete(id),
+    };
+}
+export function hasAgentCallsForSession(sessionId) {
+    return activeCallsForSession(sessionId).length > 0;
+}
+export async function abortAgentCall(callId, options = {}) {
+    return abortCalls([activeCalls.get(callId)].filter(Boolean), options);
+}
+export async function abortAgentCallsForSession(sessionId, options = {}) {
+    return abortCalls(activeCallsForSession(sessionId), options);
+}
+function activeCallsForSession(sessionId) {
+    return [...activeCalls.values()].filter((call) => call.callerSessionId === sessionId);
+}
+async function abortCalls(calls, options = {}) {
+    const state = isAbortState(options.state)
+        ? options.state
+        : { sessions: new Set(), calls: new Set() };
+    let aborted = 0;
+    for (const call of calls) {
+        if (!call || state.calls.has(call.id))
+            continue;
+        state.calls.add(call.id);
+        if (call.targetSessionId && !state.sessions.has(call.targetSessionId)) {
+            state.sessions.add(call.targetSessionId);
+            aborted += await abortAgentCallsForSession(call.targetSessionId, {
+                ...options,
+                state,
+            });
+        }
+        if (typeof call.abort === "function") {
+            await call.abort(options);
+            aborted += 1;
+        }
+    }
+    return aborted;
+}
+function isAbortState(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.sessions instanceof Set &&
+        value.calls instanceof Set);
+}
+export const LIVE_SESSION_PREFIX = "pi-gentic-live:";
+/** Installs bridge hooks once so live background sessions can be resumed in Pi. */
+export function installLiveSessionBridge() {
+    const state = getLiveRuntimeState();
+    void piCodingAgent().then((peer) => {
+        installRuntimeSwitchBridge(state, peer);
+        installSessionAbortBridge(state, peer);
+        installInteractiveEscapeBridge(state, peer);
+    });
+}
+function installRuntimeSwitchBridge(state, { AgentSessionRuntime }) {
+    if (state.bridgeInstalled)
+        return;
+    state.bridgeInstalled = true;
+    state.hostSwitchSession = AgentSessionRuntime.prototype.switchSession;
+    AgentSessionRuntime.prototype.switchSession =
+        async function switchSessionWithLiveRuntime(sessionPath, options) {
+            const switchOptions = withVisibleContextTracking(state, this, options);
+            if (typeof sessionPath !== "string" ||
+                !sessionPath.startsWith(LIVE_SESSION_PREFIX)) {
+                const restore = parkCurrentLiveRuntimeForSwitch(state, this);
+                try {
+                    return await state.hostSwitchSession?.call(this, sessionPath, switchOptions);
+                }
+                finally {
+                    restore();
+                }
+            }
+            const sessionId = sessionPath.slice(LIVE_SESSION_PREFIX.length);
+            const live = state.liveRuntimes.get(sessionId);
+            if (!live)
+                throw new Error(`No live pi-gentic session ${sessionId} is available.`);
+            const targetSessionFile = live.runtime.session.sessionFile;
+            const beforeResult = await this.emitBeforeSwitch("resume", targetSessionFile);
+            if (beforeResult.cancelled)
+                return beforeResult;
+            const restore = parkCurrentLiveRuntimeForSwitch(state, this);
+            try {
+                await this.teardownCurrent("resume", targetSessionFile);
+            }
+            finally {
+                restore();
+            }
+            this.apply({
+                session: live.runtime.session,
+                services: live.runtime.services,
+                diagnostics: live.runtime.diagnostics,
+                modelFallbackMessage: live.runtime.modelFallbackMessage,
+            });
+            await this.finishSessionReplacement(switchOptions.withSession);
+            return { cancelled: false };
+        };
+}
+function withVisibleContextTracking(state, runtimeHost, options = {}) {
+    const originalWithSession = options.withSession;
+    return {
+        ...options,
+        async withSession(nextCtx) {
+            state.activeContext = nextCtx;
+            state.activeSession = runtimeHost.session;
+            if (typeof originalWithSession === "function")
+                await originalWithSession(nextCtx);
+        },
+    };
+}
+export function activeVisibleContext() {
+    return getLiveRuntimeState().activeContext;
+}
+export function activeVisibleSession() {
+    return getLiveRuntimeState().activeSession;
+}
+export function parkCurrentLiveRuntimeForSwitch(state, runtimeHost) {
+    const session = runtimeHost?.session;
+    const sessionId = session?.sessionManager?.getSessionId?.();
+    const tracked = sessionId ? getRuntimeSession(sessionId) : undefined;
+    const liveRuntime = tracked?.runtimeHost;
+    if (!sessionId ||
+        session?.isStreaming !== true ||
+        !liveRuntime ||
+        liveRuntime.session !== session ||
+        typeof session.dispose !== "function")
+        return () => { };
+    const originalDispose = session.dispose;
+    const parkedDispose = () => { };
+    state.liveRuntimes.set(sessionId, {
+        runtime: liveRuntime,
+        metadata: { agentName: tracked.agentName },
+    });
+    session.dispose = parkedDispose;
+    return () => {
+        if (session.dispose !== parkedDispose)
+            return;
+        session.dispose = originalDispose;
+    };
+}
+function installSessionAbortBridge(state, { AgentSession }) {
+    if (state.abortBridgeInstalled)
+        return;
+    state.abortBridgeInstalled = true;
+    state.hostAbortSession =
+        AgentSession.prototype.abort;
+    AgentSession.prototype.abort = async function abortWithPiGenticTargets(...args) {
+        await abortAgentCallsForSession(this.sessionManager.getSessionId?.(), {
+            actor: "aborted session",
+        });
+        return state.hostAbortSession?.apply(this, args);
+    };
+}
+function installInteractiveEscapeBridge(state, { InteractiveMode }) {
+    if (state.escapeBridgeInstalled ||
+        !InteractiveMode?.prototype?.setupKeyHandlers)
+        return;
+    state.escapeBridgeInstalled = true;
+    state.hostSetupKeyHandlers = InteractiveMode.prototype.setupKeyHandlers;
+    InteractiveMode.prototype.setupKeyHandlers =
+        function setupKeyHandlersWithPiGenticAbort(...args) {
+            const result = state.hostSetupKeyHandlers?.apply(this, args);
+            const nativeEscape = this.defaultEditor?.onEscape;
+            if (typeof nativeEscape !== "function")
+                return result;
+            this.defaultEditor.onEscape = () => {
+                const sessionId = this.session?.sessionManager?.getSessionId?.();
+                if (sessionId &&
+                    !this.session?.isStreaming &&
+                    hasAgentCallsForSession(sessionId)) {
+                    void abortAgentCallsForSession(sessionId, {
+                        actor: "caller session",
+                    });
+                    return;
+                }
+                return nativeEscape();
+            };
+            return result;
+        };
+}
+export function livePath(sessionId) {
+    return `${LIVE_SESSION_PREFIX}${sessionId}`;
+}
+const state = getLiveRuntimeState();
+/** Creates a Pi AgentSessionRuntime for a background or reopened session. */
+export async function createLiveRuntime({ cwd, sessionManager, }) {
+    const { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, } = await piCodingAgent();
+    const agentDir = defaultAgentDir();
+    const createRuntime = async (options) => {
+        const services = await createAgentSessionServices({
+            cwd: options.cwd,
+            agentDir: options.agentDir,
+        });
+        const result = await createAgentSessionFromServices({
+            services,
+            sessionManager: options.sessionManager,
+            sessionStartEvent: options.sessionStartEvent,
+        });
+        return {
+            session: result.session,
+            services,
+            diagnostics: services.diagnostics,
+            modelFallbackMessage: result.modelFallbackMessage,
+        };
+    };
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+        cwd,
+        agentDir,
+        sessionManager,
+    });
+    registerLiveRuntime(runtime);
+    return runtime;
+}
+export function registerLiveRuntime(runtime, metadata = {}) {
+    const sessionId = runtime.session.sessionManager.getSessionId();
+    state.liveRuntimes.set(sessionId, { runtime, metadata });
+    return livePath(sessionId);
+}
+export function unregisterLiveRuntime(sessionId) {
+    state.liveRuntimes.delete(sessionId);
+}
+export function getLiveRuntime(sessionId) {
+    return state.liveRuntimes.get(sessionId);
+}
+export function listLiveRuntimes() {
+    return [...state.liveRuntimes.entries()].map(([sessionId, value]) => ({
+        sessionId,
+        ...value,
+    }));
+}
+const runtimeSessions = new Map();
+export function getRuntimeSession(sessionId) {
+    return runtimeSessions.get(sessionId);
+}
+export function findRuntimeSession(predicate) {
+    return [...runtimeSessions.values()].find(predicate);
+}
+/** Registers the latest known runtime state for session discovery and status. */
+export function setRuntimeSession(sessionId, runtime) {
+    const existing = runtimeSessions.get(sessionId);
+    const next = existing ?? runtime;
+    Object.assign(next, runtime, { lastSeenAt: Date.now() });
+    runtimeSessions.set(sessionId, next);
+    pruneRuntimeSessions();
+    return next;
+}
+export function updateRuntimeSession(sessionId, patch) {
+    const existing = runtimeSessions.get(sessionId);
+    if (!existing)
+        return undefined;
+    return setRuntimeSession(sessionId, { ...existing, ...patch });
+}
+export function listRuntimeSessions() {
+    return [...runtimeSessions.values()];
+}
+export function deleteRuntimeSession(sessionId) {
+    runtimeSessions.delete(sessionId);
+}
+export function pruneRuntimeSessions({ maxEntries = 100, maxIdleMs = 12 * 60 * 60_000, } = {}) {
+    const now = Date.now();
+    for (const [sessionId, runtime] of runtimeSessions) {
+        const running = runtime.session?.isStreaming === true;
+        const lastSeenAt = Number(runtime.lastSeenAt ?? 0);
+        if (!running && lastSeenAt && now - lastSeenAt > maxIdleMs)
+            runtimeSessions.delete(sessionId);
+    }
+    const entries = [...runtimeSessions.entries()];
+    if (entries.length <= maxEntries)
+        return;
+    const removable = entries
+        .filter(([, runtime]) => runtime.session?.isStreaming !== true)
+        .sort(([, a], [, b]) => Number(a.lastSeenAt ?? 0) - Number(b.lastSeenAt ?? 0));
+    for (const [sessionId] of removable.slice(0, Math.max(0, entries.length - maxEntries)))
+        runtimeSessions.delete(sessionId);
+}
+export function persistSessionImmediately(sessionManager) {
+    if (typeof sessionManager._rewriteFile === "function")
+        sessionManager._rewriteFile();
+    sessionManager.flushed = true;
+}
+export function resolveModelFromRegistry(modelRegistry, modelName) {
+    const available = modelRegistry.getAvailable();
+    if (modelName.includes("/")) {
+        const [provider, id] = modelName.split("/", 2);
+        return modelRegistry.find(provider, id);
+    }
+    return (available.find((model) => model.id === modelName) ??
+        available.find((model) => model.id.toLowerCase().includes(modelName.toLowerCase())));
+}
+export function inheritedModelForPolicy(policy, inheritedModel) {
+    if (policy?.model || !inheritedModel?.provider || !inheritedModel?.id)
+        return undefined;
+    return { provider: inheritedModel.provider, id: inheritedModel.id };
+}
+export async function applyInheritedModel(session, policy, inheritedModel) {
+    const modelRef = inheritedModelForPolicy(policy, inheritedModel);
+    if (!modelRef)
+        return undefined;
+    const model = session.modelRegistry.find(modelRef.provider, modelRef.id) ??
+        inheritedModel;
+    if (modelsEqual(session.model, model))
+        return model;
+    await session.setModel(model);
+    return model;
+}
+function modelsEqual(a, b) {
+    return a?.provider === b?.provider && a?.id === b?.id;
+}

package/dist/sessions.d.ts

@@ -0,0 +1,56 @@
+/** Resolves a full id, short id, prefix, substring, or path to one session. */
+export declare function resolveSessionReference(sessions: any, reference: any): any;
+export declare function listSessionSummariesFast(sessionDir: string | undefined): AnyRecord[];
+export declare function cachedPersistedSessions(key: string, load: () => Promise<AnyRecord[]>, maxAgeMs?: number): Promise<any>;
+export declare function warmPersistedSessions(key: string, load: () => Promise<AnyRecord[]>): void;
+export declare function summarizeSession(session: any, options?: AnyRecord): {
+    id: any;
+    sessionId: any;
+    shortId: string;
+    path: any;
+    parentSessionPath: any;
+    name: any;
+    firstMessage: any;
+    lastMessage: any;
+    modified: any;
+    agentName: string;
+};
+export declare function enrichSessionSummary(session: any): any;
+export declare function enrichSessionSummaries(sessions: AnyRecord[], limit?: number): any[];
+/** Orders sessions so every child appears directly under its parent. */
+export declare function orderSessionTree(sessions: any): any[];
+export declare function treeSwitchPath(session: any): any;
+export declare function sessionDiscoveryScope(sessions: AnyRecord[], currentSession: AnyRecord, options?: AnyRecord): any;
+export declare function buildSessionTree(currentSession: AnyRecord | undefined, persistedSessions: AnyRecord[], runtimeSessions?: PiRuntimeSession[], options?: AnyRecord): any[];
+export declare function sessionCompletionScope(sessions: AnyRecord[], currentSession: AnyRecord | undefined, options?: AnyRecord): any[];
+export declare function findSessionSummary(sessions: AnyRecord[], identity?: AnyRecord): AnyRecord;
+/** Keeps the current session plus nearby siblings and branch relatives. */
+export declare function filterSessionNeighborhood(sessions: any, currentSession: any, { rx, ry }?: {
+    rx?: number;
+    ry?: number;
+}): any;
+export declare function orderSessionCompletions(sessions: AnyRecord[], currentSession: AnyRecord | undefined): any[];
+export declare function mergeSessionSummaries(sessions: any): any[];
+export declare function currentSessionSummary(ctx: any): {
+    id: any;
+    sessionId: any;
+    shortId: string;
+    path: any;
+    parentSessionPath: any;
+    agentName: any;
+    lastMessage: any;
+    modified: string;
+};
+export declare function runtimeSessionSummary(runtime: any): {
+    id: any;
+    sessionId: any;
+    shortId: string;
+    path: any;
+    parentSessionPath: any;
+    agentName: any;
+    lastMessage: any;
+    modified: any;
+};
+/** Adds live runtime details without changing persisted session summaries. */
+export declare function withRuntimeState(session: any): any;
+export declare function assignTreeDepths(sessions: any): any;