@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/projection/task-history.js

@@ -0,0 +1,61 @@
+export const TASK_HISTORY_EVENT_TYPES = [
+    "TASK_CREATED",
+    "TASK_ASSIGNED",
+    "TASK_STARTED",
+    "TASK_PROGRESS",
+    "TASK_COMPLETED",
+    "TASK_FAILED",
+    "TASK_REWORK_REQUESTED",
+    "TASK_ACCEPTED",
+    "TASK_CANCELLED",
+];
+export function buildRecentTaskHistory(projection, limit = 3) {
+    return projection
+        .listTasks()
+        .sort((a, b) => b.updated_at - a.updated_at)
+        .slice(0, Math.max(0, limit))
+        .map((task) => ({
+        task_id: task.task_id,
+        status: task.status,
+        title: cleanText(task.title),
+        summary: summarizeTask(task),
+        updated_at: task.updated_at,
+    }));
+}
+export function summarizeTask(task) {
+    const title = cleanText(task.title);
+    const latestProgress = cleanText(task.progress_notes.at(-1));
+    const summary = cleanText(task.summary);
+    const failure = cleanText(task.failure_message);
+    const rework = cleanText(task.rework_reason);
+    const cancelled = cleanText(task.cancel_reason);
+    const description = cleanText(task.description);
+    switch (task.status) {
+        case "accepted":
+            return summary || title;
+        case "completed":
+            return summary || `Completed ${lowercaseFirst(title)}`;
+        case "failed":
+            return failure ? `Failed: ${failure}` : `Failed ${lowercaseFirst(title)}`;
+        case "rework":
+            return rework ? `Rework: ${rework}` : `Rework needed for ${lowercaseFirst(title)}`;
+        case "cancelled":
+            return cancelled ? `Cancelled: ${cancelled}` : `Cancelled ${lowercaseFirst(title)}`;
+        case "in_progress":
+            return latestProgress || `Working on ${lowercaseFirst(title)}`;
+        case "started":
+            return `Started ${lowercaseFirst(title)}`;
+        case "assigned":
+            return task.assigned_to ? `Assigned to ${task.assigned_to}: ${title}` : `Assigned ${lowercaseFirst(title)}`;
+        case "created":
+            return description || title;
+    }
+}
+function cleanText(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim();
+}
+function lowercaseFirst(value) {
+    if (!value)
+        return "task";
+    return value.charAt(0).toLowerCase() + value.slice(1);
+}

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

@@ -0,0 +1,82 @@
+/**
+ * Timeline Projection
+ *
+ * Derives a chronological activity timeline from events in the EventStore.
+ * Used by UI layers to render a full activity feed (not just chat messages).
+ *
+ * The timeline includes:
+ * - User messages
+ * - Agent responses (summarized)
+ * - Tool executions (with duration)
+ * - File mutations
+ * - Goal/Task lifecycle events
+ * - Session boundaries
+ * - Compaction markers
+ */
+import type { EventStore } from "../event-store/store.js";
+/** Timeline entry kind */
+export type TimelineEntryKind = "user_message" | "agent_message" | "tool_execution" | "file_mutation" | "goal_event" | "task_event" | "session_boundary" | "compaction" | "error" | "checkpoint";
+/** A single entry in the timeline */
+export interface TimelineEntry {
+    /** Underlying event ID */
+    event_id: string;
+    /** Timestamp (unix ms) */
+    timestamp: number;
+    /** Entry kind for rendering */
+    kind: TimelineEntryKind;
+    /** Short human-readable summary */
+    summary: string;
+    /** Actor that produced this event */
+    actor_id: string;
+    /** Optional duration in ms (for tool executions) */
+    duration_ms?: number;
+    /** Associated metadata (tool name, file path, goal/task id, etc.) */
+    metadata?: Record<string, unknown>;
+    /** Causal parent event_id */
+    caused_by?: string;
+}
+/** Options for querying the timeline */
+export interface TimelineQueryOptions {
+    /** Only include entries after this timestamp */
+    after_timestamp?: number;
+    /** Only include entries before this timestamp */
+    before_timestamp?: number;
+    /** Only include specific kinds */
+    kinds?: TimelineEntryKind[];
+    /** Maximum number of entries */
+    limit?: number;
+    /** Thread filter (isolation key) */
+    thread_id?: string;
+}
+/**
+ * TimelineProjection builds a chronological activity feed from events.
+ *
+ * Usage:
+ *   const timeline = new TimelineProjection(store);
+ *   const entries = timeline.query({ limit: 50 });
+ */
+export declare class TimelineProjection {
+    private store;
+    /** In-memory cache of tool start times (for duration calculation) */
+    private toolStartTimes;
+    constructor(store: EventStore);
+    /**
+     * Query the timeline.
+     */
+    query(options?: TimelineQueryOptions): TimelineEntry[];
+    /**
+     * Get the latest N timeline entries.
+     */
+    latest(count: number): TimelineEntry[];
+    private _eventToEntry;
+    private _userMessage;
+    private _agentMessage;
+    private _toolExecution;
+    private _fileMutation;
+    private _goalEvent;
+    private _taskEvent;
+    private _sessionEvent;
+    private _compactionEvent;
+    private _errorEvent;
+    private _checkpointEvent;
+}

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

