@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/slash/slash-commands.ts

@@ -1,195 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import { errorMessage } from "../shared/unknown.ts";
-import { resolveExecutionCwd } from "../shared/execution-cwd.ts";
-import {
-  assertCommandTask,
-  extractExecutionFlags,
-  inlineOverrides,
-  parseAgentArgs,
-  parseSavedChainArgs,
-  parseSingleArgs,
-  type ExecutionFlags,
-} from "./command-input.ts";
-import {
-  assertKnownAgents,
-  discoverSavedChains,
-  makeAgentCompletions,
-  makeChainCompletions,
-  type SlashDiscoveryState,
-} from "./command-discovery.ts";
-import { mapSavedChainSteps } from "./saved-chain.ts";
-import { runSlashSubagent } from "./result-delivery.ts";
-
-type Params = ReadonlyInput<SubagentParamsLike>;
-
-function executionFlags(args: string): ExecutionFlags {
-  const flags = extractExecutionFlags(args);
-  if (flags.error !== undefined) {
-    throw new Error(flags.error);
-  }
-  return flags;
-}
-
-function executionOverrides(flags: ExecutionFlags): Pick<Params, "async" | "context"> {
-  return {
-    ...(flags.async !== undefined ? { async: flags.async } : {}),
-    ...(flags.fork ? { context: "fork" } : {}),
-  };
-}
-
-function commandHandler(
-  execute: (args: string, ctx: ExtensionContext) => Promise<void>,
-): (args: string, ctx: ExtensionContext) => Promise<void> {
-  return async (args, ctx) => {
-    try {
-      await execute(args, ctx);
-    } catch (error) {
-      ctx.ui.notify(errorMessage(error), "error");
-    }
-  };
-}
-
-async function runSingle(pi: ExtensionAPI, args: string, ctx: ExtensionContext): Promise<void> {
-  const flags = executionFlags(args);
-  const { agent, task } = parseSingleArgs(flags.args);
-  const cwd = resolveExecutionCwd(pi, ctx);
-  assertKnownAgents(cwd, [agent.name], ctx.isProjectTrusted());
-  const { reads, ...overrides } = inlineOverrides(agent.config);
-  const finalTask =
-    reads !== undefined && reads !== false && reads.length > 0
-      ? `[Read from: ${reads.join(", ")}]\n\n${task}`
-      : task;
-  const params: Params = {
-    agent: agent.name,
-    task: finalTask,
-    clarify: false,
-    agentScope: "both",
-    ...overrides,
-    ...executionOverrides(flags),
-  };
-  await runSlashSubagent(pi, ctx, params, cwd);
-}
-
-async function runChain(pi: ExtensionAPI, args: string, ctx: ExtensionContext): Promise<void> {
-  const flags = executionFlags(args);
-  const cwd = resolveExecutionCwd(pi, ctx);
-  const parsed = parseAgentArgs(flags.args, "chain");
-  assertKnownAgents(
-    cwd,
-    parsed.steps.map((step) => step.name),
-    ctx.isProjectTrusted(),
-  );
-  assertCommandTask(parsed, "chain");
-  const chain = parsed.steps.map((step, index) => {
-    const task = step.task ?? (index === 0 && parsed.task.length > 0 ? parsed.task : undefined);
-    return {
-      agent: step.name,
-      ...(task !== undefined ? { task } : {}),
-      ...inlineOverrides(step.config),
-    };
-  });
-  await runSlashSubagent(
-    pi,
-    ctx,
-    {
-      chain,
-      task: parsed.task,
-      clarify: false,
-      agentScope: "both",
-      ...executionOverrides(flags),
-    },
-    cwd,
-  );
-}
-
-async function runParallel(pi: ExtensionAPI, args: string, ctx: ExtensionContext): Promise<void> {
-  const flags = executionFlags(args);
-  const cwd = resolveExecutionCwd(pi, ctx);
-  const parsed = parseAgentArgs(flags.args, "parallel");
-  assertKnownAgents(
-    cwd,
-    parsed.steps.map((step) => step.name),
-    ctx.isProjectTrusted(),
-  );
-  assertCommandTask(parsed, "parallel");
-  const tasks = parsed.steps.map((step) =>
-    Object.assign(
-      { agent: step.name, task: step.task ?? parsed.task },
-      inlineOverrides(step.config),
-    ),
-  );
-  await runSlashSubagent(
-    pi,
-    ctx,
-    {
-      tasks,
-      clarify: false,
-      agentScope: "both",
-      ...executionOverrides(flags),
-    },
-    cwd,
-  );
-}
-
-async function runSavedChain(pi: ExtensionAPI, args: string, ctx: ExtensionContext): Promise<void> {
-  const flags = executionFlags(args);
-  const { name, task } = parseSavedChainArgs(flags.args);
-  const cwd = resolveExecutionCwd(pi, ctx);
-  const chain = discoverSavedChains(cwd, ctx.isProjectTrusted()).find(
-    (candidate) => candidate.name === name,
-  );
-  if (!chain) {
-    throw new Error(`Unknown chain: ${name}`);
-  }
-  let steps: ReturnType<typeof mapSavedChainSteps>;
-  try {
-    steps = mapSavedChainSteps(chain);
-  } catch (error) {
-    ctx.ui.notify(`Cannot load chain '${name}': ${errorMessage(error)}`, "error");
-    return;
-  }
-  await runSlashSubagent(
-    pi,
-    ctx,
-    {
-      chain: steps,
-      task,
-      clarify: false,
-      agentScope: "both",
-      ...executionOverrides(flags),
-    },
-    cwd,
-  );
-}
-
-export function registerSlashCommands(pi: ExtensionAPI, state: SlashDiscoveryState): void {
-  pi.registerCommand("run", {
-    description: "Run a subagent directly: /run agent[output=file] [task] [--bg|--fg] [--fork]",
-    getArgumentCompletions: makeAgentCompletions(pi, state, false),
-    handler: commandHandler((args, ctx) => runSingle(pi, args, ctx)),
-  });
-  pi.registerCommand("chain", {
-    description: 'Run agents in sequence: /chain scout "task" -> oracle [--bg|--fg] [--fork]',
-    getArgumentCompletions: makeAgentCompletions(pi, state, true),
-    handler: commandHandler((args, ctx) => runChain(pi, args, ctx)),
-  });
-  pi.registerCommand("run-chain", {
-    description: "Run a saved chain: /run-chain chainName -- task [--bg|--fg] [--fork]",
-    getArgumentCompletions: makeChainCompletions(pi, state),
-    handler: commandHandler((args, ctx) => runSavedChain(pi, args, ctx)),
-  });
-  pi.registerCommand("parallel", {
-    description:
-      'Run agents in parallel: /parallel scout "task1" -> oracle "task2" [--bg|--fg] [--fork]',
-    getArgumentCompletions: makeAgentCompletions(pi, state, true),
-    handler: commandHandler((args, ctx) => runParallel(pi, args, ctx)),
-  });
-  pi.registerCommand("subagents-doctor", {
-    description: "Show subagent diagnostics",
-    handler: async (_args, ctx) => {
-      await runSlashSubagent(pi, ctx, { action: "doctor" });
-    },
-  });
-}

