@tomsun28/pizza 0.0.9 → 0.1.1

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

@@ -0,0 +1,339 @@
+/**
+ * Goal Projection
+ *
+ * Derives goal and task state by scanning events from the EventStore.
+ * A projection is a read-only view — it can be rebuilt at any time
+ * by replaying the event log.
+ */
+// ============================================================================
+// Goal Projection
+// ============================================================================
+/**
+ * GoalProjection derives current goal and task state from the EventStore.
+ *
+ * Usage:
+ *   const projection = new GoalProjection(store);
+ *   projection.rebuild(); // scan all events
+ *   const goals = projection.listGoals();
+ *   const tasks = projection.getTasksForGoal(goalId);
+ */
+export class GoalProjection {
+    constructor(store) {
+        this.store = store;
+        this.goals = new Map();
+        this.tasks = new Map();
+    }
+    /**
+     * Rebuild the projection from scratch by scanning all events.
+     */
+    rebuild() {
+        this.goals.clear();
+        this.tasks.clear();
+        const events = this.store.query({
+            types: [
+                "GOAL_CREATED",
+                "GOAL_CLASSIFIED",
+                "GOAL_PLANNED",
+                "GOAL_PAUSED",
+                "GOAL_RESUMED",
+                "GOAL_COMPLETED",
+                "GOAL_CANCELLED",
+                "TASK_CREATED",
+                "TASK_ASSIGNED",
+                "TASK_STARTED",
+                "TASK_PROGRESS",
+                "TASK_COMPLETED",
+                "TASK_FAILED",
+                "TASK_REWORK_REQUESTED",
+                "TASK_ACCEPTED",
+                "TASK_CANCELLED",
+            ],
+        });
+        for (const event of events) {
+            this._applyEvent(event);
+        }
+    }
+    /**
+     * Start live-updating the projection by subscribing to new events.
+     */
+    startLive() {
+        if (this.unsubscribe)
+            return;
+        this.unsubscribe = this.store.subscribe((event) => this._applyEvent(event), {
+            types: [
+                "GOAL_CREATED",
+                "GOAL_CLASSIFIED",
+                "GOAL_PLANNED",
+                "GOAL_PAUSED",
+                "GOAL_RESUMED",
+                "GOAL_COMPLETED",
+                "GOAL_CANCELLED",
+                "TASK_CREATED",
+                "TASK_ASSIGNED",
+                "TASK_STARTED",
+                "TASK_PROGRESS",
+                "TASK_COMPLETED",
+                "TASK_FAILED",
+                "TASK_REWORK_REQUESTED",
+                "TASK_ACCEPTED",
+                "TASK_CANCELLED",
+            ],
+        });
+    }
+    /**
+     * Stop live updates.
+     */
+    stopLive() {
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+    }
+    // =========================================================================
+    // Queries
+    // =========================================================================
+    /** Get all goals */
+    listGoals() {
+        return [...this.goals.values()];
+    }
+    /** Get active (non-terminal) goals */
+    listActiveGoals() {
+        return this.listGoals().filter((g) => g.status !== "completed" && g.status !== "cancelled");
+    }
+    /** Get a specific goal */
+    getGoal(goalId) {
+        return this.goals.get(goalId);
+    }
+    /** Get all tasks for a goal */
+    getTasksForGoal(goalId) {
+        return [...this.tasks.values()].filter((t) => t.goal_id === goalId);
+    }
+    /** Get all tasks */
+    listTasks() {
+        return [...this.tasks.values()];
+    }
+    /** Get a specific task */
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    /** Get tasks that are ready to start (all dependencies completed/accepted) */
+    getReadyTasks(goalId) {
+        const goalTasks = this.getTasksForGoal(goalId);
+        return goalTasks.filter((task) => {
+            if (task.status !== "created")
+                return false;
+            return task.depends_on.every((depId) => {
+                const dep = this.tasks.get(depId);
+                return dep && (dep.status === "completed" || dep.status === "accepted");
+            });
+        });
+    }
+    /** Get tasks blocked by dependencies */
+    getBlockedTasks(goalId) {
+        const goalTasks = this.getTasksForGoal(goalId);
+        return goalTasks.filter((task) => {
+            if (task.status !== "created")
+                return false;
+            return task.depends_on.some((depId) => {
+                const dep = this.tasks.get(depId);
+                return !dep || (dep.status !== "completed" && dep.status !== "accepted");
+            });
+        });
+    }
+    // =========================================================================
+    // Event Application
+    // =========================================================================
+    _applyEvent(event) {
+        switch (event.type) {
+            case "GOAL_CREATED":
+                this._onGoalCreated(event);
+                break;
+            case "GOAL_CLASSIFIED":
+                this._onGoalClassified(event);
+                break;
+            case "GOAL_PLANNED":
+                this._onGoalPlanned(event);
+                break;
+            case "GOAL_PAUSED":
+                this._onGoalStatusChange(event, "paused");
+                break;
+            case "GOAL_RESUMED":
+                this._onGoalStatusChange(event, "running");
+                break;
+            case "GOAL_COMPLETED":
+                this._onGoalStatusChange(event, "completed");
+                break;
+            case "GOAL_CANCELLED":
+                this._onGoalStatusChange(event, "cancelled");
+                break;
+            case "TASK_CREATED":
+                this._onTaskCreated(event);
+                break;
+            case "TASK_ASSIGNED":
+                this._onTaskAssigned(event);
+                break;
+            case "TASK_STARTED":
+                this._onTaskStarted(event);
+                break;
+            case "TASK_PROGRESS":
+                this._onTaskProgress(event);
+                break;
+            case "TASK_COMPLETED":
+                this._onTaskCompleted(event);
+                break;
+            case "TASK_FAILED":
+                this._onTaskFailed(event);
+                break;
+            case "TASK_REWORK_REQUESTED":
+                this._onTaskRework(event);
+                break;
+            case "TASK_ACCEPTED":
+                this._onTaskStatusChange(event, "accepted");
+                break;
+            case "TASK_CANCELLED":
+                this._onTaskCancelled(event);
+                break;
+        }
+    }
+    _onGoalCreated(event) {
+        const payload = event.payload;
+        this.goals.set(payload.goal_id, {
+            goal_id: payload.goal_id,
+            workspace_id: event.workspace_id,
+            status: "created",
+            title: payload.title,
+            description: payload.description,
+            root_event_id: event.event_id,
+            task_ids: [],
+            created_at: event.timestamp,
+            updated_at: event.timestamp,
+        });
+    }
+    _onGoalClassified(event) {
+        const payload = event.payload;
+        const goal = this.goals.get(payload.goal_id);
+        if (!goal)
+            return;
+        goal.status = "classified";
+        goal.classification = payload.classification;
+        goal.updated_at = event.timestamp;
+    }
+    _onGoalPlanned(event) {
+        const payload = event.payload;
+        const goal = this.goals.get(payload.goal_id);
+        if (!goal)
+            return;
+        goal.status = "planned";
+        goal.task_ids = payload.task_ids;
+        goal.acceptance_criteria = payload.acceptance_criteria;
+        goal.updated_at = event.timestamp;
+    }
+    _onGoalStatusChange(event, status) {
+        const payload = event.payload;
+        const goal = this.goals.get(payload.goal_id);
+        if (!goal)
+            return;
+        goal.status = status;
+        goal.updated_at = event.timestamp;
+    }
+    _onTaskCreated(event) {
+        const payload = event.payload;
+        this.tasks.set(payload.task_id, {
+            task_id: payload.task_id,
+            goal_id: payload.goal_id,
+            status: "created",
+            title: payload.title,
+            description: payload.description,
+            priority: payload.priority,
+            depends_on: payload.depends_on ?? [],
+            root_event_id: event.event_id,
+            acceptance_criteria: payload.acceptance_criteria,
+            progress_notes: [],
+            created_at: event.timestamp,
+            updated_at: event.timestamp,
+        });
+        // Also add to goal's task_ids if not already there
+        const goal = this.goals.get(payload.goal_id);
+        if (goal && !goal.task_ids.includes(payload.task_id)) {
+            goal.task_ids.push(payload.task_id);
+        }
+    }
+    _onTaskAssigned(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "assigned";
+        task.assigned_to = payload.assigned_to;
+        if (payload.session_id)
+            task.session_id = payload.session_id;
+        task.updated_at = event.timestamp;
+    }
+    _onTaskStarted(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "started";
+        task.session_id = payload.session_id;
+        task.updated_at = event.timestamp;
+        // Mark goal as running if not already
+        const goal = this.goals.get(task.goal_id);
+        if (goal && (goal.status === "planned" || goal.status === "classified")) {
+            goal.status = "running";
+            goal.active_session_id = payload.session_id;
+            goal.updated_at = event.timestamp;
+        }
+    }
+    _onTaskProgress(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "in_progress";
+        task.progress_notes.push(payload.note);
+        task.updated_at = event.timestamp;
+    }
+    _onTaskFailed(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "failed";
+        task.failure_message = payload.error_message;
+        task.updated_at = event.timestamp;
+    }
+    _onTaskRework(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "rework";
+        task.rework_reason = payload.reason;
+        task.updated_at = event.timestamp;
+    }
+    _onTaskCompleted(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "completed";
+        task.summary = payload.summary ?? task.summary;
+        task.updated_at = event.timestamp;
+    }
+    _onTaskCancelled(event) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = "cancelled";
+        task.cancel_reason = payload.reason;
+        task.updated_at = event.timestamp;
+    }
+    _onTaskStatusChange(event, status) {
+        const payload = event.payload;
+        const task = this.tasks.get(payload.task_id);
+        if (!task)
+            return;
+        task.status = status;
+        task.updated_at = event.timestamp;
+    }
+}

