@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/projection/session-manager.js

@@ -0,0 +1,331 @@
+/**
+ * Session Manager (Event-Sourced)
+ *
+ * Manages session descriptors, not session data.
+ * Data lives in EventStore. Session is just a query view.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { SessionProjection } from "./session-projection.js";
+import { SessionBoundaryInferrer } from "./boundary-inferrer.js";
+import { getSessionIndexPath } from "../event-store/workspace.js";
+// ============================================================================
+// Session Manager
+// ============================================================================
+/**
+ * SessionManager - manages session descriptors only.
+ *
+ * Storage: ~/.pizza/agent/workspaces/<workspace_id>/sessions.json
+ *
+ * Does NOT store messages. Tree structure emerges from EventStore's caused_by chain.
+ */
+export class SessionManager {
+    constructor(store, storagePath) {
+        this.store = store;
+        this.threads = new Map();
+        this.sessions = new Map();
+        this.inferrer = new SessionBoundaryInferrer();
+        this.filePath = storagePath === ":memory:" ? undefined : (storagePath ?? getSessionIndexPath(store.workspace_id));
+        if (this.filePath) {
+            this._ensureStorageDir();
+            this._loadIndex();
+        }
+        this._subscribeToEvents();
+    }
+    // =========================================================================
+    // Session Operations
+    // =========================================================================
+    /**
+     * Get or create the active session.
+     */
+    getActiveSession() {
+        if (!this.activeThreadId) {
+            this.createThread();
+        }
+        if (!this.activeSessionId) {
+            this.createSession("user_explicit", undefined, { threadId: this.activeThreadId });
+        }
+        const desc = this.sessions.get(this.activeSessionId);
+        return new SessionProjection(this.store, desc);
+    }
+    /**
+     * Create a new session.
+     */
+    createSession(created_by, name, options = {}) {
+        const threadId = options.threadId ?? this.activeThreadId ?? this._createThreadRecord().thread_id;
+        const previousActiveId = options.closeActive !== false ? this.activeSessionId : undefined;
+        const desc = {
+            session_id: this._generateSessionId(),
+            thread_id: threadId,
+            workspace_id: this.store.workspace_id,
+            event_range: {
+                start_event_id: options.startEventId ?? this.store.head ?? "ORIGIN",
+                end_event_id: "HEAD",
+            },
+            summary_event_id: options.summaryEventId,
+            name,
+            created_by,
+            parent_session_id: options.parentSessionId,
+            created_at: Date.now(),
+        };
+        this.sessions.set(desc.session_id, desc);
+        this.activeSessionId = desc.session_id;
+        // Emit session created event
+        const createdEvent = this.store.append({
+            actor_id: "runtime",
+            type: "SESSION_CREATED",
+            payload: { session_id: desc.session_id, name, created_by },
+            thread_id: desc.thread_id,
+        });
+        const previousActive = previousActiveId ? this.sessions.get(previousActiveId) : undefined;
+        if (previousActive && previousActive.thread_id === threadId && previousActive.event_range.end_event_id === "HEAD") {
+            previousActive.event_range.end_event_id = createdEvent.event_id;
+        }
+        this._persistIndex();
+        return desc;
+    }
+    /**
+     * Fork the current session at a specific event.
+     */
+    forkAt(event_id) {
+        const active = this.getActiveSession();
+        const forked = active.fork(event_id);
+        this.sessions.set(forked.session_id, forked);
+        this.activeSessionId = forked.session_id;
+        this._persistIndex();
+        this.store.append({
+            actor_id: "runtime",
+            type: "SESSION_FORKED",
+            payload: {
+                new_session_id: forked.session_id,
+                parent_session_id: forked.parent_session_id,
+                fork_at_event_id: event_id,
+            },
+            thread_id: forked.thread_id,
+        });
+        return forked;
+    }
+    /**
+     * Fork an existing session while preserving its projected history.
+     *
+     * The source session is frozen at the current head if it was tracking HEAD,
+     * and the forked descriptor reuses the source start boundary so context still
+     * includes the source conversation.
+     */
+    forkFromSession(session_id) {
+        const source = this.sessions.get(session_id);
+        if (!source) {
+            throw new Error(`Session not found: ${session_id}`);
+        }
+        const forkAtEventId = source.event_range.end_event_id === "HEAD"
+            ? this.store.head ?? source.event_range.start_event_id
+            : source.event_range.end_event_id;
+        if (source.event_range.end_event_id === "HEAD") {
+            this.activeSessionId = source.session_id;
+        }
+        const forked = this.createSession("fork", source.name, {
+            parentSessionId: source.session_id,
+            startEventId: source.event_range.start_event_id,
+            summaryEventId: source.summary_event_id,
+        });
+        this.store.append({
+            actor_id: "runtime",
+            type: "SESSION_FORKED",
+            payload: {
+                new_session_id: forked.session_id,
+                parent_session_id: source.session_id,
+                fork_at_event_id: forkAtEventId,
+            },
+            thread_id: forked.thread_id,
+        });
+        return forked;
+    }
+    /**
+     * List all sessions.
+     */
+    listSessions() {
+        return Array.from(this.sessions.values()).sort((a, b) => b.created_at - a.created_at);
+    }
+    /**
+     * Switch to a different session.
+     */
+    switchTo(session_id) {
+        if (!this.sessions.has(session_id)) {
+            throw new Error(`Session not found: ${session_id}`);
+        }
+        this.activeSessionId = session_id;
+        this._persistIndex();
+    }
+    /**
+     * Get a session by ID.
+     */
+    getSession(session_id) {
+        return this.sessions.get(session_id);
+    }
+    /**
+     * Get session projection by ID.
+     */
+    getSessionProjection(session_id) {
+        const desc = this.sessions.get(session_id);
+        if (!desc)
+            return undefined;
+        return new SessionProjection(this.store, desc);
+    }
+    /**
+     * Update session name.
+     */
+    renameSession(session_id, name) {
+        const desc = this.sessions.get(session_id);
+        if (!desc)
+            return;
+        desc.name = name;
+        this._persistIndex();
+    }
+    /**
+     * Get the active session ID.
+     */
+    getActiveSessionId() {
+        return this.activeSessionId;
+    }
+    getActiveThreadId() {
+        return this.activeThreadId;
+    }
+    getActiveThread() {
+        return this.activeThreadId ? this.threads.get(this.activeThreadId) : undefined;
+    }
+    /**
+     * Create a new thread (conversation). Threads are the isolation unit —
+     * events are tagged with thread_id. Creates the first session in the thread.
+     * Threads are fixed once created; auto-splitting happens at session level.
+     */
+    createThread(name) {
+        const thread = this._createThreadRecord(name);
+        this.createSession("user_explicit", name, { threadId: thread.thread_id });
+        this._persistIndex();
+        return thread;
+    }
+    /**
+     * Dispose the session manager.
+     */
+    dispose() {
+        this.unsubscribe?.();
+    }
+    // =========================================================================
+    // Internal Methods
+    // =========================================================================
+    _subscribeToEvents() {
+        this.unsubscribe = this.store.subscribe((event) => {
+            if (event.type === "USER_MESSAGE") {
+                this._evaluateBoundary(event);
+            }
+        }, { types: ["USER_MESSAGE"] });
+    }
+    _evaluateBoundary(event) {
+        if (!this.activeSessionId)
+            return;
+        const current = this.sessions.get(this.activeSessionId);
+        if (!current)
+            return;
+        // Only evaluate if we're at HEAD
+        if (current.event_range.end_event_id !== "HEAD")
+            return;
+        const recent = this._getRecentEventsBefore(event, current);
+        const decision = this.inferrer.evaluate(recent, event);
+        if (decision.should_split) {
+            const lastEventBeforeSplit = recent[recent.length - 1];
+            // End the current session before the triggering message.
+            // EventStore range queries use exclusive end boundaries.
+            current.event_range.end_event_id = event.event_id;
+            // Start the inferred session after the previous event so the triggering
+            // message becomes the first user-visible message in the new view.
+            this.createSession("auto_inferred", decision.suggested_name, {
+                startEventId: lastEventBeforeSplit?.event_id ?? current.event_range.start_event_id,
+            });
+            this.store.append({
+                actor_id: "runtime",
+                type: "SESSION_BOUNDARY_INFERRED",
+                payload: {
+                    reason: decision.reason,
+                    new_session_id: this.activeSessionId,
+                },
+                caused_by: event.event_id,
+                thread_id: this.activeThreadId,
+            });
+        }
+    }
+    _getRecentEventsBefore(event, current) {
+        const query = {
+            before_sequence: event.sequence,
+            limit: 20,
+            reverse: true,
+        };
+        if (current.event_range.start_event_id !== "ORIGIN") {
+            query.after = current.event_range.start_event_id;
+        }
+        return this.store.query(query).filter((e) => !e.thread_id || e.thread_id === current.thread_id).reverse();
+    }
+    _ensureStorageDir() {
+        if (!this.filePath)
+            return;
+        const dir = this.filePath.substring(0, this.filePath.lastIndexOf("/"));
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    _loadIndex() {
+        if (!this.filePath)
+            return;
+        if (!existsSync(this.filePath))
+            return;
+        try {
+            const content = readFileSync(this.filePath, "utf8");
+            const index = JSON.parse(content);
+            for (const thread of index.threads ?? []) {
+                this.threads.set(thread.thread_id, thread);
+                if (thread.status === "active") {
+                    this.activeThreadId = thread.thread_id;
+                }
+            }
+            for (const session of index.sessions) {
+                this.sessions.set(session.session_id, session);
+                if (session.event_range.end_event_id === "HEAD" && session.thread_id === this.activeThreadId) {
+                    this.activeSessionId = session.session_id;
+                }
+            }
+        }
+        catch {
+            // Start fresh if corrupted
+        }
+    }
+    _persistIndex() {
+        if (!this.filePath)
+            return;
+        const index = {
+            threads: Array.from(this.threads.values()),
+            sessions: Array.from(this.sessions.values()),
+        };
+        writeFileSync(this.filePath, JSON.stringify(index, null, 2));
+    }
+    _generateSessionId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).slice(2, 10);
+        return `sess_${timestamp}_${random}`;
+    }
+    /** Create a thread record (no session). Used by createThread and createSession's auto-thread fallback. */
+    _createThreadRecord(name) {
+        const thread = {
+            thread_id: this._generateThreadId(),
+            workspace_id: this.store.workspace_id,
+            name,
+            created_at: Date.now(),
+            status: "active",
+        };
+        this.threads.set(thread.thread_id, thread);
+        this.activeThreadId = thread.thread_id;
+        return thread;
+    }
+    _generateThreadId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).slice(2, 10);
+        return `thread_${timestamp}_${random}`;
+    }
+}

