@tomsun28/pizza 0.0.9 → 0.1.1

package/dist/core/projection/boundary-inferrer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Session Boundary Inferrer
+ *
+ * Automatically infers session boundaries based on signals like:
+ * - Time gaps
+ * - User message semantic shifts
+ * - File set drift
+ * - Tool usage pattern changes
+ */
+import type { EventBase } from "../event-store/types.js";
+/** Boundary inference decision */
+export interface BoundaryDecision {
+    should_split: boolean;
+    reason?: "intent_shift" | "file_drift" | "time_gap" | "tool_pattern_change";
+    suggested_name?: string;
+    confidence?: number;
+}
+export interface BoundaryConfig {
+    /** Time gap threshold in milliseconds */
+    time_gap_ms: number;
+    /** File drift threshold (0-1, fraction of new files) */
+    file_drift_threshold: number;
+    /** Minimum events for a session */
+    min_events_for_session: number;
+    /** Enable file drift detection */
+    enable_file_drift: boolean;
+    /** Enable intent shift detection */
+    enable_intent_shift: boolean;
+    /** Enable tool pattern change detection */
+    enable_tool_pattern_change: boolean;
+}
+/**
+ * Automatically infers session boundaries.
+ *
+ * Phase 1: Time gap only
+ * Phase 2: + File drift, tool pattern change
+ * Phase 3: + Intent shift (semantic comparison)
+ */
+export declare class SessionBoundaryInferrer {
+    private config;
+    constructor(config?: BoundaryConfig);
+    /**
+     * Evaluate whether to create a new session boundary.
+     *
+     * @param recentEvents Recent events in the current session (most recent last)
+     * @param newEvent The new event being added
+     * @returns Decision whether to split
+     */
+    evaluate(recentEvents: EventBase[], newEvent: EventBase): BoundaryDecision;
+    /**
+     * Update configuration.
+     */
+    updateConfig(updates: Partial<BoundaryConfig>): void;
+    private _hasTimeGap;
+    private _hasFileDrift;
+    private _hasIntentShift;
+    private _hasToolPatternChange;
+}

package/dist/core/projection/boundary-inferrer.js

