@jameslovespancakes/pi-plus 1.0.11 → 1.0.13

package/src/domains/workflows/runtime/workflow-run-store.ts

@@ -0,0 +1,176 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { validateWorkflowRunId, workflowRunsDir } from "./journal.ts";
+import type { WorkflowProgressSnapshot } from "./progress-types.ts";
+import {
+  isWorkflowRunRecord,
+  transitionWorkflowRun,
+  updateWorkflowRunProgress,
+  type WorkflowRunRecord,
+  type WorkflowRunTransition,
+} from "./workflow-run-record.ts";
+
+export const WORKFLOW_RUN_RECORD_KEEP = 50;
+export const WORKFLOW_RUN_RECORD_SUFFIX = ".run.json";
+
+const MAX_RECORD_BYTES = 4 << 20;
+
+export interface WorkflowRunStore {
+  save(record: WorkflowRunRecord): Promise<void>;
+  load(runId: string): Promise<WorkflowRunRecord | undefined>;
+  list(): Promise<WorkflowRunRecord[]>;
+  prune(keep?: number): Promise<void>;
+}
+
+export class ProjectWorkflowRunStore implements WorkflowRunStore {
+  private readonly cwd: string;
+
+  constructor(cwd: string) {
+    this.cwd = cwd;
+  }
+
+  async save(record: WorkflowRunRecord): Promise<void> {
+    const path = workflowRunRecordPath(this.cwd, record.runId);
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    const content = `${JSON.stringify(record)}\n`;
+    if (Buffer.byteLength(content) > MAX_RECORD_BYTES) {
+      throw new Error(`Workflow run record exceeded ${MAX_RECORD_BYTES} bytes.`);
+    }
+    await mkdir(dirname(path), { recursive: true });
+    try {
+      await writeFile(temporaryPath, content, { encoding: "utf8", mode: 0o600 });
+      await rename(temporaryPath, path);
+    } finally {
+      await rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  async load(runId: string): Promise<WorkflowRunRecord | undefined> {
+    return await loadWorkflowRunRecord(workflowRunRecordPath(this.cwd, runId));
+  }
+
+  async list(): Promise<WorkflowRunRecord[]> {
+    const dir = workflowRunsDir(this.cwd);
+    let files: string[];
+    try {
+      files = await readdir(dir);
+    } catch {
+      return [];
+    }
+    const records = await Promise.all(
+      files
+        .filter((file) => file.endsWith(WORKFLOW_RUN_RECORD_SUFFIX))
+        .map((file) => loadWorkflowRunRecord(join(dir, file))),
+    );
+    return records
+      .filter((record): record is WorkflowRunRecord => record !== undefined)
+      .sort((left, right) => right.updatedAt - left.updatedAt);
+  }
+
+  async prune(keep = WORKFLOW_RUN_RECORD_KEEP): Promise<void> {
+    const dir = workflowRunsDir(this.cwd);
+    let files: string[];
+    try {
+      files = await readdir(dir);
+    } catch {
+      return;
+    }
+    const candidates = await Promise.all(
+      files
+        .filter((file) => file.endsWith(WORKFLOW_RUN_RECORD_SUFFIX))
+        .map(async (file) => {
+          const path = join(dir, file);
+          try {
+            const info = await stat(path);
+            return { path, mtimeMs: info.mtimeMs };
+          } catch {
+            return undefined;
+          }
+        }),
+    );
+    const stale = candidates
+      .filter((entry): entry is { readonly path: string; readonly mtimeMs: number } => entry !== undefined)
+      .sort((left, right) => right.mtimeMs - left.mtimeMs)
+      .slice(Math.max(0, keep));
+    await Promise.all(stale.map((entry) => rm(entry.path, { force: true }).catch(() => undefined)));
+  }
+}
+
+/** Owns one run record and coalesces progress writes while a prior atomic save is in flight. */
+export class DurableWorkflowRun {
+  private record: WorkflowRunRecord;
+  private pending: WorkflowRunRecord | undefined;
+  private draining: Promise<void> | undefined;
+  private writeFailure: unknown;
+  private writeFailed = false;
+
+  constructor(
+    private readonly store: WorkflowRunStore,
+    initial: WorkflowRunRecord,
+    private readonly onWriteFailure?: (error: unknown) => void,
+  ) {
+    this.record = initial;
+    this.queue(initial);
+  }
+
+  updateProgress(progress: WorkflowProgressSnapshot, at = Date.now()): void {
+    this.record = updateWorkflowRunProgress(this.record, progress, at);
+    this.queue(this.record);
+  }
+
+  transition(transition: WorkflowRunTransition): void {
+    this.record = transitionWorkflowRun(this.record, transition);
+    this.queue(this.record);
+  }
+
+  async flush(): Promise<void> {
+    while (this.draining) await this.draining;
+    if (this.writeFailed) throw this.writeFailure;
+  }
+
+  private queue(record: WorkflowRunRecord): void {
+    this.pending = record;
+    if (this.draining) return;
+    this.draining = this.drain().finally(() => {
+      this.draining = undefined;
+      if (this.pending) this.queue(this.pending);
+    });
+  }
+
+  private async drain(): Promise<void> {
+    while (this.pending) {
+      const next = this.pending;
+      this.pending = undefined;
+      try {
+        await this.store.save(next);
+      } catch (error) {
+        this.writeFailed = true;
+        this.writeFailure = error;
+        try {
+          this.onWriteFailure?.(error);
+        } catch {
+          // Persistence observers must not create an unhandled rejection.
+        }
+      }
+    }
+  }
+}
+
+export function workflowRunRecordPath(cwd: string, runId: string): string {
+  return join(workflowRunsDir(cwd), `${validateWorkflowRunId(runId)}${WORKFLOW_RUN_RECORD_SUFFIX}`);
+}
+
+async function loadWorkflowRunRecord(path: string): Promise<WorkflowRunRecord | undefined> {
+  try {
+    const content = await readFile(path, "utf8");
+    if (Buffer.byteLength(content) > MAX_RECORD_BYTES) return undefined;
+    const parsed = JSON.parse(content) as unknown;
+    if (!isWorkflowRunRecord(parsed)) return undefined;
+    const file = basename(path);
+    const pathRunId = file.slice(0, -WORKFLOW_RUN_RECORD_SUFFIX.length);
+    return parsed.runId === pathRunId ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/domains/workflows/runtime/workflow-usage-limit-scheduler.ts

@@ -0,0 +1,80 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { WorkflowRunRecord } from "./workflow-run-record.ts";
+import { unknownErrorMessage } from "./unknown-error.ts";
+
+export interface WorkflowUsageLimitSchedulerClock {
+  now(): number;
+  setTimeout(callback: () => void, delayMs: number): unknown;
+  clearTimeout(handle: unknown): void;
+}
+
+interface ScheduledUsageLimitResume {
+  readonly sessionId: string;
+  readonly handle: unknown;
+}
+
+export const defaultWorkflowUsageLimitSchedulerClock: WorkflowUsageLimitSchedulerClock = {
+  now: () => Date.now(),
+  setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+  clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+/** One in-process timer per paused run. Durable records remain the source of truth. */
+export class WorkflowUsageLimitScheduler {
+  private readonly scheduled = new Map<string, ScheduledUsageLimitResume>();
+  private readonly inactiveSessions = new Set<string>();
+
+  constructor(
+    private readonly resume: (ctx: ExtensionContext, runId: string, attempt: number) => Promise<void>,
+    private readonly clock: WorkflowUsageLimitSchedulerClock = defaultWorkflowUsageLimitSchedulerClock,
+    private readonly log: (message: string) => void = (message) => process.stderr.write(`${message}\n`),
+  ) {}
+
+  arm(ctx: ExtensionContext, record: WorkflowRunRecord): boolean {
+    if (record.state !== "paused" || record.pause?.kind !== "provider_usage_limit") return false;
+    const pause = record.pause;
+    if (!pause.autoResume || pause.attempt >= pause.maxAttempts) return false;
+    const sessionId = ctx.sessionManager.getSessionId();
+    if (
+      this.inactiveSessions.has(sessionId)
+      || record.background?.origin.sessionId !== sessionId
+      || this.scheduled.has(record.runId)
+    ) {
+      return false;
+    }
+
+    const delayMs = Math.max(0, pause.nextEligibleAt - this.clock.now());
+    const handle = this.clock.setTimeout(() => {
+      this.scheduled.delete(record.runId);
+      void this.resume(ctx, record.runId, pause.attempt).catch((error: unknown) => {
+        this.log(`[workflow:${record.runId}] automatic provider-limit resume failed: ${unknownErrorMessage(error)}`);
+      });
+    }, delayMs);
+    this.scheduled.set(record.runId, { sessionId, handle });
+    return true;
+  }
+
+  cancel(runId: string): boolean {
+    const scheduled = this.scheduled.get(runId);
+    if (!scheduled) return false;
+    this.clock.clearTimeout(scheduled.handle);
+    this.scheduled.delete(runId);
+    return true;
+  }
+
+  cancelSession(ctx: Pick<ExtensionContext, "sessionManager">): void {
+    const sessionId = ctx.sessionManager.getSessionId();
+    this.inactiveSessions.add(sessionId);
+    for (const [runId, scheduled] of this.scheduled) {
+      if (scheduled.sessionId === sessionId) this.cancel(runId);
+    }
+  }
+
+  activateSession(ctx: Pick<ExtensionContext, "sessionManager">): void {
+    this.inactiveSessions.delete(ctx.sessionManager.getSessionId());
+  }
+
+  has(runId: string): boolean {
+    return this.scheduled.has(runId);
+  }
+}

package/src/domains/workflows/runtime/workflows.ts

@@ -0,0 +1,40 @@
+import { fileURLToPath } from "node:url";
+import * as codeReview from "../workflows/code-review.ts";
+import * as refactorScout from "../workflows/refactor-scout.ts";
+import * as diagnose from "../workflows/diagnose.ts";
+import * as perfReview from "../workflows/perf-review.ts";
+import * as research from "../workflows/research.ts";
+import type { WorkflowModule } from "./types.ts";
+
+/**
+ * Static imports share pi's bundled typebox instance. Add guaranteed workflows
+ * here; discovery.ts handles optional drop-ins.
+ */
+export const BUILTIN_SOURCE_ROOT = fileURLToPath(new URL("..", import.meta.url));
+
+export interface BuiltinWorkflowDefinition {
+  readonly module: WorkflowModule;
+  readonly filename: string;
+  readonly path: string;
+  readonly root: string;
+}
+
+export const BUILTIN_WORKFLOW_DEFINITIONS: readonly BuiltinWorkflowDefinition[] = [
+  defineBuiltinWorkflow(codeReview, "code-review.ts"),
+  defineBuiltinWorkflow(refactorScout, "refactor-scout.ts"),
+  defineBuiltinWorkflow(diagnose, "diagnose.ts"),
+  defineBuiltinWorkflow(perfReview, "perf-review.ts"),
+  defineBuiltinWorkflow(research, "research.ts"),
+];
+export const BUILTIN_WORKFLOWS = BUILTIN_WORKFLOW_DEFINITIONS.map(({ module }) => module);
+export const BUILTIN_WORKFLOW_FILES = new Set(BUILTIN_WORKFLOW_DEFINITIONS.map(({ filename }) => filename));
+export const BUILTIN_WORKFLOW_NAMES = BUILTIN_WORKFLOWS.map((mod) => mod.meta.name);
+
+function defineBuiltinWorkflow(module: WorkflowModule, filename: string): BuiltinWorkflowDefinition {
+  return {
+    module: { meta: module.meta, default: module.default },
+    filename,
+    path: fileURLToPath(new URL(`../workflows/${filename}`, import.meta.url)),
+    root: BUILTIN_SOURCE_ROOT,
+  };
+}