@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/slash/result-delivery.ts

@@ -1,312 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey } from "@earendil-works/pi-tui";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import { errorMessage, isRecord } from "../shared/unknown.ts";
-import { isTuiContext } from "../shared/ui-mode.ts";
-import {
-  SLASH_RESULT_TYPE,
-  SLASH_SUBAGENT_CANCEL_EVENT,
-  SLASH_SUBAGENT_REQUEST_EVENT,
-  SLASH_SUBAGENT_RESPONSE_EVENT,
-  SLASH_SUBAGENT_STARTED_EVENT,
-  SLASH_SUBAGENT_UPDATE_EVENT,
-  type SingleResult,
-} from "../shared/types.ts";
-import type { SlashSubagentResponse } from "./slash-bridge.ts";
-import {
-  applySlashUpdate,
-  buildSlashInitialResult,
-  failSlashResult,
-  finalizeSlashResult,
-} from "./slash-live-state.ts";
-import { slashResponse, slashUpdate } from "./request-protocol.ts";
-
-interface RequestCallbacks {
-  readonly active: () => boolean;
-  readonly started: () => void;
-  readonly response: (response: ReadonlyInput<SlashSubagentResponse>) => void;
-  readonly failed: (error: Readonly<Error>) => void;
-}
-
-function disposeSubscriptions(subscriptions: readonly (() => void)[]): void {
-  for (const unsubscribe of subscriptions) {
-    try {
-      unsubscribe();
-    } catch (error) {
-      console.error("Could not unsubscribe slash subagent request:", error);
-    }
-  }
-}
-
-function subscribeRequest(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  requestId: string,
-  callbacks: RequestCallbacks,
-): () => void {
-  const subscriptions: Array<() => void> = [];
-  const dispose = (): void => {
-    disposeSubscriptions(subscriptions);
-  };
-  try {
-    subscriptions.push(
-      pi.events.on(SLASH_SUBAGENT_STARTED_EVENT, (data) => {
-        if (callbacks.active() && isRecord(data) && data.requestId === requestId) {
-          callbacks.started();
-          if (ctx.hasUI) {
-            ctx.ui.setStatus("subagent-slash", "running...");
-          }
-        }
-      }),
-    );
-    subscriptions.push(
-      pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, (data) => {
-        if (!callbacks.active()) {
-          return;
-        }
-        try {
-          const parsed = slashResponse(data, requestId);
-          if (parsed) {
-            callbacks.response(parsed);
-          }
-        } catch (error) {
-          if (!(error instanceof Error)) {
-            throw error;
-          }
-          callbacks.failed(error);
-        }
-      }),
-    );
-    subscriptions.push(
-      pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, (data) => {
-        if (!callbacks.active()) {
-          return;
-        }
-        const parsed = slashUpdate(data, requestId);
-        if (!parsed) {
-          return;
-        }
-        applySlashUpdate(requestId, parsed);
-        if (ctx.hasUI) {
-          const tool = parsed.currentTool ?? "";
-          ctx.ui.setStatus(
-            "subagent-slash",
-            `${parsed.toolCount ?? 0} tools${tool.length > 0 ? ` ${tool}` : ""}`,
-          );
-        }
-      }),
-    );
-    const terminal = isTuiContext(ctx)
-      ? ctx.ui.onTerminalInput((input) => {
-          if (!callbacks.active() || !matchesKey(input, Key.escape)) {
-            return;
-          }
-          pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
-          callbacks.failed(new Error("Cancelled"));
-          return { consume: true };
-        })
-      : undefined;
-    if (terminal) {
-      subscriptions.push(terminal);
-    }
-    return dispose;
-  } catch (error) {
-    dispose();
-    throw error;
-  }
-}
-
-class PendingSlashRequest {
-  private readonly pending = Promise.withResolvers<SlashSubagentResponse>();
-  private readonly timer: ReturnType<typeof setTimeout>;
-  private started = false;
-  private settled = false;
-
-  constructor() {
-    this.timer = setTimeout(
-      () =>
-        this.fail(
-          new Error(
-            "Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly.",
-          ),
-        ),
-      15_000,
-    );
-  }
-
-  active(): boolean {
-    return !this.settled;
-  }
-  admitted(): boolean {
-    return this.started;
-  }
-  result(): Promise<SlashSubagentResponse> {
-    return this.pending.promise;
-  }
-  start(): void {
-    this.started = true;
-    clearTimeout(this.timer);
-  }
-  respond(response: ReadonlyInput<SlashSubagentResponse>): void {
-    if (this.settled) {
-      return;
-    }
-    this.settled = true;
-    clearTimeout(this.timer);
-    this.pending.resolve(response);
-  }
-  fail(error: Readonly<Error>): void {
-    if (this.settled) {
-      return;
-    }
-    this.settled = true;
-    clearTimeout(this.timer);
-    this.pending.reject(error);
-  }
-  dispose(): void {
-    clearTimeout(this.timer);
-  }
-}
-
-async function requestSlashRun(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  request: {
-    readonly requestId: string;
-    readonly params: ReadonlyInput<SubagentParamsLike>;
-    readonly executionCwd?: string;
-  },
-): Promise<SlashSubagentResponse> {
-  const pending = new PendingSlashRequest();
-  let dispose: (() => void) | undefined;
-  try {
-    dispose = subscribeRequest(pi, ctx, request.requestId, {
-      active: () => pending.active(),
-      started: () => {
-        pending.start();
-      },
-      response: (response) => {
-        pending.respond(response);
-      },
-      failed: (error) => {
-        pending.fail(error);
-      },
-    });
-    pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, request);
-    // STARTED is synchronous: its absence means no bridge admitted this request.
-    if (!pending.admitted() && pending.active()) {
-      pending.fail(
-        new Error(
-          "No slash subagent bridge responded. Ensure the subagent extension is loaded correctly.",
-        ),
-      );
-    }
-    return await pending.result();
-  } catch (error) {
-    // A synchronous response may settle before a later subscription or bus listener fails.
-    if (!pending.active()) {
-      return await pending.result();
-    }
-    throw error;
-  } finally {
-    pending.dispose();
-    dispose?.();
-  }
-}
-
-function messageText(content: ReadonlyInput<SlashSubagentResponse["result"]["content"]>): string {
-  return content
-    .filter((part) => part.type === "text")
-    .map((part) => part.text)
-    .join("\n");
-}
-
-function resultPaths(
-  results: ReadonlyInput<SingleResult[]>,
-  getPath: (result: ReadonlyInput<SingleResult>) => string | undefined,
-): string[] {
-  return results
-    .map(getPath)
-    .filter((file): file is string => file !== undefined && file.length > 0);
-}
-
-function fallbackText(text: string): string {
-  return text.length > 0 ? text : "(no output)";
-}
-
-function exportText(response: SlashSubagentResponse): string {
-  const output = messageText(response.result.content);
-  const results = response.result.details.results;
-  const fallback = response.errorText ?? "";
-  const sections = ["## Subagent result", output.length > 0 ? output : fallbackText(fallback)];
-  for (const [title, paths] of [
-    ["Child session exports", resultPaths(results, (result) => result.sessionFile)],
-    ["Saved outputs", resultPaths(results, (result) => result.savedOutputPath)],
-    ["Artifact outputs", resultPaths(results, (result) => result.artifactPaths?.outputPath)],
-  ] as const) {
-    if (paths.length > 0) {
-      sections.push(`## ${title}`, paths.map((file) => `- \`${file}\``).join("\n"));
-    }
-  }
-  return sections.join("\n\n");
-}
-
-function finishSlashStatus(
-  ctx: ExtensionContext,
-  response: ReadonlyInput<SlashSubagentResponse>,
-): void {
-  if (!ctx.hasUI) {
-    return;
-  }
-  ctx.ui.setStatus("subagent-slash", undefined);
-  if (response.isError) {
-    const error = response.errorText ?? "";
-    ctx.ui.notify(error.length > 0 ? error : "Subagent failed", "error");
-  }
-}
-
-export async function runSlashSubagent(
-  pi: ExtensionAPI,
-  ctx: ExtensionContext,
-  params: ReadonlyInput<SubagentParamsLike>,
-  executionCwd?: string,
-): Promise<void> {
-  const requestId = randomUUID();
-  const initialDetails = buildSlashInitialResult(requestId, params);
-  const text = messageText(initialDetails.result.content);
-  pi.sendMessage({
-    customType: SLASH_RESULT_TYPE,
-    content: text.length > 0 ? text : "Running subagent...",
-    display: true,
-    details: initialDetails,
-  });
-  try {
-    const response = await requestSlashRun(pi, ctx, {
-      requestId,
-      params,
-      ...(executionCwd !== undefined && executionCwd.length > 0 ? { executionCwd } : {}),
-    });
-    const finalDetails = finalizeSlashResult(response);
-    pi.sendMessage({
-      customType: SLASH_RESULT_TYPE,
-      content: exportText(response),
-      display: false,
-      details: finalDetails,
-    });
-    finishSlashStatus(ctx, response);
-  } catch (error) {
-    const message = errorMessage(error);
-    pi.sendMessage({
-      customType: SLASH_RESULT_TYPE,
-      content: `## Subagent result\n\n${message}`,
-      display: false,
-      details: failSlashResult(requestId, params, message),
-    });
-    if (ctx.hasUI) {
-      ctx.ui.setStatus("subagent-slash", undefined);
-      ctx.ui.notify(message, message === "Cancelled" ? "warning" : "error");
-    }
-  }
-}