@@ -0,0 +1,122 @@
+/**
+ * Session Boundary Inferrer
+ *
+ * Automatically infers session boundaries based on signals like:
+ * - Time gaps
+ * - User message semantic shifts
+ * - File set drift
+ * - Tool usage pattern changes
+ */
+const DEFAULT_BOUNDARY_CONFIG = {
+    time_gap_ms: 2 * 60 * 60 * 1000, // 2 hours
+    file_drift_threshold: 0.8,
+    min_events_for_session: 3,
+    enable_file_drift: false, // Phase 2
+    enable_intent_shift: false, // Phase 3
+    enable_tool_pattern_change: false, // Phase 2
+};
+// ============================================================================
+// Session Boundary Inferrer
+// ============================================================================
+/**
+ * Automatically infers session boundaries.
+ *
+ * Phase 1: Time gap only
+ * Phase 2: + File drift, tool pattern change
+ * Phase 3: + Intent shift (semantic comparison)
+ */
+export class SessionBoundaryInferrer {
+    constructor(config = DEFAULT_BOUNDARY_CONFIG) {
+        this.config = config;
+    }
+    /**
+     * Evaluate whether to create a new session boundary.
+     *
+     * @param recentEvents Recent events in the current session (most recent last)
+     * @param newEvent The new event being added
+     * @returns Decision whether to split
+     */
+    evaluate(recentEvents, newEvent) {
+        // Don't split if we don't have enough events yet
+        if (recentEvents.length < this.config.min_events_for_session) {
+            return { should_split: false };
+        }
+        // 1. Time gap check
+        if (this._hasTimeGap(recentEvents, newEvent)) {
+            return {
+                should_split: true,
+                reason: "time_gap",
+                confidence: 1.0,
+            };
+        }
+        // 2. File drift check (Phase 2)
+        if (this.config.enable_file_drift && this._hasFileDrift(recentEvents, newEvent)) {
+            return {
+                should_split: true,
+                reason: "file_drift",
+                confidence: 0.7,
+            };
+        }
+        // 3. Intent shift check (Phase 3)
+        if (this.config.enable_intent_shift && this._hasIntentShift(recentEvents, newEvent)) {
+            return {
+                should_split: true,
+                reason: "intent_shift",
+                confidence: 0.6,
+            };
+        }
+        // 4. Tool pattern change (Phase 2)
+        if (this.config.enable_tool_pattern_change && this._hasToolPatternChange(recentEvents, newEvent)) {
+            return {
+                should_split: true,
+                reason: "tool_pattern_change",
+                confidence: 0.5,
+            };
+        }
+        return { should_split: false };
+    }
+    /**
+     * Update configuration.
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+    }
+    // =========================================================================
+    // Private Detection Methods
+    // =========================================================================
+    _hasTimeGap(recent, next) {
+        if (recent.length === 0)
+            return false;
+        const last = recent[recent.length - 1];
+        return next.timestamp - last.timestamp > this.config.time_gap_ms;
+    }
+    _hasFileDrift(recent, _next) {
+        // Phase 2: Compare file sets in recent tool executions vs new event
+        const recentFiles = new Set();
+        for (const event of recent) {
+            if (event.type === "TOOL_EXECUTION_END") {
+                const payload = event.payload;
+                if (payload.file_mutations) {
+                    for (const mutation of payload.file_mutations) {
+                        recentFiles.add(mutation.path);
+                    }
+                }
+            }
+        }
+        // If no files recently, no drift
+        if (recentFiles.size === 0)
+            return false;
+        // Phase 2: implement actual drift detection
+        // For now, return false to avoid false positives
+        return false;
+    }
+    _hasIntentShift(_recent, _next) {
+        // Phase 3: Semantic comparison of user messages
+        // Requires LLM-based topic comparison
+        return false;
+    }
+    _hasToolPatternChange(_recent, _next) {
+        // Phase 2: Compare tool usage patterns
+        return false;
+    }
+}

package/dist/core/projection/event-to-message.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Event to Message Converter
+ *
+ * Converts EventStore events to AgentMessage format for LLM consumption.
+ */
+import type { AgentMessage } from "../agent/types.js";
+import type { EventBase } from "../event-store/types.js";
+/**
+ * Convert events to messages for LLM context.
+ *
+ * Handles:
+ * - USER_MESSAGE → user message
+ * - AGENT_MESSAGE_END → assistant message
+ * - TOOL_EXECUTION_END → tool result message
+ * - COMPACTION_END → system summary message
+ * - FILE_MUTATION_APPLIED → custom notification message
+ */
+export declare function eventsToMessages(events: EventBase[]): AgentMessage[];
+/**
+ * Convert a single event to an AgentMessage.
+ * Returns null if the event doesn't produce a message.
+ */
+export declare function eventToMessage(event: EventBase): AgentMessage | null;
+/**
+ * Extract tool calls from content blocks.
+ */
+export declare function extractToolCalls(content: unknown[]): Array<{
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}>;
+/**
+ * Extract text content from a message.
+ */
+export declare function extractTextContent(content: string | unknown[]): string;

package/dist/core/projection/event-to-message.js

@@ -0,0 +1,253 @@
+/**
+ * Event to Message Converter
+ *
+ * Converts EventStore events to AgentMessage format for LLM consumption.
+ */
+// ============================================================================
+// Event to Message Conversion
+// ============================================================================
+/**
+ * Convert events to messages for LLM context.
+ *
+ * Handles:
+ * - USER_MESSAGE → user message
+ * - AGENT_MESSAGE_END → assistant message
+ * - TOOL_EXECUTION_END → tool result message
+ * - COMPACTION_END → system summary message
+ * - FILE_MUTATION_APPLIED → custom notification message
+ */
+export function eventsToMessages(events) {
+    const messages = [];
+    for (const event of events) {
+        const msg = eventToMessage(event);
+        if (msg) {
+            messages.push(msg);
+        }
+    }
+    return messages;
+}
+/**
+ * Convert a single event to an AgentMessage.
+ * Returns null if the event doesn't produce a message.
+ */
+export function eventToMessage(event) {
+    switch (event.type) {
+        case "USER_MESSAGE": {
+            const payload = event.payload;
+            // Merge images into content array if present
+            let content = payload.content;
+            if (payload.images && payload.images.length > 0) {
+                if (typeof content === "string") {
+                    content = [{ type: "text", text: content }, ...payload.images];
+                }
+                else {
+                    content = [...content, ...payload.images];
+                }
+            }
+            return {
+                role: "user",
+                content,
+                timestamp: event.timestamp,
+            };
+        }
+        case "AGENT_MESSAGE_END": {
+            const payload = event.payload;
+            // Convert content - AGENT_MESSAGE_END from our event store
+            // contains text/image blocks from the LLM response
+            const rawContent = payload.content;
+            const content = rawContent
+                .filter((block) => {
+                const b = block;
+                return b.type === "text" || b.type === "thinking" || b.type === "tool_call" || b.type === "toolCall";
+            })
+                .map((block) => {
+                const blockType = block.type;
+                if (blockType !== "tool_call" && blockType !== "toolCall") {
+                    return block;
+                }
+                const toolCall = block;
+                return {
+                    type: "toolCall",
+                    id: String(toolCall.id ?? toolCall.tool_call_id ?? ""),
+                    name: String(toolCall.name ?? toolCall.tool_name ?? ""),
+                    arguments: toolCall.arguments ?? {},
+                };
+            });
+            // Convert stop_reason to StopReason
+            const stopReason = (payload.stop_reason === "tool_use" ? "toolUse" : payload.stop_reason);
+            // Convert TokenUsage to Usage
+            const usage = {
+                input: payload.usage.input,
+                output: payload.usage.output,
+                cacheRead: payload.usage.cache_read,
+                cacheWrite: payload.usage.cache_write,
+                totalTokens: payload.usage.total,
+                cost: {
+                    input: payload.usage.cost * 0.5,
+                    output: payload.usage.cost * 0.5,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    total: payload.usage.cost,
+                },
+            };
+            return {
+                role: "assistant",
+                content,
+                api: payload.model.provider,
+                provider: payload.model.provider,
+                model: payload.model.model_id,
+                usage,
+                stopReason,
+                errorMessage: payload.error_message,
+                timestamp: event.timestamp,
+            };
+        }
+        case "TOOL_EXECUTION_END": {
+            const payload = event.payload;
+            const content = formatToolResult(payload.result, payload.is_error);
+            return {
+                role: "toolResult",
+                toolCallId: payload.tool_call_id,
+                toolName: payload.tool_name,
+                content,
+                isError: payload.is_error,
+                details: payload.details,
+                timestamp: event.timestamp,
+            };
+        }
+        case "COMPACTION_END": {
+            const payload = event.payload;
+            return {
+                role: "compactionSummary",
+                summary: payload.summary,
+                tokensBefore: payload.tokens_before,
+                timestamp: event.timestamp,
+            };
+        }
+        case "FILE_MUTATION_APPLIED": {
+            const mutation = normalizeFileMutationPayload(event.payload);
+            const operation = mutation.operation ?? "modify";
+            const path = mutation.path ?? "file";
+            return {
+                role: "custom",
+                customType: "runtime:file_mutation",
+                content: `File ${operation}: ${path}`,
+                display: true,
+                details: mutation,
+                timestamp: event.timestamp,
+            };
+        }
+        case "BASH_EXECUTION": {
+            const payload = event.payload;
+            return {
+                role: "bashExecution",
+                command: payload.command,
+                output: payload.output ?? "",
+                stdout: payload.stdout,
+                stderr: payload.stderr,
+                exitCode: payload.exit_code,
+                durationMs: payload.duration_ms,
+                cwd: payload.cwd,
+                cancelled: payload.cancelled ?? false,
+                truncated: payload.truncated ?? false,
+                fullOutputPath: payload.full_output_path,
+                excludeFromContext: payload.exclude_from_context,
+                timestamp: event.timestamp,
+            };
+        }
+        case "CUSTOM_MESSAGE": {
+            const payload = event.payload;
+            // Transform event data into CustomMessage shape
+            let content = "";
+            let details = payload.data;
+            if (typeof payload.data === "string") {
+                content = payload.data;
+                details = undefined;
+            }
+            else if (Array.isArray(payload.data)) {
+                content = payload.data;
+            }
+            return {
+                role: "custom",
+                customType: `${payload.extension_id}:${payload.kind}`,
+                content,
+                display: payload.display,
+                details,
+                timestamp: event.timestamp,
+            };
+        }
+        case "BRANCH_SUMMARY": {
+            const payload = event.payload;
+            return {
+                role: "branchSummary",
+                summary: payload.summary,
+                fromId: payload.from_id,
+                timestamp: event.timestamp,
+            };
+        }
+        // Skip other event types - they don't produce messages
+        default:
+            return null;
+    }
+}
+function normalizeFileMutationPayload(payload) {
+    const nested = payload.mutation;
+    return {
+        path: payload.path ?? nested?.path,
+        operation: payload.operation ?? nested?.operation,
+        diff: payload.diff ?? nested?.diff,
+        toolCallId: payload.tool_call_id,
+        toolName: payload.tool_name,
+    };
+}
+/**
+ * Format tool result content for message.
+ */
+function formatToolResult(result, is_error) {
+    return result
+        .filter((block) => {
+        const b = block;
+        return b.type === "text" || b.type === "image";
+    })
+        .map((block) => {
+        if (block.type === "text") {
+            return {
+                type: "text",
+                text: is_error ? `Error: ${block.text}` : block.text,
+            };
+        }
+        return block;
+    });
+}
+/**
+ * Extract tool calls from content blocks.
+ */
+export function extractToolCalls(content) {
+    const calls = [];
+    for (const block of content) {
+        const b = block;
+        if (b.type === "tool_call" || b.type === "toolCall") {
+            calls.push({
+                id: String(b.id ?? b.tool_call_id ?? ""),
+                name: String(b.name ?? b.tool_name ?? ""),
+                arguments: b.arguments ?? {},
+            });
+        }
+    }
+    return calls;
+}
+/**
+ * Extract text content from a message.
+ */
+export function extractTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .filter((block) => {
+        const b = block;
+        return b.type === "text" && typeof b.text === "string";
+    })
+        .map((block) => block.text)
+        .join(" ");
+}

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

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+import type { EventStore } from "../event-store/store.js";
+import type { GoalDescriptor, TaskDescriptor } from "../goal/types.js";
+/**
+ * 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 declare class GoalProjection {
+    private store;
+    private goals;
+    private tasks;
+    private unsubscribe?;
+    constructor(store: EventStore);
+    /**
+     * Rebuild the projection from scratch by scanning all events.
+     */
+    rebuild(): void;
+    /**
+     * Start live-updating the projection by subscribing to new events.
+     */
+    startLive(): void;
+    /**
+     * Stop live updates.
+     */
+    stopLive(): void;
+    /** Get all goals */
+    listGoals(): GoalDescriptor[];
+    /** Get active (non-terminal) goals */
+    listActiveGoals(): GoalDescriptor[];
+    /** Get a specific goal */
+    getGoal(goalId: string): GoalDescriptor | undefined;
+    /** Get all tasks for a goal */
+    getTasksForGoal(goalId: string): TaskDescriptor[];
+    /** Get all tasks */
+    listTasks(): TaskDescriptor[];
+    /** Get a specific task */
+    getTask(taskId: string): TaskDescriptor | undefined;
+    /** Get tasks that are ready to start (all dependencies completed/accepted) */
+    getReadyTasks(goalId: string): TaskDescriptor[];
+    /** Get tasks blocked by dependencies */
+    getBlockedTasks(goalId: string): TaskDescriptor[];
+    private _applyEvent;
+    private _onGoalCreated;
+    private _onGoalClassified;
+    private _onGoalPlanned;
+    private _onGoalStatusChange;
+    private _onTaskCreated;
+    private _onTaskAssigned;
+    private _onTaskStarted;
+    private _onTaskProgress;
+    private _onTaskFailed;
+    private _onTaskRework;
+    private _onTaskCompleted;
+    private _onTaskCancelled;
+    private _onTaskStatusChange;
+}