@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/goal/scheduler.js

@@ -0,0 +1,154 @@
+/**
+ * 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 { GoalProjection } from "../projection/goal-projection.js";
+// ============================================================================
+// Default Policy
+// ============================================================================
+/**
+ * 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 class DefaultSchedulingPolicy {
+    selectTasks(readyTasks, _goal, context) {
+        const slots = context.maxConcurrency - context.runningTasks.length;
+        if (slots <= 0)
+            return [];
+        // Sort by priority
+        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        const sorted = [...readyTasks].sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+        return sorted.slice(0, slots).map((task) => ({
+            task_id: task.task_id,
+            assigned_to: this._inferRole(task),
+        }));
+    }
+    _inferRole(task) {
+        const title = task.title.toLowerCase();
+        if (title.includes("test") || title.includes("spec"))
+            return "tester";
+        if (title.includes("review") || title.includes("audit"))
+            return "reviewer";
+        if (title.includes("plan") || title.includes("design"))
+            return "planner";
+        return "worker";
+    }
+}
+/**
+ * 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 class GoalScheduler {
+    constructor(store, options) {
+        this.store = store;
+        this.projection = new GoalProjection(store);
+        this.policy = options?.policy ?? new DefaultSchedulingPolicy();
+        this.maxConcurrency = options?.maxConcurrency ?? 1;
+        this.projection.rebuild();
+        if (options?.autoStart !== false) {
+            this.start();
+        }
+    }
+    /**
+     * Start watching for task lifecycle events.
+     */
+    start() {
+        if (this.unsubscribe)
+            return;
+        this.projection.startLive();
+        this.unsubscribe = this.store.subscribe((event) => this._onEvent(event), {
+            types: [
+                "GOAL_PLANNED",
+                "TASK_COMPLETED",
+                "TASK_ACCEPTED",
+                "TASK_FAILED",
+            ],
+        });
+    }
+    /**
+     * Stop watching.
+     */
+    stop() {
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.projection.stopLive();
+    }
+    /**
+     * Manually trigger scheduling for a goal.
+     */
+    scheduleGoal(goalId) {
+        this._tryDispatch(goalId);
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    _onEvent(event) {
+        const payload = event.payload;
+        if (event.type === "GOAL_PLANNED" && payload.goal_id) {
+            this._tryDispatch(payload.goal_id);
+            return;
+        }
+        // For task events, find the goal_id from the task
+        if (payload.task_id) {
+            const task = this.projection.getTask(payload.task_id);
+            if (task) {
+                this._tryDispatch(task.goal_id);
+            }
+        }
+    }
+    _tryDispatch(goalId) {
+        const goal = this.projection.getGoal(goalId);
+        if (!goal)
+            return;
+        if (goal.status === "completed" || goal.status === "cancelled")
+            return;
+        const allTasks = this.projection.getTasksForGoal(goalId);
+        const readyTasks = this.projection.getReadyTasks(goalId);
+        const runningTasks = allTasks.filter((t) => t.status === "started" || t.status === "in_progress" || t.status === "assigned");
+        if (readyTasks.length === 0) {
+            // Check if all tasks are done — if so, complete the goal
+            const allDone = allTasks.every((t) => t.status === "completed" || t.status === "accepted" || t.status === "cancelled");
+            if (allDone && allTasks.length > 0) {
+                this.store.append({
+                    actor_id: "runtime",
+                    type: "GOAL_COMPLETED",
+                    payload: { goal_id: goalId, summary: "All tasks completed" },
+                    caused_by: this.store.head,
+                });
+            }
+            return;
+        }
+        const assignments = this.policy.selectTasks(readyTasks, goal, {
+            allTasks,
+            runningTasks,
+            maxConcurrency: this.maxConcurrency,
+        });
+        for (const assignment of assignments) {
+            this.store.append({
+                actor_id: "runtime",
+                type: "TASK_ASSIGNED",
+                payload: {
+                    task_id: assignment.task_id,
+                    assigned_to: assignment.assigned_to,
+                },
+                caused_by: this.store.head,
+            });
+        }
+    }
+}

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