package/dist/core/projection/session-projection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Session Projection
+ *
+ * Session is a query view over EventStore, not a data holder.
+ * Builds LLM context from event queries.
+ */
+import type { EventStore } from "../event-store/store.js";
+import type { SessionDescriptor, BuildContextOptions, BuiltContext } from "./types.js";
+import type { TimelineEntry } from "./timeline-projection.js";
+/**
+ * SessionProjection builds LLM context from EventStore queries.
+ *
+ * Session is a projection/view over events, not a data holder.
+ * Multiple sessions can coexist - same events can belong to multiple session views.
+ */
+export declare class SessionProjection {
+    private store;
+    private descriptor;
+    constructor(store: EventStore, descriptor: SessionDescriptor);
+    /**
+     * Build LLM-usable context message list.
+     *
+     * Logic:
+     * 1. Query all context-relevant events from event_range
+     * 2. If summary_event_id exists, inject compaction summary first
+     * 3. Convert events to AgentMessage[] format
+     * 4. Apply token budget truncation if needed
+     */
+    buildContext(options?: BuildContextOptions): BuiltContext;
+    /**
+     * Get timeline view for UI display.
+     *
+     * Returns all events in the session's event range, ordered by time.
+     */
+    getTimeline(): TimelineEntry[];
+    /**
+     * Get the session descriptor.
+     */
+    getDescriptor(): SessionDescriptor;
+    /**
+     * Update the session descriptor.
+     */
+    updateDescriptor(updates: Partial<SessionDescriptor>): void;
+    /**
+     * Fork: create new session descriptor from a specific event.
+     */
+    fork(at_event_id: string): SessionDescriptor;
+    /**
+     * Get effective start event_id (ORIGIN if not set).
+     */
+    getEffectiveStart(): string;
+    private _getEventRange;
+    private _applyCompactionBoundary;
+    private _summarizeEvent;
+    private _truncateByTokens;
+    private _eventTypeToKind;
+    private _generateSessionId;
+}

