@osolmaz/pi-workflows 0.1.0 → 0.3.0

package/src/extension/controller-host.ts

@@ -0,0 +1,163 @@
+import {
+  ControllerManager,
+  SqliteControllerStore,
+  projectControllerStorePath,
+  loadDiscoveredControllers,
+  type AnyControllerDefinition,
+  type ControllerResource,
+  type WorkflowSchedulerRequest,
+  type WorkflowSchedulerResult,
+} from "../controllers/index.js";
+
+export type ParsedControllerArgs =
+  | { kind: "list" }
+  | { kind: "get"; controller: string; key: string }
+  | { kind: "apply"; controller: string; key: string; spec: unknown }
+  | { kind: "reconcile"; controller: string; key: string }
+  | { kind: "delete"; controller: string; key: string }
+  | { kind: "start" }
+  | { kind: "stop" };
+
+export type PiChildWorkflowStarter = (
+  request: WorkflowSchedulerRequest,
+  signal: AbortSignal,
+  onComplete: (result: WorkflowSchedulerResult) => void,
+) => Promise<WorkflowSchedulerResult>;
+
+export function parseControllerArgs(args: string): ParsedControllerArgs {
+  const trimmed = args.trim();
+  if (trimmed.length === 0 || trimmed === "list") {
+    return { kind: "list" };
+  }
+  if (trimmed === "start" || trimmed === "stop") {
+    return { kind: trimmed };
+  }
+  const apply = trimmed.match(/^apply\s+(\S+)\s+(\S+)\s+([\s\S]+)$/);
+  if (apply !== null) {
+    let spec: unknown;
+    try {
+      spec = JSON.parse(apply[3] as string) as unknown;
+    } catch (error) {
+      throw new Error(
+        `Invalid controller spec JSON: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+    return {
+      kind: "apply",
+      controller: apply[1] as string,
+      key: apply[2] as string,
+      spec,
+    };
+  }
+  const operation = trimmed.match(/^(get|reconcile|delete)\s+(\S+)\s+(\S+)$/);
+  if (operation !== null) {
+    return {
+      kind: operation[1] as "get" | "reconcile" | "delete",
+      controller: operation[2] as string,
+      key: operation[3] as string,
+    };
+  }
+  throw new Error(
+    "Usage: /controller [list|get <controller> <key>|apply <controller> <key> <json>|reconcile <controller> <key>|delete <controller> <key>|start|stop]",
+  );
+}
+
+export class PiControllerHost {
+  readonly definitions: AnyControllerDefinition[];
+  readonly store: SqliteControllerStore;
+  readonly manager: ControllerManager;
+  private running = false;
+
+  private constructor(
+    definitions: AnyControllerDefinition[],
+    store: SqliteControllerStore,
+    manager: ControllerManager,
+  ) {
+    this.definitions = definitions;
+    this.store = store;
+    this.manager = manager;
+  }
+
+  static async create(options: {
+    cwd: string;
+    startChild: PiChildWorkflowStarter;
+  }): Promise<PiControllerHost | undefined> {
+    const definitions = await loadDiscoveredControllers({ cwd: options.cwd });
+    if (definitions.length === 0) {
+      return undefined;
+    }
+    const store = new SqliteControllerStore(projectControllerStorePath(options.cwd));
+    const manager = new ControllerManager({
+      store,
+      controllers: definitions,
+      workflowScheduler: { ensure: options.startChild },
+    });
+    return new PiControllerHost(definitions, store, manager);
+  }
+
+  start(): void {
+    this.manager.start();
+    this.running = true;
+  }
+
+  async stop(): Promise<void> {
+    await this.manager.stop();
+    this.running = false;
+  }
+
+  async close(): Promise<void> {
+    await this.stop();
+    this.store.close();
+  }
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+
+  list(): string {
+    const names = this.definitions.map((item) => item.name).join(", ");
+    const resources = this.store.listResources();
+    if (resources.length === 0) {
+      return `Controllers: ${names}. No resources.`;
+    }
+    const rows = resources.map((resource) => resourceSummary(resource)).join("; ");
+    return `Controllers: ${names}. Resources: ${rows}.`;
+  }
+
+  get(controller: string, key: string): string {
+    const resource = this.store.getResource({ controller, key });
+    if (resource === undefined) {
+      throw new Error(`Controller resource not found: ${controller}/${key}`);
+    }
+    return JSON.stringify(
+      {
+        resource,
+        effects: this.store.listEffects(resource.metadata.uid),
+        workflows: this.store.listWorkflows(resource.metadata.uid),
+      },
+      null,
+      2,
+    );
+  }
+
+  apply(controller: string, key: string, spec: unknown): ControllerResource {
+    return this.manager.putResourceByName(controller, key, spec);
+  }
+
+  reconcile(controller: string, key: string): void {
+    this.manager.enqueue({ controller, key });
+  }
+
+  delete(controller: string, key: string): void {
+    this.manager.requestDeletion({ controller, key });
+  }
+}
+
+function resourceSummary(resource: ControllerResource): string {
+  const condition =
+    resource.status.conditions.find((item) => item.type === "Ready") ??
+    resource.status.conditions[0];
+  const state =
+    condition === undefined ? "unknown" : `${String(condition.status)}:${condition.reason}`;
+  return `${resource.metadata.controller}/${resource.metadata.key} generation=${resource.metadata.generation} ready=${state}`;
+}

package/src/extension/executor.ts

@@ -2,6 +2,7 @@ import type {
   AgentStepExecutor,
   AgentStepRequest,
   AgentStepSubmission,
+  ConversationRange,
 } from "../workflows/types.js";
 
 export type SubmissionResult =
@@ -14,11 +15,24 @@ export type PromptDelivery = {
   streaming: boolean;
 };
 
+/**
+ * Bracketing hooks for conversation linkage: a mark is taken when the step
+ * prompt is first delivered, and the recorded entry range since that mark is
+ * attached to the accepted submission.
+ */
+export type ConversationHooks = {
+  beginAttempt?: (contract: AgentStepRequest["contract"]) => void;
+  mark: () => number;
+  rangeSince: (mark: number) => ConversationRange | undefined;
+};
+
 export type ConversationStepExecutorOptions = {
   /** Deliver a prompt into the pi conversation. */
   sendPrompt: (delivery: PromptDelivery) => void;
   /** Reminders sent when the agent settles without submitting. Default 2. */
   maxNudges?: number;
+  /** Conversation linkage hooks, wired to the session recorder. */
+  conversation?: ConversationHooks;
 };
 
 type PendingStep = {
@@ -26,6 +40,8 @@ type PendingStep = {
   resolve: (submission: AgentStepSubmission) => void;
   reject: (error: unknown) => void;
   nudgesSent: number;
+  /** Conversation mark taken when the prompt was first delivered. */
+  mark: number | null;
   cleanup: () => void;
   /** Resolves when this step stops being the pending step. */
   cleared: Promise<void>;
@@ -44,6 +60,7 @@ const DEFAULT_MAX_NUDGES = 2;
 export class ConversationStepExecutor implements AgentStepExecutor {
   private readonly sendPrompt: (delivery: PromptDelivery) => void;
   private readonly maxNudges: number;
+  private readonly conversation: ConversationHooks | undefined;
   private pending: PendingStep | null = null;
   private streaming = false;
   private heldByUser = false;
@@ -51,6 +68,7 @@ export class ConversationStepExecutor implements AgentStepExecutor {
   constructor(options: ConversationStepExecutorOptions) {
     this.sendPrompt = options.sendPrompt;
     this.maxNudges = options.maxNudges ?? DEFAULT_MAX_NUDGES;
+    this.conversation = options.conversation;
   }
 
   /** Track agent streaming state (wire to agent_start / agent_settled). */
@@ -88,6 +106,7 @@ export class ConversationStepExecutor implements AgentStepExecutor {
       return;
     }
     try {
+      this.conversation?.beginAttempt?.(pending.request.contract);
       this.sendPrompt({ prompt: pending.request.prompt, streaming: this.streaming });
     } catch (error) {
       this.clearPending();
@@ -110,11 +129,13 @@ export class ConversationStepExecutor implements AgentStepExecutor {
       const cleared = new Promise<void>((resolveCleared) => {
         markCleared = resolveCleared;
       });
+      this.conversation?.beginAttempt?.(request.contract);
       this.pending = {
         request,
         resolve,
         reject,
         nudgesSent: 0,
+        mark: this.conversation?.mark() ?? null,
         cleanup: () => signal.removeEventListener("abort", onAbort),
         cleared,
         markCleared,
@@ -185,7 +206,12 @@ export class ConversationStepExecutor implements AgentStepExecutor {
       };
     }
     this.clearPending();
-    pending.resolve({ output: result.value });
+    const conversation =
+      pending.mark !== null ? this.conversation?.rangeSince(pending.mark) : undefined;
+    pending.resolve({
+      output: result.value,
+      ...(conversation !== undefined ? { conversation } : {}),
+    });
     return {
       accepted: true,
       message: [
@@ -224,11 +250,12 @@ export class ConversationStepExecutor implements AgentStepExecutor {
     pending.nudgesSent += 1;
     const { nodeId, attemptId } = pending.request.contract;
     try {
+      this.conversation?.beginAttempt?.(pending.request.contract);
       this.sendPrompt({
         prompt: [
           `Reminder: workflow step ${JSON.stringify(nodeId)} is still awaiting your output.`,
           "Complete it by calling the `workflow` tool with:",
-          `{"step": ${JSON.stringify(nodeId)}, "attempt": ${JSON.stringify(attemptId)}, "output": <your result>}`,
+          `{"action": "submit", "step": ${JSON.stringify(nodeId)}, "attempt": ${JSON.stringify(attemptId)}, "output": <your result>}`,
           `Expected output: ${pending.request.contract.expectedOutput ?? "a JSON object with your result"}`,
         ].join("\n"),
         streaming: this.streaming,