@gotgenes/pi-subagents 1.0.2 → 3.0.0

package/src/cross-extension-rpc.ts

@@ -1,95 +0,0 @@
-/**
- * Cross-extension RPC handlers for the subagents extension.
- *
- * Exposes ping, spawn, and stop RPCs over the pi.events event bus,
- * using per-request scoped reply channels.
- *
- * Reply envelope follows pi-mono convention:
- *   success → { success: true, data?: T }
- *   error   → { success: false, error: string }
- */
-
-/** Minimal event bus interface needed by the RPC handlers. */
-export interface EventBus {
-  on(event: string, handler: (data: unknown) => void): () => void;
-  emit(event: string, data: unknown): void;
-}
-
-/** RPC reply envelope — matches pi-mono's RpcResponse shape. */
-export type RpcReply<T = void> =
-  | { success: true; data?: T }
-  | { success: false; error: string };
-
-/** RPC protocol version — bumped when the envelope or method contracts change. */
-export const PROTOCOL_VERSION = 2;
-
-/** Minimal AgentManager interface needed by the spawn/stop RPCs. */
-export interface SpawnCapable {
-  spawn(pi: unknown, ctx: unknown, type: string, prompt: string, options: any): string;
-  abort(id: string): boolean;
-}
-
-export interface RpcDeps {
-  events: EventBus;
-  pi: unknown;                    // passed through to manager.spawn
-  getCtx: () => unknown | undefined;  // returns current ExtensionContext
-  manager: SpawnCapable;
-}
-
-export interface RpcHandle {
-  unsubPing: () => void;
-  unsubSpawn: () => void;
-  unsubStop: () => void;
-}
-
-/**
- * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
- * emit the reply envelope on `channel:reply:${requestId}`.
- */
-function handleRpc<P extends { requestId: string }>(
-  events: EventBus,
-  channel: string,
-  fn: (params: P) => unknown | Promise<unknown>,
-): () => void {
-  return events.on(channel, async (raw: unknown) => {
-    const params = raw as P;
-    try {
-      const data = await fn(params);
-      const reply: { success: true; data?: unknown } = { success: true };
-      if (data !== undefined) reply.data = data;
-      events.emit(`${channel}:reply:${params.requestId}`, reply);
-    } catch (err: any) {
-      events.emit(`${channel}:reply:${params.requestId}`, {
-        success: false, error: err?.message ?? String(err),
-      });
-    }
-  });
-}
-
-/**
- * Register ping, spawn, and stop RPC handlers on the event bus.
- * Returns unsub functions for cleanup.
- */
-export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
-  const { events, pi, getCtx, manager } = deps;
-
-  const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
-    return { version: PROTOCOL_VERSION };
-  });
-
-  const unsubSpawn = handleRpc<{ requestId: string; type: string; prompt: string; options?: any }>(
-    events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
-      const ctx = getCtx();
-      if (!ctx) throw new Error("No active session");
-      return { id: manager.spawn(pi, ctx, type, prompt, options ?? {}) };
-    },
-  );
-
-  const unsubStop = handleRpc<{ requestId: string; agentId: string }>(
-    events, "subagents:rpc:stop", ({ agentId }) => {
-      if (!manager.abort(agentId)) throw new Error("Agent not found");
-    },
-  );
-
-  return { unsubPing, unsubSpawn, unsubStop };
-}

package/src/group-join.ts

