@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/extensions/types.js

@@ -0,0 +1,44 @@
+/**
+ * Extension system types.
+ *
+ * Extensions are TypeScript modules that can:
+ * - Subscribe to agent lifecycle events
+ * - Register LLM-callable tools
+ * - Register commands, keyboard shortcuts, and CLI flags
+ * - Interact with the user via UI primitives
+ */
+/**
+ * Preserve parameter inference for standalone tool definitions.
+ *
+ * Use this when assigning a tool to a variable or passing it through arrays such
+ * as `customTools`, where contextual typing would otherwise widen params to
+ * `unknown`.
+ */
+export function defineTool(tool) {
+    return tool;
+}
+// Type guards for ToolResultEvent
+export function isBashToolResult(e) {
+    return e.toolName === "bash";
+}
+export function isReadToolResult(e) {
+    return e.toolName === "read";
+}
+export function isEditToolResult(e) {
+    return e.toolName === "edit";
+}
+export function isWriteToolResult(e) {
+    return e.toolName === "write";
+}
+export function isGrepToolResult(e) {
+    return e.toolName === "grep";
+}
+export function isFindToolResult(e) {
+    return e.toolName === "find";
+}
+export function isLsToolResult(e) {
+    return e.toolName === "ls";
+}
+export function isToolCallEventType(toolName, event) {
+    return event.toolName === toolName;
+}

package/dist/core/extensions/wrapper.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tool wrappers for extension-registered tools.
+ *
+ * These wrappers only adapt tool execution so extension tools receive the runner context.
+ * Tool call and tool result interception is handled by the reactor via hooks.
+ */
+import type { AgentTool } from "../agent/types.js";
+import type { ExtensionRunner } from "./runner.js";
+import type { RegisteredTool } from "./types.js";
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export declare function wrapRegisteredTool(registeredTool: RegisteredTool, runner: ExtensionRunner): AgentTool;
+/**
+ * Wrap all registered tools into AgentTools.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export declare function wrapRegisteredTools(registeredTools: RegisteredTool[], runner: ExtensionRunner): AgentTool[];

package/dist/core/extensions/wrapper.js

@@ -0,0 +1,21 @@
+/**
+ * Tool wrappers for extension-registered tools.
+ *
+ * These wrappers only adapt tool execution so extension tools receive the runner context.
+ * Tool call and tool result interception is handled by the reactor via hooks.
+ */
+import { wrapToolDefinition, wrapToolDefinitions } from "../tools/tool-definition-wrapper.js";
+/**
+ * Wrap a RegisteredTool into an AgentTool.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTool(registeredTool, runner) {
+    return wrapToolDefinition(registeredTool.definition, () => runner.createContext());
+}
+/**
+ * Wrap all registered tools into AgentTools.
+ * Uses the runner's createContext() for consistent context across tools and event handlers.
+ */
+export function wrapRegisteredTools(registeredTools, runner) {
+    return wrapToolDefinitions(registeredTools.map((registeredTool) => registeredTool.definition), () => runner.createContext());
+}

