@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/extensions/session-context.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Event-backed session context for extensions.
+ *
+ * This keeps the read-only shape extensions already use while sourcing data
+ * from EventStore and SessionProjection instead of the legacy JSONL manager.
+ */
+import type { EventBase } from "../event-store/types.js";
+import type { EventStore, SubscribeOptions } from "../event-store/store.js";
+import type { BuildContextOptions, BuiltContext } from "../projection/types.js";
+import type { SessionProjection } from "../projection/session-projection.js";
+import type { SessionManager as ProjectionSessionManager } from "../projection/session-manager.js";
+import type { ReadonlySessionManager, SessionEntry, SessionHeader, SessionTreeNode } from "../types/session-types.js";
+export interface ExtensionSessionManager extends ReadonlySessionManager {
+    /** Present when the session view is backed by EventStore. */
+    readonly eventStore?: EventStore;
+    /** Present when the session view is backed by a SessionProjection. */
+    readonly projection?: SessionProjection;
+    buildContext?: (options?: BuildContextOptions) => BuiltContext;
+    subscribe?: (listener: (event: EventBase) => void, options?: SubscribeOptions) => () => void;
+    /** Split the current session, starting a new one from the current position. */
+    splitSession?: (reason?: string, name?: string) => {
+        session_id: string;
+        already_split?: boolean;
+    } | undefined;
+}
+export interface EventStoreExtensionSessionManagerOptions {
+    store: EventStore;
+    projection: SessionProjection;
+    cwd: string;
+    sessionDir?: string;
+    sessionFile?: string;
+    /** The projection SessionManager for mutation operations (e.g. splitSession). */
+    sessionManager?: ProjectionSessionManager;
+}
+export declare class EventStoreExtensionSessionManager implements ExtensionSessionManager {
+    readonly eventStore: EventStore;
+    readonly projection: SessionProjection;
+    private cwd;
+    private sessionDir;
+    private sessionFile;
+    private sessionManager;
+    constructor(options: EventStoreExtensionSessionManagerOptions);
+    splitSession(reason?: string, name?: string): {
+        session_id: string;
+        already_split?: boolean;
+    } | undefined;
+    getCwd(): string;
+    getSessionDir(): string;
+    getSessionId(): string;
+    getSessionFile(): string;
+    getLeafId(): string;
+    getLeafEntry(): SessionEntry | undefined;
+    getEntry(entryId: string): SessionEntry | undefined;
+    getLabel(entryId: string): string | undefined;
+    getBranch(): SessionEntry[];
+    getHeader(): SessionHeader;
+    getEntries(): SessionEntry[];
+    getTree(): SessionTreeNode[];
+    getSessionName(): string | undefined;
+    buildContext(options?: BuildContextOptions): BuiltContext;
+    subscribe(listener: (event: EventBase) => void, options?: SubscribeOptions): () => void;
+    private getSessionEvents;
+    private eventToEntry;
+    private messageToEntry;
+    private baseEntry;
+    private isSessionEntry;
+}

package/dist/core/extensions/session-context.js