package/dist/core/projection/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Projection Module
+ *
+ * Session is a query view over EventStore.
+ */
+export * from "./types.js";
+export * from "./event-to-message.js";
+export * from "./session-projection.js";
+export * from "./session-manager.js";
+export * from "./boundary-inferrer.js";
+export * from "./goal-projection.js";
+export * from "./task-history.js";
+export * from "./timeline-projection.js";

package/dist/core/projection/index.js

@@ -0,0 +1,13 @@
+/**
+ * Projection Module
+ *
+ * Session is a query view over EventStore.
+ */
+export * from "./types.js";
+export * from "./event-to-message.js";
+export * from "./session-projection.js";
+export * from "./session-manager.js";
+export * from "./boundary-inferrer.js";
+export * from "./goal-projection.js";
+export * from "./task-history.js";
+export * from "./timeline-projection.js";

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

@@ -0,0 +1,100 @@
+/**
+ * Session Manager (Event-Sourced)
+ *
+ * Manages session descriptors, not session data.
+ * Data lives in EventStore. Session is just a query view.
+ */
+import type { EventStore } from "../event-store/store.js";
+import type { SessionDescriptor, ThreadDescriptor } from "./types.js";
+import { SessionProjection } from "./session-projection.js";
+export interface CreateProjectionSessionOptions {
+    parentSessionId?: string;
+    threadId?: string;
+    startEventId?: string;
+    summaryEventId?: string;
+    closeActive?: boolean;
+}
+/**
+ * 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 declare class SessionManager {
+    private store;
+    private threads;
+    private sessions;
+    private activeThreadId;
+    private activeSessionId;
+    private inferrer;
+    private unsubscribe;
+    private filePath;
+    constructor(store: EventStore, storagePath?: string);
+    /**
+     * Get or create the active session.
+     */
+    getActiveSession(): SessionProjection;
+    /**
+     * Create a new session.
+     */
+    createSession(created_by: SessionDescriptor["created_by"], name?: string, options?: CreateProjectionSessionOptions): SessionDescriptor;
+    /**
+     * Fork the current session at a specific event.
+     */
+    forkAt(event_id: string): SessionDescriptor;
+    /**
+     * 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: string): SessionDescriptor;
+    /**
+     * List all sessions.
+     */
+    listSessions(): SessionDescriptor[];
+    /**
+     * Switch to a different session.
+     */
+    switchTo(session_id: string): void;
+    /**
+     * Get a session by ID.
+     */
+    getSession(session_id: string): SessionDescriptor | undefined;
+    /**
+     * Get session projection by ID.
+     */
+    getSessionProjection(session_id: string): SessionProjection | undefined;
+    /**
+     * Update session name.
+     */
+    renameSession(session_id: string, name: string): void;
+    /**
+     * Get the active session ID.
+     */
+    getActiveSessionId(): string | undefined;
+    getActiveThreadId(): string | undefined;
+    getActiveThread(): ThreadDescriptor | 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?: string): ThreadDescriptor;
+    /**
+     * Dispose the session manager.
+     */
+    dispose(): void;
+    private _subscribeToEvents;
+    private _evaluateBoundary;
+    private _getRecentEventsBefore;
+    private _ensureStorageDir;
+    private _loadIndex;
+    private _persistIndex;
+    private _generateSessionId;
+    /** Create a thread record (no session). Used by createThread and createSession's auto-thread fallback. */
+    private _createThreadRecord;
+    private _generateThreadId;
+}