package/src/slash/slash-live-state.ts

@@ -1,350 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import type { ReadonlyInput } from "../shared/types/inputs.ts";
-import type { ChainStep, SequentialStep } from "../shared/types/workflow.ts";
-import { isRecord, isUnknownArray } from "../shared/unknown.ts";
-import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
-import {
-  SLASH_RESULT_TYPE,
-  type Details,
-  type SingleResult,
-  type SubagentExecutionResult,
-  type Usage,
-} from "../shared/types.ts";
-
-export interface SlashMessageDetails {
-  readonly requestId: string;
-  readonly result: ReadonlyInput<SubagentExecutionResult>;
-}
-
-interface SlashSnapshot {
-  readonly result: ReadonlyInput<SubagentExecutionResult>;
-  readonly version: number;
-}
-
-const liveSnapshots = new Map<string, SlashSnapshot>();
-const finalSnapshots = new Map<string, SlashSnapshot>();
-let versionCounter = 1;
-
-const EMPTY_MESSAGES: Message[] = [];
-const EMPTY_USAGE: Usage = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-  cost: 0,
-  turns: 0,
-};
-
-function nextVersion(): number {
-  return versionCounter++;
-}
-
-function cloneUsage(): Usage {
-  return { ...EMPTY_USAGE };
-}
-
-function createPlaceholderResult(
-  agent: string,
-  task: string,
-  status: "pending" | "running",
-  index = 0,
-): SingleResult {
-  return {
-    agent,
-    task,
-    exitCode: 0,
-    messages: EMPTY_MESSAGES,
-    usage: cloneUsage(),
-    progress: {
-      index,
-      agent,
-      status,
-      task,
-      recentTools: [],
-      recentOutput: [],
-      toolCount: 0,
-      tokens: 0,
-      durationMs: 0,
-    },
-  };
-}
-
-function buildParallelInitialResult(
-  params: ReadonlyInput<SubagentParamsLike>,
-): SubagentExecutionResult {
-  const tasks = params.tasks ?? [];
-  return {
-    content: [
-      { type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") },
-    ],
-    details: {
-      mode: "parallel",
-      ...(params.context !== undefined ? { context: params.context } : {}),
-      results: tasks.map((task, index) =>
-        createPlaceholderResult(task.agent, task.task, "running", index),
-      ),
-      progress: tasks.map((task, index) => ({
-        index,
-        agent: task.agent,
-        status: "running" as const,
-        task: task.task,
-        recentTools: [],
-        recentOutput: [],
-        toolCount: 0,
-        tokens: 0,
-        durationMs: 0,
-      })),
-    },
-  };
-}
-
-function chainTasks(step: ReadonlyInput<ChainStep>): readonly ReadonlyInput<SequentialStep>[] {
-  if ("agent" in step) {
-    return [step];
-  }
-  return "expand" in step ? [step.parallel] : step.parallel;
-}
-
-function chainStepLabel(step: ReadonlyInput<ChainStep>): string {
-  const label = chainTasks(step)
-    .map((task) => task.agent)
-    .join("+");
-  return "parallel" in step ? `[${label}]` : label;
-}
-
-function flattenChainResults(
-  chain: readonly ReadonlyInput<ChainStep>[],
-  fallbackTask: string | undefined,
-): SingleResult[] {
-  const results: SingleResult[] = [];
-  let flatIndex = 0;
-  for (const step of chain) {
-    for (const task of chainTasks(step)) {
-      results.push(
-        createPlaceholderResult(
-          task.agent,
-          task.task ?? fallbackTask ?? "",
-          results.length === 0 ? "running" : "pending",
-          flatIndex,
-        ),
-      );
-      flatIndex++;
-    }
-  }
-  return results;
-}
-
-function buildChainInitialResult(
-  params: ReadonlyInput<SubagentParamsLike>,
-): SubagentExecutionResult {
-  const chain = params.chain ?? [];
-  const results = flattenChainResults(chain, params.task);
-  return {
-    content: [
-      {
-        type: "text",
-        text: results
-          .map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`)
-          .join("\n\n"),
-      },
-    ],
-    details: {
-      mode: "chain",
-      ...(params.context !== undefined ? { context: params.context } : {}),
-      results,
-      progress: results.map((result, index) => ({
-        index,
-        agent: result.agent,
-        status: index === 0 ? ("running" as const) : ("pending" as const),
-        task: result.task,
-        recentTools: [],
-        recentOutput: [],
-        toolCount: 0,
-        tokens: 0,
-        durationMs: 0,
-      })),
-      chainAgents: chain.map((step) => chainStepLabel(step)),
-      totalSteps: chain.length,
-      currentStepIndex: 0,
-    },
-  };
-}
-
-function buildSingleInitialResult(
-  params: ReadonlyInput<SubagentParamsLike>,
-): SubagentExecutionResult {
-  const agent = params.agent ?? "subagent";
-  const task = params.task ?? "";
-  return {
-    content: [{ type: "text", text: task }],
-    details: {
-      mode: "single",
-      ...(params.context !== undefined ? { context: params.context } : {}),
-      results: [createPlaceholderResult(agent, task, "running")],
-      progress: [
-        {
-          index: 0,
-          agent,
-          status: "running",
-          task,
-          recentTools: [],
-          recentOutput: [],
-          toolCount: 0,
-          tokens: 0,
-          durationMs: 0,
-        },
-      ],
-    },
-  };
-}
-
-export function buildSlashInitialResult(
-  requestId: string,
-  params: ReadonlyInput<SubagentParamsLike>,
-): SlashMessageDetails {
-  let result: SubagentExecutionResult;
-  if ((params.tasks?.length ?? 0) > 0) {
-    result = buildParallelInitialResult(params);
-  } else if ((params.chain?.length ?? 0) > 0) {
-    result = buildChainInitialResult(params);
-  } else {
-    result = buildSingleInitialResult(params);
-  }
-  liveSnapshots.set(requestId, { result, version: nextVersion() });
-  finalSnapshots.delete(requestId);
-  return { requestId, result };
-}
-
-function cloneResultsWithProgress(
-  results: ReadonlyInput<SingleResult[]>,
-  progress: ReadonlyInput<Details["progress"]>,
-): ReadonlyInput<SingleResult[]> {
-  return results.map((result, index) => {
-    const nextProgress =
-      progress?.find((entry) => entry.index === index) ?? progress?.[index] ?? result.progress;
-    return nextProgress ? Object.assign({}, result, { progress: nextProgress }) : result;
-  });
-}
-
-export function applySlashUpdate(
-  requestId: string,
-  update: ReadonlyInput<SlashSubagentUpdate>,
-): void {
-  const snapshot = liveSnapshots.get(requestId);
-  if (!snapshot) {
-    return;
-  }
-  const progress = update.progress;
-  if (!progress) {
-    return;
-  }
-  const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
-  const nextDetails: ReadonlyInput<Details> = {
-    ...snapshot.result.details,
-    progress,
-    results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-    ...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0
-      ? { currentStepIndex }
-      : {}),
-  };
-  liveSnapshots.set(requestId, {
-    result: {
-      ...snapshot.result,
-      details: nextDetails,
-    },
-    version: nextVersion(),
-  });
-}
-
-export function finalizeSlashResult(
-  response: ReadonlyInput<SlashSubagentResponse>,
-): SlashMessageDetails {
-  const snapshot = {
-    result: response.result,
-    version: nextVersion(),
-  };
-  finalSnapshots.set(response.requestId, snapshot);
-  liveSnapshots.delete(response.requestId);
-  return {
-    requestId: response.requestId,
-    result: response.result,
-  };
-}
-
-export function failSlashResult(
-  requestId: string,
-  params: ReadonlyInput<SubagentParamsLike>,
-  message: string,
-): SlashMessageDetails {
-  const initial = buildSlashInitialResult(requestId, params).result;
-  const failedResults = initial.details.results.map((result) => ({
-    ...result,
-    exitCode: 1,
-    error: message,
-    progress: result.progress ? { ...result.progress, status: "failed" as const } : result.progress,
-  }));
-  const result: ReadonlyInput<SubagentExecutionResult> = {
-    content: [{ type: "text", text: message }],
-    details: {
-      ...initial.details,
-      results: failedResults,
-      progress: failedResults.flatMap((entry) => (entry.progress ? [entry.progress] : [])),
-    },
-  };
-  const snapshot = { result, version: nextVersion() };
-  finalSnapshots.set(requestId, snapshot);
-  liveSnapshots.delete(requestId);
-  return { requestId, result };
-}
-
-function isSlashMessageDetails(value: unknown): value is SlashMessageDetails {
-  if (!isRecord(value)) {
-    return false;
-  }
-  const v = value;
-  if (typeof v.requestId !== "string" || v.requestId.length === 0) {
-    return false;
-  }
-  if (!isRecord(v.result) || !isUnknownArray(v.result.content)) {
-    return false;
-  }
-  return isRecord(v.result.details) && isUnknownArray(v.result.details.results);
-}
-
-export function resolveSlashMessageDetails(value: unknown): SlashMessageDetails | undefined {
-  return isSlashMessageDetails(value) ? value : undefined;
-}
-
-export function getSlashRenderableSnapshot(
-  details: ReadonlyInput<SlashMessageDetails>,
-): SlashSnapshot {
-  return (
-    finalSnapshots.get(details.requestId) ??
-    liveSnapshots.get(details.requestId) ?? { result: details.result, version: 0 }
-  );
-}
-
-export function restoreSlashFinalSnapshots(entries: readonly unknown[]): void {
-  liveSnapshots.clear();
-  finalSnapshots.clear();
-  for (const entry of entries) {
-    if (!isRecord(entry)) {
-      continue;
-    }
-    const e = entry;
-    if (e.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) {
-      continue;
-    }
-    const details = resolveSlashMessageDetails(e.details);
-    if (!details) {
-      continue;
-    }
-    finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
-  }
-}
-
-export function clearSlashSnapshots(): void {
-  liveSnapshots.clear();
-  finalSnapshots.clear();
-}

package/src/tui/action-hints.ts

@@ -1,155 +0,0 @@
-import { rawKeyHint, type MessageRenderer } from "@earendil-works/pi-coding-agent";
-import {
-  MouseRegion,
-  Text,
-  stripTerminalSequences,
-  truncateToWidth,
-  visibleWidth,
-  type Component,
-} from "@earendil-works/pi-tui";
-
-/** Native custom messages expose global expansion, but need their own per-message click state. */
-export function withMouseExpansion<T>(renderer: MessageRenderer<T>): MessageRenderer<T> {
-  const states = new WeakMap<object, { expanded: boolean; globalExpanded: boolean }>();
-  return (message, options, theme) => {
-    let state = states.get(message);
-    if (!state || state.globalExpanded !== options.expanded) {
-      state = { expanded: options.expanded, globalExpanded: options.expanded };
-      states.set(message, state);
-    }
-    const expansion = state;
-    const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
-    let content = draw();
-    if (!content) {
-      return;
-    }
-    return new MouseRegion(
-      { render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() },
-      (event) => {
-        if (event.type !== "click" || event.button !== "left") {
-          return;
-        }
-        expansion.expanded = !expansion.expanded;
-        content = draw();
-        return { handled: true };
-      },
-    );
-  };
-}
-
-type ActionPart = string | { readonly text: string; readonly run: () => void };
-interface ActionRange {
-  readonly start: number;
-  readonly length: number;
-  readonly run: () => void;
-}
-interface ActionHit {
-  readonly row: number;
-  readonly start: number;
-  readonly end: number;
-  readonly run: () => void;
-}
-
-function actionSource(parts: readonly ActionPart[]): {
-  text: string;
-  source: string;
-  ranges: ActionRange[];
-} {
-  let text = "",
-    source = "";
-  const ranges: ActionRange[] = [];
-  for (const part of parts) {
-    const displayed =
-      typeof part === "string"
-        ? part
-        : part.text.replace(/\balt\+/gi, (key) =>
-            stripTerminalSequences(rawKeyHint(key, "")).trim(),
-          );
-    const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
-    if (typeof part !== "string") {
-      ranges.push({ start: source.length, length: plain.length, run: part.run });
-    }
-    text += displayed;
-    source += plain;
-  }
-  return { text, source, ranges };
-}
-
-function lineHits(
-  shown: string,
-  from: number,
-  ranges: readonly ActionRange[],
-  row: number,
-): ActionHit[] {
-  const hits: ActionHit[] = [];
-  const to = from + shown.length;
-  for (const range of ranges) {
-    const start = Math.max(from, range.start),
-      end = Math.min(to, range.start + range.length);
-    if (start < end) {
-      hits.push({
-        row,
-        start: visibleWidth(shown.slice(0, start - from)),
-        end: visibleWidth(shown.slice(0, end - from)),
-        run: range.run,
-      });
-    }
-  }
-  return hits;
-}
-
-/** Declare action spans while building text; native Text owns wrapping and clipping. */
-export function actionHints(
-  parts: readonly ActionPart[],
-  style: (text: string) => string = (text) => text,
-  ellipsis?: string,
-): Component {
-  const { text: raw, source, ranges } = actionSource(parts);
-  const text = style(raw),
-    content = new Text("", 0, 0);
-  let hits: ActionHit[] = [];
-  return new MouseRegion(
-    {
-      invalidate() {
-        content.invalidate();
-        hits = [];
-      },
-      render(width) {
-        const clipped = ellipsis !== undefined && visibleWidth(text) > width;
-        content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
-        const lines = content.render(width);
-        hits = [];
-        let offset = 0;
-        for (const [row, line] of lines.entries()) {
-          const visible = stripTerminalSequences(line).trimEnd();
-          const shown = clipped
-            ? visible.slice(0, Math.max(0, visible.length - ellipsis.length))
-            : visible;
-          const from = source.indexOf(shown, offset);
-          if (shown.length === 0 || from < 0) {
-            continue;
-          }
-          hits.push(...lineHits(shown, from, ranges, row));
-          offset = from + shown.length;
-        }
-        return lines;
-      },
-    },
-    (event) => {
-      if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) {
-        return;
-      }
-      const hit = hits.find(
-        (candidate) =>
-          candidate.row === event.y && event.x >= candidate.start && event.x < candidate.end,
-      );
-      if (!hit) {
-        return;
-      }
-      if (event.type === "click") {
-        hit.run();
-      }
-      return { handled: true };
-    },
-  );
-}