package/src/slash/saved-chain.ts

@@ -1,115 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ChainConfig, JsonSchemaObject } from "../shared/types/config.ts";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import { isRecord, isUnknownArray } from "../shared/unknown.ts";
-import { assertJsonSchemaObject } from "../runs/shared/structured-output.ts";
-import {
-  normalizeSubagentParamsLike,
-  type SubagentParamsLike,
-} from "../runs/foreground/subagent-executor.ts";
-
-type RuntimeStep = NonNullable<SubagentParamsLike["chain"]>[number];
-
-function loadOutputSchema(
-  chain: ReadonlyInput<ChainConfig>,
-  agent: string,
-  value: unknown,
-): JsonSchemaObject | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-  if (typeof value === "string") {
-    const file = path.isAbsolute(value) ? value : path.join(path.dirname(chain.filePath), value);
-    const parsed: unknown = JSON.parse(fs.readFileSync(file, "utf-8"));
-    assertJsonSchemaObject(
-      parsed,
-      `outputSchema for chain '${chain.name}' step '${agent}' (${file})`,
-    );
-    return parsed;
-  }
-  assertJsonSchemaObject(value, `outputSchema for chain '${chain.name}' step '${agent}'`);
-  return value;
-}
-
-function taskWithSchema(
-  chain: ReadonlyInput<ChainConfig>,
-  task: unknown,
-): Readonly<Record<string, unknown>> {
-  if (!isRecord(task) || typeof task.agent !== "string") {
-    throw new Error(`Chain '${chain.name}' contains a task without an agent.`);
-  }
-  const { outputSchema: raw, ...rest } = task;
-  const outputSchema = loadOutputSchema(chain, task.agent, raw);
-  return { ...rest, ...(outputSchema !== undefined ? { outputSchema } : {}) };
-}
-
-function dynamicStep(
-  chain: ReadonlyInput<ChainConfig>,
-  step: Readonly<Record<string, unknown>>,
-): Readonly<Record<string, unknown>> {
-  if (!isRecord(step.collect) || typeof step.collect.as !== "string") {
-    throw new Error(`Chain '${chain.name}' dynamic collection requires an output name.`);
-  }
-  const schema = loadOutputSchema(
-    chain,
-    `${step.collect.as} collection`,
-    step.collect.outputSchema,
-  );
-  return {
-    ...step,
-    parallel: taskWithSchema(chain, step.parallel),
-    collect: { ...step.collect, ...(schema !== undefined ? { outputSchema: schema } : {}) },
-  };
-}
-
-function nonempty(value: unknown): boolean {
-  return typeof value === "string" && value.length > 0;
-}
-
-function sequentialStep(
-  chain: ReadonlyInput<ChainConfig>,
-  step: Readonly<Record<string, unknown>>,
-): Readonly<Record<string, unknown>> {
-  if (typeof step.agent !== "string") {
-    throw new Error(`Chain '${chain.name}' contains a step without an agent.`);
-  }
-  const outputSchema = loadOutputSchema(chain, step.agent, step.outputSchema);
-  const named: Record<string, unknown> = {};
-  for (const key of ["task", "phase", "label", "as"] as const) {
-    if (nonempty(step[key])) {
-      named[key] = step[key];
-    }
-  }
-  return {
-    agent: step.agent,
-    ...named,
-    ...(step.cwd !== undefined ? { cwd: step.cwd } : {}),
-    ...(outputSchema !== undefined ? { outputSchema } : {}),
-    output: step.output,
-    outputMode: step.outputMode,
-    reads: step.reads,
-    progress: step.progress,
-    skill: step.skill ?? step.skills,
-    model: step.model,
-    ...(step.acceptance !== undefined ? { acceptance: step.acceptance } : {}),
-  };
-}
-
-function resolveStep(
-  chain: ReadonlyInput<ChainConfig>,
-  step: Readonly<Record<string, unknown>>,
-): Readonly<Record<string, unknown>> {
-  if (isUnknownArray(step.parallel)) {
-    return { ...step, parallel: step.parallel.map((task) => taskWithSchema(chain, task)) };
-  }
-  return "expand" in step && "collect" in step && "parallel" in step
-    ? dynamicStep(chain, step)
-    : sequentialStep(chain, step);
-}
-
-/** Resolve file schemas before the executor's canonical argument decoder owns the runtime shape. */
-export function mapSavedChainSteps(chain: ReadonlyInput<ChainConfig>): RuntimeStep[] {
-  const steps = chain.steps.map((step) => resolveStep(chain, { ...step }));
-  return [...(normalizeSubagentParamsLike({ chain: steps }).chain ?? [])];
-}