@@ -1,141 +0,0 @@
-/**
- * group-join.ts — Manages grouped background agent completion notifications.
- *
- * Instead of each agent individually nudging the main agent on completion,
- * agents in a group are held until all complete (or a timeout fires),
- * then a single consolidated notification is sent.
- */
-
-import type { AgentRecord } from "./types.js";
-
-export type DeliveryCallback = (records: AgentRecord[], partial: boolean) => void;
-
-interface AgentGroup {
-  groupId: string;
-  agentIds: Set<string>;
-  completedRecords: Map<string, AgentRecord>;
-  timeoutHandle?: ReturnType<typeof setTimeout>;
-  delivered: boolean;
-  /** Shorter timeout for stragglers after a partial delivery. */
-  isStraggler: boolean;
-}
-
-/** Default timeout: 30s after first completion in a group. */
-const DEFAULT_TIMEOUT = 30_000;
-/** Straggler re-batch timeout: 15s. */
-const STRAGGLER_TIMEOUT = 15_000;
-
-export class GroupJoinManager {
-  private groups = new Map<string, AgentGroup>();
-  private agentToGroup = new Map<string, string>();
-
-  constructor(
-    private deliverCb: DeliveryCallback,
-    private groupTimeout = DEFAULT_TIMEOUT,
-  ) {}
-
-  /** Register a group of agent IDs that should be joined. */
-  registerGroup(groupId: string, agentIds: string[]): void {
-    const group: AgentGroup = {
-      groupId,
-      agentIds: new Set(agentIds),
-      completedRecords: new Map(),
-      delivered: false,
-      isStraggler: false,
-    };
-    this.groups.set(groupId, group);
-    for (const id of agentIds) {
-      this.agentToGroup.set(id, groupId);
-    }
-  }
-
-  /**
-   * Called when an agent completes.
-   * Returns:
-   * - 'pass'      — agent is not grouped, caller should send individual nudge
-   * - 'held'      — result held, waiting for group completion
-   * - 'delivered'  — this completion triggered the group notification
-   */
-  onAgentComplete(record: AgentRecord): 'delivered' | 'held' | 'pass' {
-    const groupId = this.agentToGroup.get(record.id);
-    if (!groupId) return 'pass';
-
-    const group = this.groups.get(groupId);
-    if (!group || group.delivered) return 'pass';
-
-    group.completedRecords.set(record.id, record);
-
-    // All done — deliver immediately
-    if (group.completedRecords.size >= group.agentIds.size) {
-      this.deliver(group, false);
-      return 'delivered';
-    }
-
-    // First completion in this batch — start timeout
-    if (!group.timeoutHandle) {
-      const timeout = group.isStraggler ? STRAGGLER_TIMEOUT : this.groupTimeout;
-      group.timeoutHandle = setTimeout(() => {
-        this.onTimeout(group);
-      }, timeout);
-    }
-
-    return 'held';
-  }
-
-  private onTimeout(group: AgentGroup): void {
-    if (group.delivered) return;
-    group.timeoutHandle = undefined;
-
-    // Partial delivery — some agents still running
-    const remaining = new Set<string>();
-    for (const id of group.agentIds) {
-      if (!group.completedRecords.has(id)) remaining.add(id);
-    }
-
-    // Clean up agentToGroup for delivered agents (they won't complete again)
-    for (const id of group.completedRecords.keys()) {
-      this.agentToGroup.delete(id);
-    }
-
-    // Deliver what we have
-    this.deliverCb([...group.completedRecords.values()], true);
-
-    // Set up straggler group for remaining agents
-    group.completedRecords.clear();
-    group.agentIds = remaining;
-    group.isStraggler = true;
-    // Timeout will be started when the next straggler completes
-  }
-
-  private deliver(group: AgentGroup, partial: boolean): void {
-    if (group.timeoutHandle) {
-      clearTimeout(group.timeoutHandle);
-      group.timeoutHandle = undefined;
-    }
-    group.delivered = true;
-    this.deliverCb([...group.completedRecords.values()], partial);
-    this.cleanupGroup(group.groupId);
-  }
-
-  private cleanupGroup(groupId: string): void {
-    const group = this.groups.get(groupId);
-    if (!group) return;
-    for (const id of group.agentIds) {
-      this.agentToGroup.delete(id);
-    }
-    this.groups.delete(groupId);
-  }
-
-  /** Check if an agent is in a group. */
-  isGrouped(agentId: string): boolean {
-    return this.agentToGroup.has(agentId);
-  }
-
-  dispose(): void {
-    for (const group of this.groups.values()) {
-      if (group.timeoutHandle) clearTimeout(group.timeoutHandle);
-    }
-    this.groups.clear();
-    this.agentToGroup.clear();
-  }
-}

package/src/schedule-store.ts