package/dist/core/footer-data-provider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Provides git branch and extension statuses - data not otherwise accessible to extensions.
+ * Token stats, model info available via ctx.sessionManager and ctx.model.
+ */
+export declare class FooterDataProvider {
+    private cwd;
+    private static readonly WATCH_DEBOUNCE_MS;
+    private extensionStatuses;
+    private cachedBranch;
+    private gitPaths;
+    private headWatcher;
+    private reftableWatcher;
+    private reftableTablesListWatcher;
+    private reftableTablesListPath;
+    private branchChangeCallbacks;
+    private availableProviderCount;
+    private refreshTimer;
+    private refreshInFlight;
+    private refreshPending;
+    private disposed;
+    constructor(cwd: string);
+    /** Current git branch, null if not in repo, "detached" if detached HEAD */
+    getGitBranch(): string | null;
+    /** Extension status texts set via ctx.ui.setStatus() */
+    getExtensionStatuses(): ReadonlyMap<string, string>;
+    /** Subscribe to git branch changes. Returns unsubscribe function. */
+    onBranchChange(callback: () => void): () => void;
+    /** Internal: set extension status */
+    setExtensionStatus(key: string, text: string | undefined): void;
+    /** Internal: clear extension statuses */
+    clearExtensionStatuses(): void;
+    /** Number of unique providers with available models (for footer display) */
+    getAvailableProviderCount(): number;
+    /** Internal: update available provider count */
+    setAvailableProviderCount(count: number): void;
+    setCwd(cwd: string): void;
+    /** Internal: cleanup */
+    dispose(): void;
+    private notifyBranchChange;
+    private scheduleRefresh;
+    private refreshGitBranchAsync;
+    private resolveGitBranchSync;
+    private resolveGitBranchAsync;
+    private setupGitWatcher;
+}
+/** Read-only view for extensions - excludes setExtensionStatus, setAvailableProviderCount and dispose */
+export type ReadonlyFooterDataProvider = Pick<FooterDataProvider, "getGitBranch" | "getExtensionStatuses" | "getAvailableProviderCount" | "onBranchChange">;

package/dist/core/footer-data-provider.js