package/src/slash/slash-bridge.ts

@@ -1,224 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  normalizeSubagentParamsLike,
-  type SubagentParamsLike,
-  type SubagentExecutionRequest,
-} from "../runs/foreground/subagent-executor.ts";
-import { errorMessage, isRecord } from "../shared/unknown.ts";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import {
-  SLASH_SUBAGENT_CANCEL_EVENT,
-  SLASH_SUBAGENT_REQUEST_EVENT,
-  SLASH_SUBAGENT_RESPONSE_EVENT,
-  SLASH_SUBAGENT_STARTED_EVENT,
-  SLASH_SUBAGENT_UPDATE_EVENT,
-  type Details,
-  type SubagentExecutionResult,
-} from "../shared/types.ts";
-
-interface SlashSubagentRequest {
-  readonly requestId: string;
-  readonly params: ReadonlyInput<SubagentParamsLike>;
-  /** Reuse slash discovery's captured directory without changing the native session context. */
-  readonly executionCwd?: string;
-}
-
-export interface SlashSubagentResponse {
-  readonly requestId: string;
-  readonly result: ReadonlyInput<SubagentExecutionResult>;
-  readonly isError: boolean;
-  readonly errorText?: string;
-}
-
-export interface SlashSubagentUpdate {
-  readonly requestId: string;
-  readonly progress?: ReadonlyInput<Details["progress"]>;
-  readonly currentTool?: string;
-  readonly toolCount?: number;
-}
-
-interface EventBus {
-  // Retained adapter buses may return no unsubscribe function, including an explicit void contract.
-  // oxlint-disable-next-line typescript/no-invalid-void-type
-  readonly on: (event: string, handler: (data: unknown) => void) => (() => void) | void;
-  readonly emit: (event: string, data: unknown) => void;
-}
-
-interface SlashBridgeOptions {
-  readonly events: EventBus;
-  readonly getContext: () => ExtensionContext | null;
-  readonly execute: (request: SubagentExecutionRequest) => Promise<SubagentExecutionResult>;
-}
-
-function failedResponse(
-  requestId: string,
-  errorText: string,
-  content = errorText,
-): SlashSubagentResponse {
-  return {
-    requestId,
-    isError: true,
-    errorText,
-    result: {
-      content: [{ type: "text", text: content }],
-      details: { mode: "single", results: [] },
-    },
-  };
-}
-
-class SlashBridge {
-  private readonly options: SlashBridgeOptions;
-  private readonly controllers = new Map<string, AbortController>();
-  private readonly pendingCancels = new Set<string>();
-  private readonly subscriptions: Array<() => void> = [];
-  private readonly pending = new Set<Promise<void>>();
-
-  constructor(options: SlashBridgeOptions) {
-    this.options = options;
-  }
-
-  register(): void {
-    this.subscribe(SLASH_SUBAGENT_CANCEL_EVENT, (data) => this.cancel(data));
-    this.subscribe(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-      const operation = this.receive(data);
-      this.pending.add(operation);
-      operation
-        .finally(() => {
-          this.pending.delete(operation);
-        })
-        .catch((error: unknown) => {
-          console.error("Slash subagent bridge failed:", error);
-        });
-    });
-  }
-
-  private subscribe(event: string, handler: (data: unknown) => void): void {
-    const unsubscribe = this.options.events.on(event, handler);
-    if (typeof unsubscribe === "function") {
-      this.subscriptions.push(unsubscribe);
-    }
-  }
-
-  private cancel(data: unknown): void {
-    if (!isRecord(data) || typeof data.requestId !== "string") {
-      return;
-    }
-    const controller = this.controllers.get(data.requestId);
-    if (controller) {
-      controller.abort();
-    } else {
-      this.pendingCancels.add(data.requestId);
-    }
-  }
-
-  private respond(response: SlashSubagentResponse): void {
-    this.options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
-  }
-
-  private async receive(data: unknown): Promise<void> {
-    if (!isRecord(data) || typeof data.requestId !== "string" || data.params === undefined) {
-      return;
-    }
-    const requestId = data.requestId;
-    const ctx = this.options.getContext();
-    if (!ctx) {
-      this.respond(
-        failedResponse(
-          requestId,
-          "No active extension context.",
-          "No active extension context for slash subagent execution.",
-        ),
-      );
-      return;
-    }
-    if (!isRecord(data.params)) {
-      this.respond(failedResponse(requestId, "Slash subagent parameters must be an object."));
-      return;
-    }
-    let request: SlashSubagentRequest;
-    try {
-      request = {
-        requestId,
-        params: normalizeSubagentParamsLike(data.params),
-        ...(typeof data.executionCwd === "string" ? { executionCwd: data.executionCwd } : {}),
-      };
-    } catch (error) {
-      this.respond(failedResponse(requestId, errorMessage(error)));
-      return;
-    }
-    const controller = new AbortController();
-    this.controllers.set(requestId, controller);
-    if (this.pendingCancels.delete(requestId)) {
-      controller.abort();
-      this.respond(failedResponse(requestId, "Cancelled before start.", "Cancelled."));
-      this.controllers.delete(requestId);
-      return;
-    }
-    this.options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
-    await this.execute(request, controller.signal, ctx);
-  }
-
-  private async execute(
-    request: SlashSubagentRequest,
-    signal: AbortSignal,
-    ctx: ExtensionContext,
-  ): Promise<void> {
-    try {
-      const result = await this.options.execute({
-        toolCallId: request.requestId,
-        params: request.params,
-        signal,
-        onUpdate: (update) => {
-          const progress = update.details.progress;
-          const first = progress?.at(0);
-          this.options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, {
-            requestId: request.requestId,
-            progress,
-            currentTool: first?.currentTool,
-            toolCount: first?.toolCount,
-          });
-        },
-        ctx,
-        executionCwd: request.executionCwd,
-      });
-      this.respond({
-        requestId: request.requestId,
-        result,
-        isError: result.isError === true,
-        errorText:
-          result.isError === true
-            ? result.content.find((part) => part.type === "text")?.text
-            : undefined,
-      });
-    } catch (error) {
-      this.respond(failedResponse(request.requestId, errorMessage(error)));
-    } finally {
-      this.controllers.delete(request.requestId);
-    }
-  }
-
-  cancelAll(): void {
-    for (const controller of this.controllers.values()) {
-      controller.abort();
-    }
-    this.controllers.clear();
-    this.pendingCancels.clear();
-  }
-
-  dispose(): void {
-    for (const unsubscribe of this.subscriptions) {
-      unsubscribe();
-    }
-    this.subscriptions.length = 0;
-    this.pendingCancels.clear();
-  }
-}
-
-export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
-  cancelAll: () => void;
-  dispose: () => void;
-} {
-  const bridge = new SlashBridge(options);
-  bridge.register();
-  return { cancelAll: () => bridge.cancelAll(), dispose: () => bridge.dispose() };
-}