package/dist/core/projection/session-projection.js

@@ -0,0 +1,257 @@
+/**
+ * Session Projection
+ *
+ * Session is a query view over EventStore, not a data holder.
+ * Builds LLM context from event queries.
+ */
+import { eventsToMessages } from "./event-to-message.js";
+// ============================================================================
+// Constants
+// ============================================================================
+/** Event types that participate in LLM context */
+const CONTEXT_RELEVANT_EVENT_TYPES = [
+    "USER_MESSAGE",
+    "AGENT_MESSAGE_END",
+    "TOOL_EXECUTION_END",
+    "COMPACTION_END",
+    "FILE_MUTATION_APPLIED",
+    "BASH_EXECUTION",
+    "CUSTOM_MESSAGE",
+    "BRANCH_SUMMARY",
+];
+// ============================================================================
+// Session Projection
+// ============================================================================
+/**
+ * SessionProjection builds LLM context from EventStore queries.
+ *
+ * Session is a projection/view over events, not a data holder.
+ * Multiple sessions can coexist - same events can belong to multiple session views.
+ */
+export class SessionProjection {
+    constructor(store, descriptor) {
+        this.store = store;
+        this.descriptor = descriptor;
+    }
+    /**
+     * Build LLM-usable context message list.
+     *
+     * Logic:
+     * 1. Query all context-relevant events from event_range
+     * 2. If summary_event_id exists, inject compaction summary first
+     * 3. Convert events to AgentMessage[] format
+     * 4. Apply token budget truncation if needed
+     */
+    buildContext(options) {
+        const { start, end } = this._getEventRange();
+        const rawEvents = this.store.query({
+            after: start,
+            before: end,
+            types: CONTEXT_RELEVANT_EVENT_TYPES,
+        }).filter((e) => !e.thread_id || e.thread_id === this.descriptor.thread_id);
+        const events = this._applyCompactionBoundary(rawEvents);
+        let messages = eventsToMessages(events);
+        // Inject compaction summary if present
+        if (this.descriptor.summary_event_id) {
+            const summaryAlreadyInRange = events.some((event) => event.event_id === this.descriptor.summary_event_id);
+            const summaryEvent = this.store.get(this.descriptor.summary_event_id);
+            if (!summaryAlreadyInRange && summaryEvent && summaryEvent.type === "COMPACTION_END") {
+                const summaryPayload = summaryEvent.payload;
+                // Use compactionSummary message type
+                messages.unshift({
+                    role: "compactionSummary",
+                    summary: summaryPayload.summary,
+                    tokensBefore: summaryPayload.tokens_before,
+                    timestamp: summaryEvent.timestamp,
+                });
+            }
+        }
+        // Apply token budget if specified
+        if (options?.max_tokens) {
+            messages = this._truncateByTokens(messages, options.max_tokens);
+        }
+        return { messages, events, descriptor: this.descriptor };
+    }
+    /**
+     * Get timeline view for UI display.
+     *
+     * Returns all events in the session's event range, ordered by time.
+     */
+    getTimeline() {
+        const { start, end } = this._getEventRange();
+        const events = this.store.query({
+            after: start,
+            before: end,
+            reverse: false,
+        }).filter((e) => !e.thread_id || e.thread_id === this.descriptor.thread_id);
+        return events.map((e) => ({
+            event_id: e.event_id,
+            kind: this._eventTypeToKind(e.type),
+            actor_id: e.actor_id,
+            timestamp: e.timestamp,
+            summary: this._summarizeEvent(e),
+            caused_by: e.caused_by,
+        }));
+    }
+    /**
+     * Get the session descriptor.
+     */
+    getDescriptor() {
+        return this.descriptor;
+    }
+    /**
+     * Update the session descriptor.
+     */
+    updateDescriptor(updates) {
+        Object.assign(this.descriptor, updates);
+    }
+    /**
+     * Fork: create new session descriptor from a specific event.
+     */
+    fork(at_event_id) {
+        return {
+            session_id: this._generateSessionId(),
+            thread_id: this.descriptor.thread_id,
+            workspace_id: this.store.workspace_id,
+            event_range: {
+                start_event_id: at_event_id,
+                end_event_id: "HEAD",
+            },
+            created_by: "fork",
+            parent_session_id: this.descriptor.session_id,
+            created_at: Date.now(),
+        };
+    }
+    /**
+     * Get effective start event_id (ORIGIN if not set).
+     */
+    getEffectiveStart() {
+        return this.descriptor.event_range.start_event_id;
+    }
+    // =========================================================================
+    // Private Methods
+    // =========================================================================
+    _getEventRange() {
+        const start = this.descriptor.event_range.start_event_id === "ORIGIN" ? undefined : this.descriptor.event_range.start_event_id;
+        const end = this.descriptor.event_range.end_event_id === "HEAD" ? undefined : this.descriptor.event_range.end_event_id;
+        return { start, end };
+    }
+    _applyCompactionBoundary(events) {
+        let latestCompaction;
+        for (const event of events) {
+            if (event.type === "COMPACTION_END") {
+                latestCompaction = event;
+            }
+        }
+        if (!latestCompaction)
+            return events;
+        const payload = latestCompaction.payload;
+        const firstKept = payload.first_kept_event_id ? this.store.get(payload.first_kept_event_id) : undefined;
+        const firstKeptSequence = firstKept?.sequence ?? latestCompaction.sequence + 1;
+        return [
+            latestCompaction,
+            ...events.filter((event) => event.type !== "COMPACTION_END" && event.sequence >= firstKeptSequence),
+        ];
+    }
+    _summarizeEvent(event) {
+        switch (event.type) {
+            case "USER_MESSAGE": {
+                const payload = event.payload;
+                const content = typeof payload.content === "string" ? payload.content : "[Content]";
+                return `User: ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}`;
+            }
+            case "AGENT_MESSAGE_END": {
+                const payload = event.payload;
+                return `Agent (stop: ${payload.stop_reason})`;
+            }
+            case "TOOL_EXECUTION_END": {
+                const payload = event.payload;
+                return `${payload.is_error ? "❌" : "✓"} ${payload.tool_name}`;
+            }
+            case "COMPACTION_END":
+                return "📋 Compaction summary applied";
+            case "SESSION_CREATED": {
+                const payload = event.payload;
+                return `Session created: ${payload.name ?? payload.created_by}`;
+            }
+            case "SESSION_FORKED": {
+                const payload = event.payload;
+                return `Forked to new session`;
+            }
+            default:
+                return event.type;
+        }
+    }
+    _truncateByTokens(messages, maxTokens) {
+        // Simple truncation: keep recent messages up to token limit
+        // In production, use proper token counting
+        const estimatedTokensPerMessage = 100; // rough estimate
+        const maxMessages = Math.floor(maxTokens / estimatedTokensPerMessage);
+        if (messages.length <= maxMessages) {
+            return messages;
+        }
+        // Keep system-equivalent messages + most recent messages
+        const systemMessages = messages.filter((m) => m.role === "compactionSummary" || m.role === "branchSummary");
+        const otherMessages = messages.filter((m) => m.role !== "compactionSummary" && m.role !== "branchSummary");
+        const recentMessages = otherMessages.slice(-maxMessages);
+        return [...systemMessages, ...recentMessages];
+    }
+    _eventTypeToKind(type) {
+        switch (type) {
+            case "USER_MESSAGE":
+                return "user_message";
+            case "AGENT_MESSAGE_START":
+            case "AGENT_MESSAGE_CHUNK":
+            case "AGENT_MESSAGE_END":
+                return "agent_message";
+            case "TOOL_EXECUTION_START":
+            case "TOOL_EXECUTION_UPDATE":
+            case "TOOL_EXECUTION_END":
+                return "tool_execution";
+            case "FILE_MUTATION_APPLIED":
+                return "file_mutation";
+            case "GOAL_CREATED":
+            case "GOAL_CLASSIFIED":
+            case "GOAL_PLANNED":
+            case "GOAL_PAUSED":
+            case "GOAL_RESUMED":
+            case "GOAL_COMPLETED":
+            case "GOAL_CANCELLED":
+                return "goal_event";
+            case "TASK_CREATED":
+            case "TASK_ASSIGNED":
+            case "TASK_STARTED":
+            case "TASK_PROGRESS":
+            case "TASK_COMPLETED":
+            case "TASK_FAILED":
+            case "TASK_REWORK_REQUESTED":
+            case "TASK_ACCEPTED":
+            case "TASK_CANCELLED":
+                return "task_event";
+            case "SESSION_CREATED":
+            case "SESSION_BOUNDARY_INFERRED":
+            case "SESSION_FORKED":
+                return "session_boundary";
+            case "COMPACTION_REQUESTED":
+            case "COMPACTION_START":
+            case "COMPACTION_END":
+            case "COMPACTION_ABORTED":
+                return "compaction";
+            case "AGENT_ERROR":
+            case "RUNTIME_ERROR":
+                return "error";
+            case "CHECKPOINT_CREATED":
+            case "CHECKPOINT_RESTORED":
+            case "CHECKPOINT_FAILED":
+                return "checkpoint";
+            default:
+                return "agent_message";
+        }
+    }
+    _generateSessionId() {
+        // Use UUIDv7-like format
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).slice(2, 10);
+        return `sess_${timestamp}_${random}`;
+    }
+}

package/dist/core/projection/task-history.d.ts

@@ -0,0 +1,13 @@
+import type { EventType } from "../event-store/types.js";
+import type { TaskDescriptor, TaskStatus } from "../goal/types.js";
+import type { GoalProjection } from "./goal-projection.js";
+export declare const TASK_HISTORY_EVENT_TYPES: EventType[];
+export interface TaskHistoryItem {
+    task_id: string;
+    status: TaskStatus;
+    title: string;
+    summary: string;
+    updated_at: number;
+}
+export declare function buildRecentTaskHistory(projection: Pick<GoalProjection, "listTasks">, limit?: number): TaskHistoryItem[];
+export declare function summarizeTask(task: TaskDescriptor): string;