@@ -0,0 +1,321 @@
+import { execFile, spawnSync } from "child_process";
+import { existsSync, readFileSync, statSync, unwatchFile, watch, watchFile } from "fs";
+import { dirname, join, resolve } from "path";
+/**
+ * Find git metadata paths by walking up from cwd.
+ * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
+ */
+function findGitPaths(cwd) {
+    let dir = cwd;
+    while (true) {
+        const gitPath = join(dir, ".git");
+        if (existsSync(gitPath)) {
+            try {
+                const stat = statSync(gitPath);
+                if (stat.isFile()) {
+                    const content = readFileSync(gitPath, "utf8").trim();
+                    if (content.startsWith("gitdir: ")) {
+                        const gitDir = resolve(dir, content.slice(8).trim());
+                        const headPath = join(gitDir, "HEAD");
+                        if (!existsSync(headPath))
+                            return null;
+                        const commonDirPath = join(gitDir, "commondir");
+                        const commonGitDir = existsSync(commonDirPath)
+                            ? resolve(gitDir, readFileSync(commonDirPath, "utf8").trim())
+                            : gitDir;
+                        return { repoDir: dir, commonGitDir, headPath };
+                    }
+                }
+                else if (stat.isDirectory()) {
+                    const headPath = join(gitPath, "HEAD");
+                    if (!existsSync(headPath))
+                        return null;
+                    return { repoDir: dir, commonGitDir: gitPath, headPath };
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/** Ask git for the current branch. Returns null on detached HEAD or if git is unavailable. */
+function resolveBranchWithGitSync(repoDir) {
+    const result = spawnSync("git", ["--no-optional-locks", "symbolic-ref", "--quiet", "--short", "HEAD"], {
+        cwd: repoDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    const branch = result.status === 0 ? result.stdout.trim() : "";
+    return branch || null;
+}
+/** Ask git for the current branch asynchronously. Returns null on detached HEAD or if git is unavailable. */
+function resolveBranchWithGitAsync(repoDir) {
+    return new Promise((resolvePromise) => {
+        execFile("git", ["--no-optional-locks", "symbolic-ref", "--quiet", "--short", "HEAD"], {
+            cwd: repoDir,
+            encoding: "utf8",
+        }, (error, stdout) => {
+            if (error) {
+                resolvePromise(null);
+                return;
+            }
+            const branch = stdout.trim();
+            resolvePromise(branch || null);
+        });
+    });
+}
+function closeOnWatchError(watcher) {
+    watcher.on("error", () => {
+        try {
+            watcher.close();
+        }
+        catch { }
+    });
+    return watcher;
+}
+/**
+ * Provides git branch and extension statuses - data not otherwise accessible to extensions.
+ * Token stats, model info available via ctx.sessionManager and ctx.model.
+ */
+export class FooterDataProvider {
+    static { this.WATCH_DEBOUNCE_MS = 500; }
+    constructor(cwd) {
+        this.extensionStatuses = new Map();
+        this.cachedBranch = undefined;
+        this.gitPaths = undefined;
+        this.headWatcher = null;
+        this.reftableWatcher = null;
+        this.reftableTablesListWatcher = null;
+        this.reftableTablesListPath = null;
+        this.branchChangeCallbacks = new Set();
+        this.availableProviderCount = 0;
+        this.refreshTimer = null;
+        this.refreshInFlight = false;
+        this.refreshPending = false;
+        this.disposed = false;
+        this.cwd = cwd;
+        this.gitPaths = findGitPaths(cwd);
+        this.setupGitWatcher();
+    }
+    /** Current git branch, null if not in repo, "detached" if detached HEAD */
+    getGitBranch() {
+        if (this.cachedBranch === undefined) {
+            this.cachedBranch = this.resolveGitBranchSync();
+        }
+        return this.cachedBranch;
+    }
+    /** Extension status texts set via ctx.ui.setStatus() */
+    getExtensionStatuses() {
+        return this.extensionStatuses;
+    }
+    /** Subscribe to git branch changes. Returns unsubscribe function. */
+    onBranchChange(callback) {
+        this.branchChangeCallbacks.add(callback);
+        return () => this.branchChangeCallbacks.delete(callback);
+    }
+    /** Internal: set extension status */
+    setExtensionStatus(key, text) {
+        if (text === undefined) {
+            this.extensionStatuses.delete(key);
+        }
+        else {
+            this.extensionStatuses.set(key, text);
+        }
+    }
+    /** Internal: clear extension statuses */
+    clearExtensionStatuses() {
+        this.extensionStatuses.clear();
+    }
+    /** Number of unique providers with available models (for footer display) */
+    getAvailableProviderCount() {
+        return this.availableProviderCount;
+    }
+    /** Internal: update available provider count */
+    setAvailableProviderCount(count) {
+        this.availableProviderCount = count;
+    }
+    setCwd(cwd) {
+        if (this.cwd === cwd) {
+            return;
+        }
+        this.cwd = cwd;
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (this.headWatcher) {
+            this.headWatcher.close();
+            this.headWatcher = null;
+        }
+        if (this.reftableWatcher) {
+            this.reftableWatcher.close();
+            this.reftableWatcher = null;
+        }
+        if (this.reftableTablesListWatcher) {
+            this.reftableTablesListWatcher.close();
+            this.reftableTablesListWatcher = null;
+        }
+        if (this.reftableTablesListPath) {
+            unwatchFile(this.reftableTablesListPath);
+            this.reftableTablesListPath = null;
+        }
+        this.cachedBranch = undefined;
+        this.gitPaths = findGitPaths(cwd);
+        this.setupGitWatcher();
+        this.notifyBranchChange();
+    }
+    /** Internal: cleanup */
+    dispose() {
+        this.disposed = true;
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (this.headWatcher) {
+            this.headWatcher.close();
+            this.headWatcher = null;
+        }
+        if (this.reftableWatcher) {
+            this.reftableWatcher.close();
+            this.reftableWatcher = null;
+        }
+        if (this.reftableTablesListWatcher) {
+            this.reftableTablesListWatcher.close();
+            this.reftableTablesListWatcher = null;
+        }
+        if (this.reftableTablesListPath) {
+            unwatchFile(this.reftableTablesListPath);
+            this.reftableTablesListPath = null;
+        }
+        this.branchChangeCallbacks.clear();
+    }
+    notifyBranchChange() {
+        for (const cb of this.branchChangeCallbacks)
+            cb();
+    }
+    scheduleRefresh() {
+        if (this.disposed || this.refreshTimer)
+            return;
+        if (this.refreshInFlight) {
+            this.refreshPending = true;
+            return;
+        }
+        this.refreshTimer = setTimeout(() => {
+            this.refreshTimer = null;
+            void this.refreshGitBranchAsync();
+        }, FooterDataProvider.WATCH_DEBOUNCE_MS);
+    }
+    async refreshGitBranchAsync() {
+        if (this.disposed)
+            return;
+        if (this.refreshInFlight) {
+            this.refreshPending = true;
+            return;
+        }
+        this.refreshInFlight = true;
+        try {
+            const nextBranch = await this.resolveGitBranchAsync();
+            if (this.disposed)
+                return;
+            if (this.cachedBranch !== undefined && this.cachedBranch !== nextBranch) {
+                this.cachedBranch = nextBranch;
+                this.notifyBranchChange();
+                return;
+            }
+            this.cachedBranch = nextBranch;
+        }
+        finally {
+            this.refreshInFlight = false;
+            if (this.refreshPending && !this.disposed) {
+                this.refreshPending = false;
+                this.scheduleRefresh();
+            }
+        }
+    }
+    resolveGitBranchSync() {
+        try {
+            if (!this.gitPaths)
+                return null;
+            const content = readFileSync(this.gitPaths.headPath, "utf8").trim();
+            if (content.startsWith("ref: refs/heads/")) {
+                const branch = content.slice(16);
+                return branch === ".invalid" ? (resolveBranchWithGitSync(this.gitPaths.repoDir) ?? "detached") : branch;
+            }
+            return "detached";
+        }
+        catch {
+            return null;
+        }
+    }
+    async resolveGitBranchAsync() {
+        try {
+            if (!this.gitPaths)
+                return null;
+            const content = readFileSync(this.gitPaths.headPath, "utf8").trim();
+            if (content.startsWith("ref: refs/heads/")) {
+                const branch = content.slice(16);
+                return branch === ".invalid"
+                    ? ((await resolveBranchWithGitAsync(this.gitPaths.repoDir)) ?? "detached")
+                    : branch;
+            }
+            return "detached";
+        }
+        catch {
+            return null;
+        }
+    }
+    setupGitWatcher() {
+        if (!this.gitPaths)
+            return;
+        // Watch the directory containing HEAD, not HEAD itself.
+        // Git uses atomic writes (write temp, rename over HEAD), which changes the inode.
+        // fs.watch on a file stops working after the inode changes.
+        try {
+            this.headWatcher = closeOnWatchError(watch(dirname(this.gitPaths.headPath), (_eventType, filename) => {
+                if (!filename || filename.toString() === "HEAD") {
+                    this.scheduleRefresh();
+                }
+            }));
+        }
+        catch {
+            // Silently fail if we can't watch
+        }
+        // In reftable repos, branch switches update files in the reftable directory
+        // instead of HEAD. Watch it separately so the footer picks up those changes.
+        const reftableDir = join(this.gitPaths.commonGitDir, "reftable");
+        if (existsSync(reftableDir)) {
+            try {
+                this.reftableWatcher = closeOnWatchError(watch(reftableDir, () => {
+                    this.scheduleRefresh();
+                }));
+            }
+            catch {
+                // Silently fail if we can't watch
+            }
+            const tablesListPath = join(reftableDir, "tables.list");
+            if (existsSync(tablesListPath)) {
+                this.reftableTablesListPath = tablesListPath;
+                try {
+                    this.reftableTablesListWatcher = closeOnWatchError(watch(tablesListPath, () => {
+                        this.scheduleRefresh();
+                    }));
+                }
+                catch {
+                    // Silently fail if we can't watch
+                }
+                watchFile(tablesListPath, { interval: 250 }, (current, previous) => {
+                    if (current.mtimeMs !== previous.mtimeMs ||
+                        current.ctimeMs !== previous.ctimeMs ||
+                        current.size !== previous.size) {
+                        this.scheduleRefresh();
+                    }
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export type { GoalStatus, GoalClassification, GoalPhase, GoalDescriptor, TaskStatus, TaskPriority, AgentRole, TaskDescriptor, GoalCreatedPayload, GoalClassifiedPayload, GoalPlannedPayload, GoalLifecyclePayload, GoalCompletedPayload, GoalCancelledPayload, TaskCreatedPayload, TaskAssignedPayload, TaskStartedPayload, TaskProgressPayload, TaskCompletedPayload, TaskFailedPayload, TaskReworkPayload, TaskAcceptedPayload, TaskCancelledPayload, } from "./types.js";
+export { GoalScheduler, DefaultSchedulingPolicy } from "./scheduler.js";
+export type { SchedulingPolicy, SchedulingContext, TaskAssignment, GoalSchedulerOptions } from "./scheduler.js";

package/dist/core/goal/index.js

@@ -0,0 +1 @@
+export { GoalScheduler, DefaultSchedulingPolicy } from "./scheduler.js";

package/dist/core/goal/scheduler.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Goal Scheduler
+ *
+ * Watches the EventStore for task completions and automatically
+ * dispatches the next ready tasks. A lightweight scheduler that
+ * does NOT execute tasks itself — it only emits TASK_ASSIGNED events
+ * for ready tasks, and the runtime decides how to execute them.
+ *
+ * Design principle: the scheduler is a projection + policy.
+ * It reads events to understand state, applies a scheduling policy,
+ * and emits new events to drive execution.
+ */
+import type { EventStore } from "../event-store/store.js";
+import type { AgentRole, GoalDescriptor, TaskDescriptor } from "./types.js";
+/** Scheduling policy — decides which tasks to dispatch and in what order */
+export interface SchedulingPolicy {
+    /** Select which ready tasks to assign, and to whom */
+    selectTasks(readyTasks: TaskDescriptor[], goal: GoalDescriptor, context: SchedulingContext): TaskAssignment[];
+}
+/** Context available to the scheduling policy */
+export interface SchedulingContext {
+    /** All tasks in the goal */
+    allTasks: TaskDescriptor[];
+    /** Currently running tasks */
+    runningTasks: TaskDescriptor[];
+    /** Maximum concurrent tasks allowed */
+    maxConcurrency: number;
+}
+/** A task assignment decision */
+export interface TaskAssignment {
+    task_id: string;
+    assigned_to: AgentRole;
+}
+/**
+ * DefaultSchedulingPolicy — FIFO with role inference from task content.
+ *
+ * Rules:
+ * 1. Respects maxConcurrency (won't assign more tasks than allowed)
+ * 2. Assigns tasks in priority order (critical > high > medium > low)
+ * 3. Infers agent role from task title keywords
+ */
+export declare class DefaultSchedulingPolicy implements SchedulingPolicy {
+    selectTasks(readyTasks: TaskDescriptor[], _goal: GoalDescriptor, context: SchedulingContext): TaskAssignment[];
+    private _inferRole;
+}
+export interface GoalSchedulerOptions {
+    /** Maximum concurrent tasks per goal (default: 1) */
+    maxConcurrency?: number;
+    /** Scheduling policy (default: DefaultSchedulingPolicy) */
+    policy?: SchedulingPolicy;
+    /** Auto-start on construction (default: true) */
+    autoStart?: boolean;
+}
+/**
+ * GoalScheduler watches task lifecycle events and auto-dispatches ready tasks.
+ *
+ * Usage:
+ *   const scheduler = new GoalScheduler(store, { maxConcurrency: 2 });
+ *   // ... scheduler emits TASK_ASSIGNED events when tasks become ready
+ *   scheduler.stop();
+ */
+export declare class GoalScheduler {
+    private store;
+    private projection;
+    private policy;
+    private maxConcurrency;
+    private unsubscribe?;
+    constructor(store: EventStore, options?: GoalSchedulerOptions);
+    /**
+     * Start watching for task lifecycle events.
+     */
+    start(): void;
+    /**
+     * Stop watching.
+     */
+    stop(): void;
+    /**
+     * Manually trigger scheduling for a goal.
+     */
+    scheduleGoal(goalId: string): void;
+    private _onEvent;
+    private _tryDispatch;
+}