@@ -0,0 +1,182 @@
+/**
+ * Goal & Task Types
+ *
+ * Data model for long-running goals and their decomposed tasks.
+ * Goals are top-level user objectives that may span multiple sessions.
+ * Tasks are concrete work items within a goal.
+ *
+ * All state is derived from EventStore events — these types represent
+ * the projected view of that state.
+ */
+/** Goal status derived from event stream */
+export type GoalStatus = "created" | "classified" | "planned" | "running" | "paused" | "completed" | "cancelled";
+/** Whether a goal is short-running (single session) or long-running (multi-session) */
+export type GoalClassification = "short_running" | "long_running";
+/** Goal phase — maps to sessions within the goal */
+export type GoalPhase = "planning" | "implementation" | "testing" | "review" | "rework";
+/** Projected goal state (derived from events, not stored directly) */
+export interface GoalDescriptor {
+    /** Unique goal identifier */
+    goal_id: string;
+    /** Workspace this goal belongs to */
+    workspace_id: string;
+    /** Current status */
+    status: GoalStatus;
+    /** Classification (if classified) */
+    classification?: GoalClassification;
+    /** Current phase */
+    phase?: GoalPhase;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description or user request */
+    description?: string;
+    /** Event that created this goal */
+    root_event_id: string;
+    /** Task references (task_ids) */
+    task_ids: string[];
+    /** Active session ID (if running) */
+    active_session_id?: string;
+    /** Acceptance criteria (from planning) */
+    acceptance_criteria?: string[];
+    /** Timestamp of creation */
+    created_at: number;
+    /** Timestamp of last status change */
+    updated_at: number;
+}
+/** Task status derived from event stream */
+export type TaskStatus = "created" | "assigned" | "started" | "in_progress" | "completed" | "failed" | "rework" | "accepted" | "cancelled";
+/** Task priority */
+export type TaskPriority = "critical" | "high" | "medium" | "low";
+/** Agent role that can be assigned to a task */
+export type AgentRole = "planner" | "worker" | "tester" | "reviewer" | "memory" | "skill";
+/** Projected task state (derived from events) */
+export interface TaskDescriptor {
+    /** Unique task identifier */
+    task_id: string;
+    /** Parent goal ID */
+    goal_id: string;
+    /** Current status */
+    status: TaskStatus;
+    /** Human-readable title */
+    title: string;
+    /** Detailed specification */
+    description?: string;
+    /** Assigned agent role */
+    assigned_to?: AgentRole;
+    /** Task priority */
+    priority: TaskPriority;
+    /** Dependencies — task_ids that must complete before this one */
+    depends_on: string[];
+    /** Session ID where this task is being worked on */
+    session_id?: string;
+    /** Event that created this task */
+    root_event_id: string;
+    /** Acceptance criteria specific to this task */
+    acceptance_criteria?: string[];
+    /** Progress notes (from TASK_PROGRESS events) */
+    progress_notes: string[];
+    /** Generated or agent-provided task summary */
+    summary?: string;
+    /** Failure message (if status is "failed") */
+    failure_message?: string;
+    /** Rework reason (if status is "rework") */
+    rework_reason?: string;
+    /** Cancellation reason (if status is "cancelled") */
+    cancel_reason?: string;
+    /** Timestamp of creation */
+    created_at: number;
+    /** Timestamp of last status change */
+    updated_at: number;
+}
+/** Payload for GOAL_CREATED event */
+export interface GoalCreatedPayload {
+    goal_id: string;
+    title: string;
+    description?: string;
+    /** User message that triggered goal creation */
+    source_message?: string;
+}
+/** Payload for GOAL_CLASSIFIED event */
+export interface GoalClassifiedPayload {
+    goal_id: string;
+    classification: GoalClassification;
+    reason?: string;
+}
+/** Payload for GOAL_PLANNED event */
+export interface GoalPlannedPayload {
+    goal_id: string;
+    task_ids: string[];
+    acceptance_criteria?: string[];
+    plan_summary?: string;
+}
+/** Payload for GOAL_PAUSED / GOAL_RESUMED event */
+export interface GoalLifecyclePayload {
+    goal_id: string;
+    reason?: string;
+}
+/** Payload for GOAL_COMPLETED event */
+export interface GoalCompletedPayload {
+    goal_id: string;
+    summary?: string;
+}
+/** Payload for GOAL_CANCELLED event */
+export interface GoalCancelledPayload {
+    goal_id: string;
+    reason?: string;
+}
+/** Payload for TASK_CREATED event */
+export interface TaskCreatedPayload {
+    task_id: string;
+    goal_id: string;
+    title: string;
+    description?: string;
+    priority: TaskPriority;
+    depends_on?: string[];
+    acceptance_criteria?: string[];
+}
+/** Payload for TASK_ASSIGNED event */
+export interface TaskAssignedPayload {
+    task_id: string;
+    assigned_to: AgentRole;
+    session_id?: string;
+}
+/** Payload for TASK_STARTED event */
+export interface TaskStartedPayload {
+    task_id: string;
+    session_id: string;
+}
+/** Payload for TASK_PROGRESS event */
+export interface TaskProgressPayload {
+    task_id: string;
+    note: string;
+    /** Progress percentage 0-100 */
+    percentage?: number;
+}
+/** Payload for TASK_COMPLETED event */
+export interface TaskCompletedPayload {
+    task_id: string;
+    summary?: string;
+}
+/** Payload for TASK_FAILED event */
+export interface TaskFailedPayload {
+    task_id: string;
+    error_message: string;
+}
+/** Payload for TASK_REWORK_REQUESTED event */
+export interface TaskReworkPayload {
+    task_id: string;
+    reason: string;
+    /** Event ID of the review that triggered rework */
+    review_event_id?: string;
+}
+/** Payload for TASK_ACCEPTED event */
+export interface TaskAcceptedPayload {
+    task_id: string;
+    /** Event ID of the acceptance review */
+    review_event_id?: string;
+}
+/** Payload for TASK_CANCELLED event */
+export interface TaskCancelledPayload {
+    task_id: string;
+    reason?: string;
+}