@@ -1,143 +0,0 @@
-/**
- * schedule-store.ts — File-backed store for scheduled subagents.
- *
- * Session-scoped: each pi session owns its own schedules at
- * `<cwd>/.pi/subagent-schedules/<sessionId>.json`. `/new` starts a fresh
- * empty store; `/resume` reloads.
- *
- * Concurrency model lifted from pi-chonky-tasks/src/task-store.ts: every
- * mutation acquires a PID-based exclusion lock, re-reads the latest state
- * from disk, applies the change, atomic-writes via temp+rename, releases.
- */
-
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import type { ScheduledSubagent, ScheduleStoreData } from "./types.js";
-
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
-
-function isProcessRunning(pid: number): boolean {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-function acquireLock(lockPath: string): void {
-  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
-    try {
-      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
-      return;
-    } catch (e: any) {
-      if (e.code === "EEXIST") {
-        try {
-          const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-          if (pid && !isProcessRunning(pid)) {
-            unlinkSync(lockPath);
-            continue;
-          }
-        } catch { /* ignore — try again */ }
-        const start = Date.now();
-        while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
-        continue;
-      }
-      throw e;
-    }
-  }
-  throw new Error(`Failed to acquire schedule lock: ${lockPath}`);
-}
-
-function releaseLock(lockPath: string): void {
-  try { unlinkSync(lockPath); } catch { /* ignore */ }
-}
-
-/** Resolve the storage path for a session-scoped store. */
-export function resolveStorePath(cwd: string, sessionId: string): string {
-  return join(cwd, ".pi", "subagent-schedules", `${sessionId}.json`);
-}
-
-export class ScheduleStore {
-  private filePath: string;
-  private lockPath: string;
-  private jobs = new Map<string, ScheduledSubagent>();
-
-  constructor(filePath: string) {
-    this.filePath = filePath;
-    this.lockPath = filePath + ".lock";
-    mkdirSync(dirname(filePath), { recursive: true });
-    this.load();
-  }
-
-  /** Load from disk into the in-memory cache. Silent on parse errors. */
-  private load(): void {
-    if (!existsSync(this.filePath)) return;
-    try {
-      const data: ScheduleStoreData = JSON.parse(readFileSync(this.filePath, "utf-8"));
-      this.jobs.clear();
-      for (const j of data.jobs ?? []) this.jobs.set(j.id, j);
-    } catch { /* corrupt — start fresh, next save rewrites */ }
-  }
-
-  /** Atomic write via temp file + rename (POSIX-atomic). */
-  private save(): void {
-    const data: ScheduleStoreData = { version: 1, jobs: [...this.jobs.values()] };
-    const tmp = this.filePath + ".tmp";
-    writeFileSync(tmp, JSON.stringify(data, null, 2));
-    renameSync(tmp, this.filePath);
-  }
-
-  /** Acquire lock → reload → mutate → save → release. */
-  private withLock<T>(fn: () => T): T {
-    acquireLock(this.lockPath);
-    try {
-      this.load();
-      const result = fn();
-      this.save();
-      return result;
-    } finally {
-      releaseLock(this.lockPath);
-    }
-  }
-
-  /** Read-only — returns a snapshot of the in-memory cache. */
-  list(): ScheduledSubagent[] {
-    return [...this.jobs.values()];
-  }
-
-  /** Read-only check — uses the cache. */
-  hasName(name: string, exceptId?: string): boolean {
-    for (const j of this.jobs.values()) {
-      if (j.id !== exceptId && j.name === name) return true;
-    }
-    return false;
-  }
-
-  get(id: string): ScheduledSubagent | undefined {
-    return this.jobs.get(id);
-  }
-
-  add(job: ScheduledSubagent): void {
-    this.withLock(() => {
-      this.jobs.set(job.id, job);
-    });
-  }
-
-  update(id: string, patch: Partial<ScheduledSubagent>): ScheduledSubagent | undefined {
-    return this.withLock(() => {
-      const existing = this.jobs.get(id);
-      if (!existing) return undefined;
-      const updated = { ...existing, ...patch };
-      this.jobs.set(id, updated);
-      return updated;
-    });
-  }
-
-  remove(id: string): boolean {
-    return this.withLock(() => this.jobs.delete(id));
-  }
-
-  /** Delete the backing file (used when no jobs remain, optional cleanup). */
-  deleteFileIfEmpty(): void {
-    if (this.jobs.size === 0 && existsSync(this.filePath)) {
-      try { unlinkSync(this.filePath); } catch { /* ignore */ }
-    }
-  }
-}