@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/sdk.js

@@ -0,0 +1,10 @@
+/**
+ * Public SDK entry point.
+ *
+ * Exposes `createSessionFacade()` as the primary session creation API,
+ * plus tool factories and type exports for extension development.
+ */
+export { createSessionFacade, } from "./session-facade-factory.js";
+export { withFileMutationQueue, 
+// Tool factories (for custom cwd)
+createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, } from "./tools/index.js";

package/dist/core/session-context-builder.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Session Context Builder
+ *
+ * Builds a SessionContext (messages, thinkingLevel, model) from an array
+ * of SessionEntry objects. Extracted from the legacy SessionManager to
+ * allow its removal.
+ */
+import type { SessionContext, SessionEntry } from "./types/session-types.js";
+export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>): SessionContext;

package/dist/core/session-context-builder.js

@@ -0,0 +1,87 @@
+/**
+ * Session Context Builder
+ *
+ * Builds a SessionContext (messages, thinkingLevel, model) from an array
+ * of SessionEntry objects. Extracted from the legacy SessionManager to
+ * allow its removal.
+ */
+import { createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "./messages.js";
+export function buildSessionContext(entries, leafId, byId) {
+    if (!byId) {
+        byId = new Map();
+        for (const entry of entries) {
+            byId.set(entry.id, entry);
+        }
+    }
+    let leaf;
+    if (leafId === null) {
+        return { messages: [], thinkingLevel: "off", model: null };
+    }
+    if (leafId) {
+        leaf = byId.get(leafId);
+    }
+    if (!leaf) {
+        leaf = entries[entries.length - 1];
+    }
+    if (!leaf) {
+        return { messages: [], thinkingLevel: "off", model: null };
+    }
+    const path = [];
+    let current = leaf;
+    while (current) {
+        path.unshift(current);
+        current = current.parentId ? byId.get(current.parentId) : undefined;
+    }
+    let thinkingLevel = "off";
+    let model = null;
+    let compaction = null;
+    for (const entry of path) {
+        if (entry.type === "thinking_level_change") {
+            thinkingLevel = entry.thinkingLevel;
+        }
+        else if (entry.type === "model_change") {
+            model = { provider: entry.provider, modelId: entry.modelId };
+        }
+        else if (entry.type === "message" && entry.message.role === "assistant") {
+            model = { provider: entry.message.provider, modelId: entry.message.model };
+        }
+        else if (entry.type === "compaction") {
+            compaction = entry;
+        }
+    }
+    const messages = [];
+    const appendMessage = (entry) => {
+        if (entry.type === "message") {
+            messages.push(entry.message);
+        }
+        else if (entry.type === "custom_message") {
+            messages.push(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
+        }
+        else if (entry.type === "branch_summary" && entry.summary) {
+            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
+        }
+    };
+    if (compaction) {
+        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
+        const compactionIdx = path.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
+        let foundFirstKept = false;
+        for (let i = 0; i < compactionIdx; i++) {
+            const entry = path[i];
+            if (entry.id === compaction.firstKeptEntryId) {
+                foundFirstKept = true;
+            }
+            if (foundFirstKept) {
+                appendMessage(entry);
+            }
+        }
+        for (let i = compactionIdx + 1; i < path.length; i++) {
+            appendMessage(path[i]);
+        }
+    }
+    else {
+        for (const entry of path) {
+            appendMessage(entry);
+        }
+    }
+    return { messages, thinkingLevel, model };
+}

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

@@ -0,0 +1,18 @@
+export interface SessionCwdIssue {
+    sessionFile?: string;
+    sessionCwd: string;
+    fallbackCwd: string;
+}
+interface SessionCwdSource {
+    getCwd(): string;
+    getSessionFile(): string | undefined;
+}
+export declare function getMissingSessionCwdIssue(sessionManager: SessionCwdSource, fallbackCwd: string): SessionCwdIssue | undefined;
+export declare function formatMissingSessionCwdError(issue: SessionCwdIssue): string;
+export declare function formatMissingSessionCwdPrompt(issue: SessionCwdIssue): string;
+export declare class MissingSessionCwdError extends Error {
+    readonly issue: SessionCwdIssue;
+    constructor(issue: SessionCwdIssue);
+}
+export declare function assertSessionCwdExists(sessionManager: SessionCwdSource, fallbackCwd: string): void;
+export {};

package/dist/core/session-cwd.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+export function getMissingSessionCwdIssue(sessionManager, fallbackCwd) {
+    const sessionFile = sessionManager.getSessionFile();
+    if (!sessionFile) {
+        return undefined;
+    }
+    const sessionCwd = sessionManager.getCwd();
+    if (!sessionCwd || existsSync(sessionCwd)) {
+        return undefined;
+    }
+    return {
+        sessionFile,
+        sessionCwd,
+        fallbackCwd,
+    };
+}
+export function formatMissingSessionCwdError(issue) {
+    const sessionFile = issue.sessionFile ? `\nSession file: ${issue.sessionFile}` : "";
+    return `Stored session working directory does not exist: ${issue.sessionCwd}${sessionFile}\nCurrent working directory: ${issue.fallbackCwd}`;
+}
+export function formatMissingSessionCwdPrompt(issue) {
+    return `cwd from session file does not exist\n${issue.sessionCwd}\n\ncontinue in current cwd\n${issue.fallbackCwd}`;
+}
+export class MissingSessionCwdError extends Error {
+    constructor(issue) {
+        super(formatMissingSessionCwdError(issue));
+        this.name = "MissingSessionCwdError";
+        this.issue = issue;
+    }
+}
+export function assertSessionCwdExists(sessionManager, fallbackCwd) {
+    const issue = getMissingSessionCwdIssue(sessionManager, fallbackCwd);
+    if (issue) {
+        throw new MissingSessionCwdError(issue);
+    }
+}

package/dist/core/session-facade-factory.d.ts

@@ -0,0 +1,79 @@
+/**
+ * SessionFacade factory.
+ *
+ * Builds a fully wired, pure event-sourced session: EventStore (SQLite) +
+ * projection SessionManager + EventSourcedRuntime, wrapped in a SessionFacade.
+ *
+ * This is the primary session creation API. Modes and extensions subscribe
+ * directly to EventStore TypedEvents through the facade.
+ */
+import { type Model } from "@earendil-works/pi-ai/compat";
+import type { ThinkingLevel } from "./agent/index.js";
+import { AuthStorage } from "./auth-storage.js";
+import { type LoadExtensionsResult, type SessionStartEvent, type ToolDefinition as ExtensionToolDefinition } from "./extensions/index.js";
+import { ModelRegistry } from "./model-registry.js";
+import { type ResourceLoader } from "./resource-loader.js";
+import { EventSourcedRuntime } from "./runtime/runtime.js";
+import { SessionFacade } from "./session-facade.js";
+import { SettingsManager } from "./settings-manager.js";
+export interface CreateSessionFacadeOptions {
+    /** Working directory for project-local discovery. Default: process.cwd() */
+    cwd?: string;
+    /** Global config directory. Default: ~/.pizza/agent */
+    agentDir?: string;
+    /** Auth storage for credentials. */
+    authStorage?: AuthStorage;
+    /** Model registry. */
+    modelRegistry?: ModelRegistry;
+    /** Settings manager. */
+    settingsManager?: SettingsManager;
+    /** Resource loader (skills/context/extensions/system prompt). */
+    resourceLoader?: ResourceLoader;
+    /** Model to use. Default: resolved from settings/registry. */
+    model?: Model<any>;
+    /** Thinking level. Default: from settings, clamped to model capabilities. */
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Allowlist of tool names to expose to the LLM.
+     * Default: DEFAULT_LLM_TOOLS (["cli"]) plus custom/extension tools.
+     */
+    tools?: string[];
+    /** Custom tools to register (in addition to built-in and extension tools). */
+    customTools?: ExtensionToolDefinition[];
+    /** Session start event metadata for extension runtime startup. */
+    sessionStartEvent?: SessionStartEvent;
+    /** Override SQLite event database path (e.g. ":memory:" for tests). */
+    storagePath?: string;
+    /** Override session index path. */
+    sessionIndexPath?: string;
+    /** Override workspace id when opening a session from another workspace. */
+    workspaceId?: string;
+    /** Existing projection session id to activate before prompting. */
+    sessionId?: string;
+    /** Existing projection session to fork into the target workspace before prompting. */
+    forkFrom?: {
+        workspaceId: string;
+        sessionId: string;
+        agentDir?: string;
+    };
+    /** Context token budget. Default: model.contextWindow ?? 128000. */
+    contextBudget?: number;
+}
+export interface CreateSessionFacadeResult {
+    /** The created facade. */
+    facade: SessionFacade;
+    /** The underlying runtime (escape hatch for advanced wiring). */
+    runtime: EventSourcedRuntime;
+    /** Resolved model. */
+    model: Model<any> | undefined;
+    /** Resolved thinking level. */
+    thinkingLevel: ThinkingLevel;
+    /** Extensions result (for UI context setup in interactive mode). */
+    extensionsResult: LoadExtensionsResult;
+    /** Warning if no model could be resolved. */
+    modelFallbackMessage?: string;
+}
+/**
+ * Create a pure event-sourced SessionFacade.
+ */
+export declare function createSessionFacade(options?: CreateSessionFacadeOptions): Promise<CreateSessionFacadeResult>;