@@ -0,0 +1,276 @@
+/**
+ * Timeline Projection
+ *
+ * Derives a chronological activity timeline from events in the EventStore.
+ * Used by UI layers to render a full activity feed (not just chat messages).
+ *
+ * The timeline includes:
+ * - User messages
+ * - Agent responses (summarized)
+ * - Tool executions (with duration)
+ * - File mutations
+ * - Goal/Task lifecycle events
+ * - Session boundaries
+ * - Compaction markers
+ */
+// ============================================================================
+// Event types we scan for the timeline
+// ============================================================================
+const TIMELINE_EVENT_TYPES = [
+    "USER_MESSAGE",
+    "AGENT_MESSAGE_END",
+    "TOOL_EXECUTION_START",
+    "TOOL_EXECUTION_END",
+    "FILE_MUTATION_APPLIED",
+    "GOAL_CREATED",
+    "GOAL_PLANNED",
+    "GOAL_COMPLETED",
+    "GOAL_CANCELLED",
+    "TASK_CREATED",
+    "TASK_STARTED",
+    "TASK_COMPLETED",
+    "TASK_FAILED",
+    "TASK_ACCEPTED",
+    "SESSION_CREATED",
+    "SESSION_BOUNDARY_INFERRED",
+    "SESSION_FORKED",
+    "COMPACTION_END",
+    "COMPACTION_ABORTED",
+    "AGENT_ERROR",
+    "RUNTIME_ERROR",
+    "CHECKPOINT_CREATED",
+];
+// ============================================================================
+// Timeline Projection
+// ============================================================================
+/**
+ * TimelineProjection builds a chronological activity feed from events.
+ *
+ * Usage:
+ *   const timeline = new TimelineProjection(store);
+ *   const entries = timeline.query({ limit: 50 });
+ */
+export class TimelineProjection {
+    constructor(store) {
+        this.store = store;
+        /** In-memory cache of tool start times (for duration calculation) */
+        this.toolStartTimes = new Map();
+    }
+    /**
+     * Query the timeline.
+     */
+    query(options) {
+        const events = this.store.query({
+            types: TIMELINE_EVENT_TYPES,
+            thread_id: options?.thread_id,
+        });
+        // Also fetch TOOL_EXECUTION_START events for duration calculation
+        const toolStartEvents = this.store.query({ types: ["TOOL_EXECUTION_START"] });
+        this.toolStartTimes.clear();
+        for (const evt of toolStartEvents) {
+            const payload = evt.payload;
+            if (payload.tool_call_id) {
+                this.toolStartTimes.set(payload.tool_call_id, evt.timestamp);
+            }
+        }
+        let entries = events
+            .map((event) => this._eventToEntry(event))
+            .filter((entry) => entry !== undefined);
+        // Apply filters
+        if (options?.after_timestamp) {
+            entries = entries.filter((e) => e.timestamp > options.after_timestamp);
+        }
+        if (options?.before_timestamp) {
+            entries = entries.filter((e) => e.timestamp < options.before_timestamp);
+        }
+        if (options?.kinds?.length) {
+            entries = entries.filter((e) => options.kinds.includes(e.kind));
+        }
+        if (options?.limit && entries.length > options.limit) {
+            entries = entries.slice(-options.limit);
+        }
+        return entries;
+    }
+    /**
+     * Get the latest N timeline entries.
+     */
+    latest(count) {
+        return this.query({ limit: count });
+    }
+    // =========================================================================
+    // Event-to-Entry Conversion
+    // =========================================================================
+    _eventToEntry(event) {
+        switch (event.type) {
+            case "USER_MESSAGE":
+                return this._userMessage(event);
+            case "AGENT_MESSAGE_END":
+                return this._agentMessage(event);
+            case "TOOL_EXECUTION_END":
+                return this._toolExecution(event);
+            case "FILE_MUTATION_APPLIED":
+                return this._fileMutation(event);
+            case "GOAL_CREATED":
+            case "GOAL_PLANNED":
+            case "GOAL_COMPLETED":
+            case "GOAL_CANCELLED":
+                return this._goalEvent(event);
+            case "TASK_CREATED":
+            case "TASK_STARTED":
+            case "TASK_COMPLETED":
+            case "TASK_FAILED":
+            case "TASK_ACCEPTED":
+                return this._taskEvent(event);
+            case "SESSION_CREATED":
+            case "SESSION_BOUNDARY_INFERRED":
+            case "SESSION_FORKED":
+                return this._sessionEvent(event);
+            case "COMPACTION_END":
+            case "COMPACTION_ABORTED":
+                return this._compactionEvent(event);
+            case "AGENT_ERROR":
+            case "RUNTIME_ERROR":
+                return this._errorEvent(event);
+            case "CHECKPOINT_CREATED":
+                return this._checkpointEvent(event);
+            default:
+                return undefined;
+        }
+    }
+    _userMessage(event) {
+        const payload = event.payload;
+        const text = typeof payload.content === "string" ? payload.content : "";
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "user_message",
+            summary: text.length > 100 ? text.slice(0, 100) + "…" : text,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+        };
+    }
+    _agentMessage(event) {
+        const payload = event.payload;
+        const textBlocks = payload.content?.filter((b) => b.type === "text") ?? [];
+        const firstText = textBlocks[0]?.text ?? "";
+        const summary = firstText.length > 100 ? firstText.slice(0, 100) + "…" : firstText;
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "agent_message",
+            summary: summary || `(${payload.stop_reason ?? "response"})`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: { stop_reason: payload.stop_reason, tokens: payload.usage?.total },
+        };
+    }
+    _toolExecution(event) {
+        const payload = event.payload;
+        const startTime = payload.tool_call_id
+            ? this.toolStartTimes.get(payload.tool_call_id)
+            : undefined;
+        const duration = startTime ? event.timestamp - startTime : undefined;
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "tool_execution",
+            summary: `${payload.tool_name ?? "tool"}${payload.is_error ? " (error)" : ""}`,
+            actor_id: event.actor_id,
+            duration_ms: duration,
+            caused_by: event.caused_by,
+            metadata: { tool_name: payload.tool_name, is_error: payload.is_error },
+        };
+    }
+    _fileMutation(event) {
+        const payload = event.payload;
+        const path = payload.path ?? payload.mutation?.path ?? "file";
+        const operation = payload.operation ?? payload.mutation?.operation ?? "modify";
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "file_mutation",
+            summary: `${operation} ${path}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: { ...payload.mutation, ...payload, path, operation },
+        };
+    }
+    _goalEvent(event) {
+        const payload = event.payload;
+        const action = event.type.replace("GOAL_", "").toLowerCase();
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "goal_event",
+            summary: `Goal ${action}: ${payload.title ?? payload.goal_id ?? ""}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+    _taskEvent(event) {
+        const payload = event.payload;
+        const action = event.type.replace("TASK_", "").toLowerCase();
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "task_event",
+            summary: `Task ${action}: ${payload.title ?? payload.task_id ?? ""}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+    _sessionEvent(event) {
+        const payload = event.payload;
+        const action = event.type.replace("SESSION_", "").toLowerCase();
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "session_boundary",
+            summary: `Session ${action}${payload.reason ? `: ${payload.reason}` : ""}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+    _compactionEvent(event) {
+        const payload = event.payload;
+        const aborted = event.type === "COMPACTION_ABORTED";
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "compaction",
+            summary: aborted
+                ? `Context compaction aborted${payload.message ? `: ${payload.message}` : ""}`
+                : `Context compacted${payload.tokens_before ? ` (${payload.tokens_before} tokens)` : ""}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+    _errorEvent(event) {
+        const payload = event.payload;
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "error",
+            summary: payload.error_message ?? payload.error ?? "Runtime error",
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+    _checkpointEvent(event) {
+        const payload = event.payload;
+        return {
+            event_id: event.event_id,
+            timestamp: event.timestamp,
+            kind: "checkpoint",
+            summary: `Checkpoint${payload.label ? `: ${payload.label}` : ""}`,
+            actor_id: event.actor_id,
+            caused_by: event.caused_by,
+            metadata: payload,
+        };
+    }
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Session Projection Types
+ *
+ * Session is a query view over the EventStore, not a data holder.
+ */
+import type { EventBase } from "../event-store/types.js";
+/** Session definition - pure reference structure */
+export interface SessionDescriptor {
+    session_id: string;
+    thread_id: string;
+    workspace_id: string;
+    /** Event range covered by this session [start, end] (inclusive) */
+    event_range: {
+        start_event_id: string;
+        end_event_id: string;
+    };
+    /** Summary reference (compaction event_id) */
+    summary_event_id?: string;
+    /** User-defined name */
+    name?: string;
+    /** Creation method */
+    created_by: "user_explicit" | "auto_inferred" | "fork";
+    /** Boundary inference reason */
+    boundary_reason?: "intent_shift" | "file_drift" | "time_gap" | "user_explicit";
+    /** Parent session (fork source) */
+    parent_session_id?: string;
+    /** Creation timestamp */
+    created_at: number;
+}
+/**
+ * A conversation thread — the isolation unit.
+ *
+ * One thread = one `thread_id` on events. Threads are fixed once created;
+ * auto-splitting happens at session level (within a thread), never at thread level.
+ * A thread contains a tree of sessions (branches from rewind/fork).
+ */
+export interface ThreadDescriptor {
+    thread_id: string;
+    workspace_id: string;
+    /** User-defined name (e.g. "Q3 marketing") */
+    name?: string;
+    /** Creation timestamp */
+    created_at: number;
+    /** Lifecycle status. active = ongoing; closed = user-ended. */
+    status: "active" | "closed";
+}
+/** Session index storage (threads + their session branches) */
+export interface SessionIndex {
+    threads: ThreadDescriptor[];
+    sessions: SessionDescriptor[];
+}
+/** Options for building LLM context */
+export interface BuildContextOptions {
+    /** Token budget */
+    max_tokens?: number;
+    /** Include tool execution details */
+    include_tool_details?: boolean;
+    /** Include file mutations */
+    include_file_mutations?: boolean;
+}
+/** Built context result */
+export interface BuiltContext {
+    /** Messages for LLM consumption */
+    messages: import("../agent/types.js").AgentMessage[];
+    /** Raw events used to build context */
+    events: EventBase[];
+    /** Session descriptor */
+    descriptor: SessionDescriptor;
+}

package/dist/core/projection/types.js

@@ -0,0 +1,6 @@
+/**
+ * Session Projection Types
+ *
+ * Session is a query view over the EventStore, not a data holder.
+ */
+export {};

package/dist/core/prompt-templates.d.ts

@@ -0,0 +1,51 @@
+import { type SourceInfo } from "./source-info.js";
+/**
+ * Represents a prompt template loaded from a markdown file
+ */
+export interface PromptTemplate {
+    name: string;
+    description: string;
+    argumentHint?: string;
+    content: string;
+    sourceInfo: SourceInfo;
+    filePath: string;
+}
+/**
+ * Parse command arguments respecting quoted strings (bash-style)
+ * Returns array of arguments
+ */
+export declare function parseCommandArgs(argsString: string): string[];
+/**
+ * Substitute argument placeholders in template content
+ * Supports:
+ * - $1, $2, ... for positional args
+ * - $@ and $ARGUMENTS for all args
+ * - ${@:N} for args from Nth onwards (bash-style slicing)
+ * - ${@:N:L} for L args starting from Nth
+ *
+ * Note: Replacement happens on the template string only. Argument values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export declare function substituteArgs(content: string, args: string[]): string;
+export interface LoadPromptTemplatesOptions {
+    /** Working directory for project-local templates. */
+    cwd: string;
+    /** Agent config directory for global templates. */
+    agentDir: string;
+    /** Explicit prompt template paths (files or directories). */
+    promptPaths: string[];
+    /** Include default prompt directories. */
+    includeDefaults: boolean;
+}
+/**
+ * Load all prompt templates from:
+ * 1. Global: agentDir/prompts/
+ * 2. Project: cwd/{CONFIG_DIR_NAME}/prompts/
+ * 3. Explicit prompt paths
+ */
+export declare function loadPromptTemplates(options: LoadPromptTemplatesOptions): PromptTemplate[];
+/**
+ * Expand a prompt template if it matches a template name.
+ * Returns the expanded content or the original text if not a template.
+ */
+export declare function expandPromptTemplate(text: string, templates: PromptTemplate[]): string;