@@ -0,0 +1,272 @@
+/**
+ * Event-backed session context for extensions.
+ *
+ * This keeps the read-only shape extensions already use while sourcing data
+ * from EventStore and SessionProjection instead of the legacy JSONL manager.
+ */
+import { eventToMessage } from "../projection/event-to-message.js";
+export class EventStoreExtensionSessionManager {
+    constructor(options) {
+        this.eventStore = options.store;
+        this.projection = options.projection;
+        this.cwd = options.cwd;
+        this.sessionManager = options.sessionManager;
+        const descriptor = options.projection.getDescriptor();
+        this.sessionDir = options.sessionDir ?? options.cwd;
+        this.sessionFile = options.sessionFile ?? `event-session:${descriptor.session_id}`;
+    }
+    splitSession(reason, name) {
+        if (!this.sessionManager)
+            return undefined;
+        // Guard against redundant splits. If the most recent boundary event
+        // came after the most recent USER_MESSAGE, the session was just split
+        // (e.g. by a previous split within the same turn). Splitting again
+        // would only produce empty sessions and can cause the model to loop.
+        const recentUserMessages = this.eventStore.query({
+            reverse: true,
+            types: ["USER_MESSAGE"],
+        });
+        const recentBoundaries = this.eventStore.query({
+            reverse: true,
+            types: ["SESSION_BOUNDARY_INFERRED"],
+        });
+        const lastUserMsgSeq = recentUserMessages[0]?.sequence;
+        const lastBoundarySeq = recentBoundaries[0]?.sequence;
+        if (lastBoundarySeq !== undefined && lastUserMsgSeq !== undefined && lastBoundarySeq > lastUserMsgSeq) {
+            const activeId = this.sessionManager.getActiveSessionId();
+            return { session_id: activeId, already_split: true };
+        }
+        // Find the most recent USER_MESSAGE — the new session should start from
+        // there so the model retains the current user request in context.
+        // query({ after }) is exclusive (sequence > ?), so we need the event
+        // immediately BEFORE the USER_MESSAGE as startEventId.
+        const userMessageId = recentUserMessages[0]?.event_id;
+        let startEventId;
+        if (userMessageId) {
+            const beforeUserMessage = this.eventStore.query({
+                before: userMessageId,
+                reverse: true,
+                limit: 1,
+            });
+            // If there's an event before USER_MESSAGE, use it as the exclusive
+            // start boundary. If USER_MESSAGE is the first event, use "ORIGIN"
+            // so the query includes everything from the beginning.
+            startEventId = beforeUserMessage[0]?.event_id ?? "ORIGIN";
+        }
+        const desc = this.sessionManager.createSession("auto_inferred", name, {
+            startEventId,
+        });
+        this.eventStore.append({
+            actor_id: "runtime",
+            type: "SESSION_BOUNDARY_INFERRED",
+            payload: {
+                reason: reason ?? "intent_shift",
+                new_session_id: desc.session_id,
+            },
+            thread_id: desc.thread_id,
+        });
+        return { session_id: desc.session_id };
+    }
+    getCwd() {
+        return this.cwd;
+    }
+    getSessionDir() {
+        return this.sessionDir;
+    }
+    getSessionId() {
+        return this.projection.getDescriptor().session_id;
+    }
+    getSessionFile() {
+        return this.sessionFile;
+    }
+    getLeafId() {
+        return this.getLeafEntry()?.id ?? this.projection.getDescriptor().event_range.start_event_id;
+    }
+    getLeafEntry() {
+        return this.getEntries().at(-1);
+    }
+    getEntry(entryId) {
+        return this.getEntries().find((entry) => entry.id === entryId);
+    }
+    getLabel(entryId) {
+        let label;
+        for (const entry of this.getEntries()) {
+            if (entry.type === "label" && entry.targetId === entryId) {
+                label = entry.label;
+            }
+        }
+        return label;
+    }
+    getBranch() {
+        return this.getEntries();
+    }
+    getHeader() {
+        const descriptor = this.projection.getDescriptor();
+        return {
+            type: "session",
+            id: descriptor.session_id,
+            timestamp: new Date(descriptor.created_at).toISOString(),
+            cwd: this.cwd,
+            parentSession: descriptor.parent_session_id,
+        };
+    }
+    getEntries() {
+        return this.getSessionEvents()
+            .map((event) => this.eventToEntry(event))
+            .filter((entry) => entry !== undefined);
+    }
+    getTree() {
+        const nodes = new Map();
+        const roots = [];
+        for (const entry of this.getEntries()) {
+            const node = { entry, children: [] };
+            nodes.set(entry.id, node);
+            if (entry.parentId && nodes.has(entry.parentId)) {
+                nodes.get(entry.parentId).children.push(node);
+            }
+            else {
+                roots.push(node);
+            }
+        }
+        return roots;
+    }
+    getSessionName() {
+        let name = this.projection.getDescriptor().name;
+        for (const entry of this.getEntries()) {
+            if (entry.type === "session_info") {
+                name = entry.name;
+            }
+        }
+        return name;
+    }
+    buildContext(options) {
+        return this.projection.buildContext(options);
+    }
+    subscribe(listener, options) {
+        return this.eventStore.subscribe(listener, options);
+    }
+    getSessionEvents() {
+        const descriptor = this.projection.getDescriptor();
+        return this.eventStore.query({
+            after: descriptor.event_range.start_event_id === "ORIGIN" ? undefined : descriptor.event_range.start_event_id,
+            before: descriptor.event_range.end_event_id === "HEAD" ? undefined : descriptor.event_range.end_event_id,
+            reverse: false,
+        });
+    }
+    eventToEntry(event) {
+        if (event.type === "SESSION_ENTRY_APPENDED") {
+            const payload = event.payload;
+            if (this.isSessionEntry(payload.entry))
+                return payload.entry;
+        }
+        if (event.type === "MODEL_CHANGED") {
+            const payload = event.payload;
+            const entry = {
+                ...this.baseEntry(event),
+                type: "model_change",
+                provider: payload.provider,
+                modelId: payload.model_id,
+            };
+            return entry;
+        }
+        if (event.type === "THINKING_LEVEL_CHANGED") {
+            const payload = event.payload;
+            const entry = {
+                ...this.baseEntry(event),
+                type: "thinking_level_change",
+                thinkingLevel: payload.level,
+            };
+            return entry;
+        }
+        if (event.type === "COMPACTION_END") {
+            const payload = event.payload;
+            const entry = {
+                ...this.baseEntry(event),
+                type: "compaction",
+                summary: payload.summary,
+                firstKeptEntryId: payload.first_kept_event_id,
+                tokensBefore: payload.tokens_before,
+            };
+            return entry;
+        }
+        if (event.type === "BRANCH_SUMMARY") {
+            const payload = event.payload;
+            const entry = {
+                ...this.baseEntry(event),
+                type: "branch_summary",
+                fromId: payload.from_id ?? event.caused_by ?? event.event_id,
+                summary: payload.summary,
+            };
+            return entry;
+        }
+        if (event.type === "CUSTOM_MESSAGE") {
+            const payload = event.payload;
+            const entry = {
+                ...this.baseEntry(event),
+                type: "custom_message",
+                customType: payload.kind,
+                content: typeof payload.data === "string" ? payload.data : JSON.stringify(payload.data),
+                details: payload.data,
+                display: payload.display !== false,
+            };
+            return entry;
+        }
+        const message = eventToMessage(event);
+        if (!message)
+            return undefined;
+        return this.messageToEntry(event, message);
+    }
+    messageToEntry(event, message) {
+        if (message.role === "compactionSummary") {
+            const entry = {
+                ...this.baseEntry(event),
+                type: "compaction",
+                summary: message.summary,
+                firstKeptEntryId: event.event_id,
+                tokensBefore: message.tokensBefore,
+            };
+            return entry;
+        }
+        if (message.role === "branchSummary") {
+            const entry = {
+                ...this.baseEntry(event),
+                type: "branch_summary",
+                fromId: message.fromId ?? event.caused_by ?? event.event_id,
+                summary: message.summary,
+            };
+            return entry;
+        }
+        if (message.role === "custom") {
+            const entry = {
+                ...this.baseEntry(event),
+                type: "custom_message",
+                customType: message.customType,
+                content: message.content,
+                details: message.details,
+                display: message.display !== false,
+            };
+            return entry;
+        }
+        const entry = {
+            ...this.baseEntry(event),
+            type: "message",
+            message,
+        };
+        return entry;
+    }
+    baseEntry(event) {
+        return {
+            id: event.event_id,
+            parentId: event.caused_by ?? null,
+            timestamp: new Date(event.timestamp).toISOString(),
+        };
+    }
+    isSessionEntry(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "type" in value &&
+            "id" in value &&
+            "parentId" in value &&
+            "timestamp" in value);
+    }
+}