package/dist/core/goal/types.js

@@ -0,0 +1,11 @@
+/**
+ * Goal & Task Types
+ *
+ * Data model for long-running goals and their decomposed tasks.
+ * Goals are top-level user objectives that may span multiple sessions.
+ * Tasks are concrete work items within a goal.
+ *
+ * All state is derived from EventStore events — these types represent
+ * the projected view of that state.
+ */
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core modules shared between all run modes.
+ */
+export { type BashExecutorOptions, type BashResult, executeBashWithOperations } from "./bash-executor.js";
+export type { CompactionResult } from "./compaction/index.js";
+export { createEventBus, type EventBus, type EventBusController } from "./event-bus.js";
+export { type AgentEndEvent, type AgentStartEvent, type AgentToolResult, type AgentToolUpdateCallback, type BeforeAgentStartEvent, type BeforeAgentStartEventResult, type BuildSystemPromptOptions, type ContextEvent, defineTool, discoverAndLoadExtensions, type ExecOptions, type ExecResult, type Extension, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ExtensionError, type ExtensionEvent, type ExtensionFactory, type ExtensionFlag, type ExtensionHandler, ExtensionRunner, type ExtensionShortcut, type ExtensionUIContext, type LoadExtensionsResult, type MessageRenderer, type RegisteredCommand, type SessionBeforeCompactEvent, type SessionBeforeForkEvent, type SessionBeforeSwitchEvent, type SessionBeforeTreeEvent, type SessionCompactEvent, type SessionShutdownEvent, type SessionStartEvent, type SessionTreeEvent, type ToolCallEvent, type ToolCallEventResult, type ToolDefinition, type ToolRenderResultOptions, type ToolResultEvent, type TurnEndEvent, type TurnStartEvent, type WorkingIndicatorOptions, } from "./extensions/index.js";
+export { createSyntheticSourceInfo } from "./source-info.js";

package/dist/core/index.js

@@ -0,0 +1,8 @@
+/**
+ * Core modules shared between all run modes.
+ */
+export { executeBashWithOperations } from "./bash-executor.js";
+export { createEventBus } from "./event-bus.js";
+// Extensions system
+export { defineTool, discoverAndLoadExtensions, ExtensionRunner, } from "./extensions/index.js";
+export { createSyntheticSourceInfo } from "./source-info.js";

package/dist/core/intent/classifier.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Intent Classifier
+ *
+ * Classifies LLM-proposed tool calls by risk level and approval requirements.
+ */
+import type { IntentClassification, IntentCategory } from "./types.js";
+export interface ClassifierConfig {
+    /** Require user approval before file writes. */
+    require_approval_writes?: boolean;
+    /** Require user approval before file edits. */
+    require_approval_edits?: boolean;
+    /** Require user approval before moderate shell commands. */
+    require_approval_shell_moderate?: boolean;
+    /** Require user approval before unknown tools. */
+    require_approval_unknown?: boolean;
+    /** @deprecated Use require_approval_writes. Historical alias. */
+    approve_writes?: boolean;
+    /** @deprecated Use require_approval_edits. Historical alias. */
+    approve_edits?: boolean;
+    /** @deprecated Use require_approval_shell_moderate. Historical alias. */
+    approve_shell_moderate?: boolean;
+    /** @deprecated Use require_approval_unknown. Historical alias. */
+    approve_unknown?: boolean;
+}
+/**
+ * Classifies tool calls by risk level and approval requirements.
+ *
+ * Default policy:
+ * - file_read, shell_safe: auto-approve
+ * - file_write, network, unknown: require approval (configurable)
+ * - shell_moderate: auto-approve by default (configurable)
+ * - file_delete, shell_dangerous: always require approval
+ */
+export declare class IntentClassifier {
+    private config;
+    constructor(config?: ClassifierConfig);
+    /**
+     * Classify a tool call by name and arguments.
+     */
+    classify(toolName: string, args: Record<string, unknown>): IntentClassification;
+    /**
+     * Classify a bash command by its content.
+     */
+    private _classifyBashCommand;
+    /**
+     * Classify a builtin command.
+     */
+    private _classifyBuiltinCommand;
+    /**
+     * Classify by intent category directly.
+     */
+    classifyByCategory(category: IntentCategory, args: Record<string, unknown>): IntentClassification;
+}