@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/session-listing.js

@@ -0,0 +1,168 @@
+/**
+ * Session Listing
+ *
+ * Lists sessions from the new session index (sessions.json) and EventStore.
+ * Replaces old SessionManager.list/listAll static methods with a clean,
+ * event-sourced implementation.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "../config.js";
+import { SqliteEventStore } from "./event-store/sqlite-store.js";
+import { deriveWorkspaceId, getEventDatabasePath, getWorkspaceMetaPath } from "./event-store/workspace.js";
+// ============================================================================
+// Helpers
+// ============================================================================
+const SESSION_REF_PREFIX = "event-session:";
+function makeSessionRef(workspaceId, sessionId) {
+    return `${SESSION_REF_PREFIX}${workspaceId}:${sessionId}`;
+}
+function extractTextContent(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join(" ");
+}
+function isMessageWithContent(message) {
+    return typeof message.role === "string" && "content" in message;
+}
+/** Read session index from a workspace directory */
+function readSessionIndex(indexPath) {
+    if (!existsSync(indexPath))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(indexPath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read workspace cwd from meta.json */
+function readWorkspaceCwd(workspaceId, agentDir) {
+    const metaPath = getWorkspaceMetaPath(workspaceId, agentDir);
+    if (!existsSync(metaPath))
+        return undefined;
+    try {
+        const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+        return meta.cwd;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Build SessionListInfo from a session descriptor by querying EventStore for metadata */
+function buildSessionInfo(descriptor, workspaceId, cwd, store) {
+    let messageCount = 0;
+    let firstMessage = "";
+    const allMessages = [];
+    let lastActivity = descriptor.created_at;
+    // Query context-relevant events for this session's range
+    const events = store.query({
+        types: ["USER_MESSAGE", "AGENT_MESSAGE_END"],
+    });
+    for (const event of events) {
+        if (event.timestamp > 0) {
+            lastActivity = Math.max(lastActivity, event.timestamp);
+        }
+        if (event.type === "USER_MESSAGE") {
+            const payload = event.payload;
+            const text = typeof payload.content === "string"
+                ? payload.content
+                : "";
+            messageCount++;
+            if (text && !firstMessage) {
+                firstMessage = text.slice(0, 200);
+            }
+            if (text)
+                allMessages.push(text);
+        }
+        else if (event.type === "AGENT_MESSAGE_END") {
+            messageCount++;
+        }
+    }
+    return {
+        path: makeSessionRef(workspaceId, descriptor.session_id),
+        id: descriptor.session_id,
+        cwd,
+        name: descriptor.name,
+        parentSessionPath: descriptor.parent_session_id
+            ? makeSessionRef(workspaceId, descriptor.parent_session_id)
+            : undefined,
+        created: new Date(descriptor.created_at),
+        modified: new Date(lastActivity),
+        messageCount,
+        firstMessage: firstMessage || "(no messages)",
+        allMessagesText: allMessages.join(" "),
+    };
+}
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * List all sessions for a workspace (current cwd).
+ * Reads from sessions.json + EventStore for each session.
+ */
+export async function listWorkspaceSessions(cwd, agentDir = getAgentDir(), onProgress) {
+    const workspaceId = deriveWorkspaceId(cwd);
+    const indexPath = join(agentDir, "workspaces", workspaceId, "sessions.json");
+    const index = readSessionIndex(indexPath);
+    if (!index || index.sessions.length === 0)
+        return [];
+    const dbPath = getEventDatabasePath(workspaceId, agentDir);
+    if (!existsSync(dbPath))
+        return [];
+    const store = new SqliteEventStore(workspaceId, dbPath, "session_list");
+    try {
+        const workspaceCwd = readWorkspaceCwd(workspaceId, agentDir) ?? cwd;
+        const results = [];
+        for (let i = 0; i < index.sessions.length; i++) {
+            const desc = index.sessions[i];
+            results.push(buildSessionInfo(desc, workspaceId, workspaceCwd, store));
+            onProgress?.(i + 1, index.sessions.length);
+        }
+        results.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+        return results;
+    }
+    finally {
+        store.close();
+    }
+}
+/**
+ * List all sessions across all workspaces.
+ * Scans agentDir/workspaces/* for sessions.json files.
+ */
+export async function listAllSessions(agentDir = getAgentDir(), onProgress) {
+    const workspacesDir = join(agentDir, "workspaces");
+    if (!existsSync(workspacesDir))
+        return [];
+    const workspaceEntries = readdirSync(workspacesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+    const results = [];
+    for (let i = 0; i < workspaceEntries.length; i++) {
+        const workspaceId = workspaceEntries[i];
+        const indexPath = join(workspacesDir, workspaceId, "sessions.json");
+        const index = readSessionIndex(indexPath);
+        if (!index || index.sessions.length === 0)
+            continue;
+        const dbPath = getEventDatabasePath(workspaceId, agentDir);
+        if (!existsSync(dbPath))
+            continue;
+        const store = new SqliteEventStore(workspaceId, dbPath, "session_list_all");
+        try {
+            const workspaceCwd = readWorkspaceCwd(workspaceId, agentDir) ?? process.cwd();
+            for (const desc of index.sessions) {
+                results.push(buildSessionInfo(desc, workspaceId, workspaceCwd, store));
+            }
+        }
+        finally {
+            store.close();
+        }
+        onProgress?.(i + 1, workspaceEntries.length);
+    }
+    results.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return results;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Session Reader
+ *
+ * Minimal utility for reading session data from EventStore for export.
+ * This is the only remaining code that understands the old SESSION_ENTRY_APPENDED
+ * event format used to reconstruct entries for HTML export.
+ */
+import type { SessionEntry, SessionHeader } from "./types/session-types.js";
+export interface ReadSessionResult {
+    header: SessionHeader | null;
+    entries: SessionEntry[];
+    leafId: string | null;
+    sessionId: string;
+}
+/**
+ * Read session data from EventStore for export.
+ * Replaces SessionManager.open() for the export use case.
+ */
+export declare function readSessionForExport(inputPath: string, agentDir?: string): ReadSessionResult;

package/dist/core/session-reader.js

@@ -0,0 +1,101 @@
+/**
+ * Session Reader
+ *
+ * Minimal utility for reading session data from EventStore for export.
+ * This is the only remaining code that understands the old SESSION_ENTRY_APPENDED
+ * event format used to reconstruct entries for HTML export.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { getAgentDir } from "../config.js";
+import { SqliteEventStore } from "./event-store/sqlite-store.js";
+import { deriveWorkspaceId, getEventDatabasePath, getWorkspaceMetaPath } from "./event-store/workspace.js";
+const SESSION_REF_PREFIX = "event-session:";
+// ============================================================================
+// Helpers
+// ============================================================================
+function parseSessionRef(ref) {
+    if (ref.endsWith(".jsonl") || ref.includes("/") || ref.includes("\\")) {
+        throw new Error("Legacy JSONL session files are no longer supported; sessions now live in events.sqlite.");
+    }
+    if (!ref.startsWith(SESSION_REF_PREFIX)) {
+        return { sessionId: ref };
+    }
+    const rest = ref.slice(SESSION_REF_PREFIX.length);
+    const [workspaceId, sessionId] = rest.split(":");
+    if (!sessionId) {
+        throw new Error(`Invalid session reference: ${ref}`);
+    }
+    return { workspaceId, sessionId };
+}
+function readWorkspaceCwd(workspaceId, agentDir, fallback) {
+    const metaPath = getWorkspaceMetaPath(workspaceId, agentDir);
+    if (!existsSync(metaPath))
+        return fallback;
+    try {
+        const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+        return meta.cwd ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function entryFromEvent(event) {
+    const payload = event.payload;
+    return payload.entry;
+}
+/**
+ * Read session data from EventStore for export.
+ * Replaces SessionManager.open() for the export use case.
+ */
+export function readSessionForExport(inputPath, agentDir = getAgentDir()) {
+    const parsed = parseSessionRef(inputPath);
+    const workspaceId = parsed.workspaceId ?? deriveWorkspaceId(process.cwd());
+    const dbPath = getEventDatabasePath(workspaceId, agentDir);
+    if (!existsSync(dbPath)) {
+        throw new Error(`Session database not found: ${dbPath}`);
+    }
+    const store = new SqliteEventStore(workspaceId, dbPath, "export_reader");
+    try {
+        const sessionId = parsed.sessionId;
+        const cwd = readWorkspaceCwd(workspaceId, agentDir, process.cwd());
+        // Find the SESSION_CREATED event for this session
+        const createdEvents = store.query({ types: ["SESSION_CREATED"] });
+        const createdEvent = createdEvents.find((e) => {
+            const payload = e.payload;
+            return payload.session_id === sessionId;
+        });
+        let header = null;
+        if (createdEvent) {
+            const payload = createdEvent.payload;
+            header = {
+                type: "session",
+                version: 3,
+                id: sessionId,
+                timestamp: payload.timestamp ?? new Date(createdEvent.timestamp).toISOString(),
+                cwd: payload.cwd ?? cwd,
+                parentSession: payload.parentSession,
+            };
+        }
+        // Rebuild entries from SESSION_ENTRY_APPENDED events
+        const appendedEvents = store.query({ types: ["SESSION_ENTRY_APPENDED"] }).filter((event) => {
+            const payload = event.payload;
+            return payload.session_id === sessionId;
+        });
+        const entries = [];
+        let leafId = null;
+        for (const event of appendedEvents) {
+            const payload = event.payload;
+            if (payload.entry) {
+                entries.push(payload.entry);
+                leafId = payload.entry.id;
+            }
+            if (payload.leaf_id !== undefined) {
+                leafId = payload.leaf_id;
+            }
+        }
+        return { header, entries, leafId, sessionId };
+    }
+    finally {
+        store.close();
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare const SESSION_REF_PREFIX = "event-session:";
+export declare function makeSessionRef(workspaceId: string, sessionId: string): string;
+export declare function parseSessionRef(ref: string): {
+    workspaceId?: string;
+    sessionId: string;
+};
+export declare function getAgentDirFromSessionDir(sessionDir?: string): string;

package/dist/core/session-ref.js

@@ -0,0 +1,25 @@
+import { basename, dirname } from "node:path";
+import { getAgentDir as getDefaultAgentDir } from "../config.js";
+export const SESSION_REF_PREFIX = "event-session:";
+export function makeSessionRef(workspaceId, sessionId) {
+    return `${SESSION_REF_PREFIX}${workspaceId}:${sessionId}`;
+}
+export function parseSessionRef(ref) {
+    if (ref.endsWith(".jsonl") || ref.includes("/") || ref.includes("\\")) {
+        throw new Error("Legacy JSONL session files are no longer supported; sessions now live in events.sqlite.");
+    }
+    if (!ref.startsWith(SESSION_REF_PREFIX)) {
+        return { sessionId: ref };
+    }
+    const rest = ref.slice(SESSION_REF_PREFIX.length);
+    const [workspaceId, sessionId] = rest.split(":");
+    if (!sessionId) {
+        throw new Error(`Invalid session reference: ${ref}`);
+    }
+    return { workspaceId, sessionId };
+}
+export function getAgentDirFromSessionDir(sessionDir) {
+    if (!sessionDir)
+        return getDefaultAgentDir();
+    return basename(sessionDir) === "sessions" ? dirname(sessionDir) : sessionDir;
+}

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

@@ -0,0 +1,51 @@
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { type DefaultResourceLoaderOptions, type ResourceLoader } from "./resource-loader.js";
+import { SettingsManager } from "./settings-manager.js";
+/**
+ * Non-fatal issues collected while creating services or sessions.
+ *
+ * Runtime creation returns diagnostics to the caller instead of printing or
+ * exiting. The app layer decides whether warnings should be shown and whether
+ * errors should abort startup.
+ */
+export interface SessionDiagnostic {
+    type: "info" | "warning" | "error";
+    message: string;
+}
+/**
+ * Inputs for creating cwd-bound runtime services.
+ *
+ * These services are recreated whenever the effective session cwd changes.
+ * CLI-provided resource paths should be resolved to absolute paths before they
+ * reach this function, so later cwd switches do not reinterpret them.
+ */
+export interface CreateSessionServicesOptions {
+    cwd: string;
+    agentDir?: string;
+    authStorage?: AuthStorage;
+    settingsManager?: SettingsManager;
+    modelRegistry?: ModelRegistry;
+    extensionFlagValues?: Map<string, boolean | string>;
+    resourceLoaderOptions?: Omit<DefaultResourceLoaderOptions, "cwd" | "agentDir" | "settingsManager">;
+}
+/**
+ * Coherent cwd-bound runtime services for one effective session cwd.
+ *
+ * Services are created separately so session options can be resolved against them first.
+ */
+export interface SessionServices {
+    cwd: string;
+    agentDir: string;
+    authStorage: AuthStorage;
+    settingsManager: SettingsManager;
+    modelRegistry: ModelRegistry;
+    resourceLoader: ResourceLoader;
+    diagnostics: SessionDiagnostic[];
+}
+/**
+ * Create cwd-bound runtime services.
+ *
+ * Returns services plus diagnostics. Does not create a session facade.
+ */
+export declare function createSessionServices(options: CreateSessionServicesOptions): Promise<SessionServices>;

package/dist/core/session-services.js

@@ -0,0 +1,90 @@
+import { join } from "node:path";
+import { getAgentDir } from "../config.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SettingsManager } from "./settings-manager.js";
+function applyExtensionFlagValues(resourceLoader, extensionFlagValues) {
+    if (!extensionFlagValues) {
+        return [];
+    }
+    const diagnostics = [];
+    const extensionsResult = resourceLoader.getExtensions();
+    const registeredFlags = new Map();
+    for (const extension of extensionsResult.extensions) {
+        for (const [name, flag] of extension.flags) {
+            registeredFlags.set(name, { type: flag.type });
+        }
+    }
+    const unknownFlags = [];
+    for (const [name, value] of extensionFlagValues) {
+        const flag = registeredFlags.get(name);
+        if (!flag) {
+            unknownFlags.push(name);
+            continue;
+        }
+        if (flag.type === "boolean") {
+            extensionsResult.runtime.flagValues.set(name, true);
+            continue;
+        }
+        if (typeof value === "string") {
+            extensionsResult.runtime.flagValues.set(name, value);
+            continue;
+        }
+        diagnostics.push({
+            type: "error",
+            message: `Extension flag "--${name}" requires a value`,
+        });
+    }
+    if (unknownFlags.length > 0) {
+        diagnostics.push({
+            type: "error",
+            message: `Unknown option${unknownFlags.length === 1 ? "" : "s"}: ${unknownFlags.map((name) => `--${name}`).join(", ")}`,
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Create cwd-bound runtime services.
+ *
+ * Returns services plus diagnostics. Does not create a session facade.
+ */
+export async function createSessionServices(options) {
+    const cwd = options.cwd;
+    const agentDir = options.agentDir ?? getAgentDir();
+    const authStorage = options.authStorage ?? AuthStorage.create(join(agentDir, "auth.json"));
+    const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
+    const modelRegistry = options.modelRegistry ?? ModelRegistry.create(authStorage, join(agentDir, "models.json"));
+    const resourceLoader = new DefaultResourceLoader({
+        ...(options.resourceLoaderOptions ?? {}),
+        cwd,
+        agentDir,
+        settingsManager,
+    });
+    await resourceLoader.reload();
+    const diagnostics = [];
+    const extensionsResult = resourceLoader.getExtensions();
+    for (const { name, config, extensionPath } of extensionsResult.runtime.pendingProviderRegistrations) {
+        try {
+            modelRegistry.registerProvider(name, config);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            diagnostics.push({
+                type: "error",
+                message: `Extension "${extensionPath}" error: ${message}`,
+            });
+        }
+    }
+    extensionsResult.runtime.pendingProviderRegistrations = [];
+    diagnostics.push(...applyExtensionFlagValues(resourceLoader, options.extensionFlagValues));
+    return {
+        cwd,
+        agentDir,
+        authStorage,
+        settingsManager,
+        modelRegistry,
+        resourceLoader,
+        diagnostics,
+    };
+}

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

@@ -0,0 +1,43 @@
+import type { ContextUsage } from "./extensions/index.js";
+import type { AgentMessage } from "./agent/types.js";
+/** Token + cost + message-count statistics derived from a message list (no identity). */
+export interface MessageStats {
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    toolResults: number;
+    totalMessages: number;
+    tokens: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    cost: number;
+}
+/**
+ * Compute token/cost/message-count statistics from a list of agent messages.
+ * Pure function — no facade, no identity fields. Callers needing sessionFile/
+ * sessionId add them on top.
+ */
+export declare function computeMessageStats(messages: AgentMessage[]): MessageStats;
+/** Session statistics for /session command */
+export interface SessionStats {
+    sessionFile: string | undefined;
+    sessionId: string;
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    toolResults: number;
+    totalMessages: number;
+    tokens: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    cost: number;
+    contextUsage?: ContextUsage;
+}

package/dist/core/session-stats.js

@@ -0,0 +1,41 @@
+/**
+ * Compute token/cost/message-count statistics from a list of agent messages.
+ * Pure function — no facade, no identity fields. Callers needing sessionFile/
+ * sessionId add them on top.
+ */
+export function computeMessageStats(messages) {
+    const userMessages = messages.filter((m) => m.role === "user").length;
+    const assistantMessages = messages.filter((m) => m.role === "assistant").length;
+    const toolResults = messages.filter((m) => m.role === "toolResult").length;
+    let toolCalls = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheRead = 0;
+    let totalCacheWrite = 0;
+    let totalCost = 0;
+    for (const message of messages) {
+        if (message.role !== "assistant")
+            continue;
+        toolCalls += message.content.filter((block) => block.type === "toolCall").length;
+        totalInput += message.usage?.input ?? 0;
+        totalOutput += message.usage?.output ?? 0;
+        totalCacheRead += message.usage?.cacheRead ?? 0;
+        totalCacheWrite += message.usage?.cacheWrite ?? 0;
+        totalCost += message.usage?.cost?.total ?? 0;
+    }
+    return {
+        userMessages,
+        assistantMessages,
+        toolCalls,
+        toolResults,
+        totalMessages: messages.length,
+        tokens: {
+            input: totalInput,
+            output: totalOutput,
+            cacheRead: totalCacheRead,
+            cacheWrite: totalCacheWrite,
+            total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
+        },
+        cost: totalCost,
+    };
+}