@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/shared/types/workflow.ts

@@ -1,187 +0,0 @@
-import type {
-  AcceptanceInput,
-  AcceptanceLedgerStatus,
-  ResolvedAcceptanceConfig,
-} from "./acceptance.ts";
-import type { JsonSchemaObject, OutputMode } from "./config.ts";
-import type { SavedLaunchConfig } from "./launch.ts";
-
-export interface ResolvedStepBehavior {
-  readonly output: string | false;
-  readonly outputMode: OutputMode;
-  readonly reads: readonly string[] | false;
-  readonly progress: boolean;
-  readonly skills: readonly string[] | false;
-  readonly model?: string;
-}
-
-export type StepOverrides = Partial<ResolvedStepBehavior>;
-
-export interface SequentialStep {
-  readonly agent: string;
-  readonly task?: string;
-  readonly phase?: string;
-  readonly label?: string;
-  readonly as?: string;
-  readonly outputSchema?: JsonSchemaObject;
-  readonly cwd?: string;
-  readonly output?: string | false;
-  readonly outputMode?: OutputMode;
-  readonly outputFromAgentDefault?: boolean;
-  readonly reads?: readonly string[] | false;
-  readonly progress?: boolean;
-  readonly skill?: string | readonly string[] | false;
-  readonly model?: string;
-  readonly acceptance?: AcceptanceInput;
-}
-
-export interface ParallelTaskItem extends SequentialStep {
-  readonly count?: number;
-}
-
-export interface DynamicExpandSpec {
-  readonly from: { readonly output: string; readonly path: string };
-  readonly item?: string;
-  readonly key?: string;
-  readonly maxItems?: number;
-  readonly onEmpty?: "skip" | "fail";
-}
-
-export type DynamicParallelTemplate = Omit<ParallelTaskItem, "as" | "count">;
-
-export interface DynamicCollectSpec {
-  readonly as: string;
-  readonly outputSchema?: JsonSchemaObject;
-}
-
-export interface DynamicParallelStep {
-  readonly expand: DynamicExpandSpec;
-  readonly parallel: DynamicParallelTemplate;
-  readonly collect: DynamicCollectSpec;
-  readonly concurrency?: number;
-  readonly failFast?: boolean;
-  readonly phase?: string;
-  readonly label?: string;
-}
-
-export interface ParallelStep {
-  readonly parallel: readonly ParallelTaskItem[];
-  readonly concurrency?: number;
-  readonly failFast?: boolean;
-  readonly worktree?: boolean;
-  readonly cwd?: string;
-}
-
-export type ChainStep = SequentialStep | ParallelStep | DynamicParallelStep;
-
-export interface RunnerSubagentStep {
-  readonly agent: string;
-  readonly task: string;
-  readonly phase?: string;
-  readonly label?: string;
-  readonly outputName?: string;
-  readonly structured?: boolean;
-  readonly cwd?: string;
-  readonly model?: string;
-  readonly thinking?: string;
-  readonly modelCandidates?: readonly string[];
-  readonly tools?: readonly string[];
-  readonly allowSubagents?: boolean;
-  readonly extensions?: readonly string[];
-  readonly mcpDirectTools?: readonly string[];
-  readonly completionGuard?: boolean;
-  readonly systemPrompt?: string | null;
-  readonly systemPromptMode?: "append" | "replace";
-  readonly inheritProjectContext: boolean;
-  readonly inheritSkills: boolean;
-  readonly skills?: readonly string[];
-  readonly outputPath?: string;
-  readonly output?: string | false;
-  readonly outputMode?: OutputMode;
-  readonly outputPathFromAgentDefault?: boolean;
-  readonly sessionFile?: string;
-  readonly maxSubagentDepth?: number;
-  readonly maxExecutionTimeMs?: number;
-  readonly maxTokens?: number;
-  readonly structuredOutput?: {
-    readonly schema: JsonSchemaObject;
-    readonly schemaPath: string;
-    readonly outputPath: string;
-  };
-  readonly structuredOutputSchema?: JsonSchemaObject;
-  readonly effectiveAcceptance?: ResolvedAcceptanceConfig;
-  readonly launch?: SavedLaunchConfig;
-}
-
-export interface ParallelStepGroup {
-  readonly parallel: readonly RunnerSubagentStep[];
-  readonly cwd?: string;
-  readonly concurrency?: number;
-  readonly failFast?: boolean;
-  readonly worktree?: boolean;
-}
-
-export interface DynamicRunnerGroup {
-  readonly expand: DynamicExpandSpec;
-  readonly parallel: RunnerSubagentStep;
-  readonly collect: DynamicCollectSpec;
-  readonly concurrency?: number;
-  readonly failFast?: boolean;
-  readonly phase?: string;
-  readonly label?: string;
-  readonly sessionFiles?: readonly (string | undefined)[];
-}
-
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;
-
-export interface ChainOutputMapEntry {
-  readonly text: string;
-  readonly structured?: unknown;
-  readonly agent: string;
-  readonly stepIndex: number;
-}
-
-export type ChainOutputMap = Readonly<Record<string, ChainOutputMapEntry>>;
-
-export type WorkflowNodeStatus =
-  | "pending"
-  | "running"
-  | "completed"
-  | "complete"
-  | "failed"
-  | "blocked"
-  | "paused"
-  | "detached"
-  | "timed-out";
-
-export interface WorkflowGraphNode {
-  readonly id: string;
-  readonly kind: "step" | "parallel-group" | "dynamic-parallel-group" | "agent";
-  readonly agent?: string;
-  readonly phase?: string;
-  readonly label: string;
-  readonly status: WorkflowNodeStatus;
-  readonly flatIndex?: number;
-  readonly stepIndex?: number;
-  readonly children?: readonly WorkflowGraphNode[];
-  readonly dynamic?: {
-    readonly sourceOutput: string;
-    readonly sourcePath: string;
-    readonly itemName: string;
-    readonly maxItems?: number;
-    readonly collectAs?: string;
-  };
-  readonly itemKey?: string;
-  readonly outputName?: string;
-  readonly structured?: boolean;
-  readonly acceptanceStatus?: AcceptanceLedgerStatus;
-  readonly error?: string;
-}
-
-export interface WorkflowGraphSnapshot {
-  readonly runId: string;
-  readonly mode: "chain" | "parallel" | "single";
-  readonly phases: readonly { readonly title: string; readonly nodeIds: readonly string[] }[];
-  readonly nodes: readonly WorkflowGraphNode[];
-  readonly currentNodeId?: string;
-}

package/src/shared/ui-mode.ts

@@ -1,5 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-
-export function isTuiContext(ctx: Pick<ExtensionContext, "mode">): boolean {
-  return ctx.mode === "tui";
-}

package/src/shared/utils.ts

@@ -1,148 +0,0 @@
-/**
- * General utility functions for the subagent extension
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { errorMessage, hasErrorCode, isRecord } from "./unknown.ts";
-import type { ReadonlyAsyncStatus } from "./types.ts";
-import { parseAsyncStatus } from "../runs/background/run-schemas.ts";
-import { normalizeLegacyStatusAcceptance } from "../runs/background/legacy-status-acceptance.ts";
-
-// ============================================================================
-// File System Utilities
-// ============================================================================
-
-export { getAgentDir } from "./agent-dir.ts";
-
-const statusCache = new Map<string, { version: string; status: ReadonlyAsyncStatus }>();
-
-function rememberStatus(statusPath: string, version: string, status: ReadonlyAsyncStatus): void {
-  statusCache.set(statusPath, { version, status });
-  if (statusCache.size > 50) {
-    const firstKey = statusCache.keys().next().value;
-    if (firstKey !== undefined) {
-      statusCache.delete(firstKey);
-    }
-  }
-}
-
-export function resolveChildCwd(baseCwd: string, childCwd: string | undefined): string {
-  if (childCwd === undefined || childCwd === "") {
-    return baseCwd;
-  }
-  return path.isAbsolute(childCwd) ? childCwd : path.resolve(baseCwd, childCwd);
-}
-
-function isNotFoundError(error: unknown): boolean {
-  return hasErrorCode(error, "ENOENT");
-}
-
-function parseStatusForDisplay(value: unknown): ReadonlyAsyncStatus {
-  try {
-    return parseAsyncStatus(value);
-  } catch (error) {
-    if (!isRecord(value)) {
-      throw error;
-    }
-    // Legacy display metadata may be corrupt; every other persisted field must validate.
-    const { parallelGroups, ...remaining } = value;
-    if (parallelGroups === undefined) {
-      throw error;
-    }
-    try {
-      return parseAsyncStatus(remaining);
-    } catch {
-      throw error;
-    }
-  }
-}
-
-/**
- * Read async job status from disk, invalidating on replacement and in-place updates.
- */
-export function readStatus(asyncDir: string): ReadonlyAsyncStatus | null {
-  const statusPath = path.join(asyncDir, "status.json");
-
-  let stat: fs.BigIntStats;
-  try {
-    stat = fs.statSync(statusPath, { bigint: true });
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      statusCache.delete(statusPath);
-      return null;
-    }
-    throw new Error(`Failed to inspect async status file '${statusPath}': ${errorMessage(error)}`, {
-      cause: error,
-    });
-  }
-
-  const cached = statusCache.get(statusPath);
-  const version = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
-  if (cached && cached.version === version) {
-    return cached.status;
-  }
-
-  let content: string;
-  try {
-    content = fs.readFileSync(statusPath, "utf-8");
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return null;
-    }
-    throw new Error(`Failed to read async status file '${statusPath}': ${errorMessage(error)}`, {
-      cause: error,
-    });
-  }
-
-  let status: ReadonlyAsyncStatus;
-  try {
-    const parsed: unknown = JSON.parse(content);
-    status = parseStatusForDisplay(normalizeLegacyStatusAcceptance(parsed));
-  } catch (error) {
-    throw new Error(`Failed to parse async status file '${statusPath}': ${errorMessage(error)}`, {
-      cause: error,
-    });
-  }
-
-  rememberStatus(statusPath, version, status);
-  return status;
-}
-
-/**
- * Find the latest session file in a directory
- */
-export function findLatestSessionFile(sessionDir: string): string | null {
-  try {
-    let latest: { path: string; mtime: number } | undefined;
-    for (const file of fs.readdirSync(sessionDir)) {
-      if (!file.endsWith(".jsonl")) {
-        continue;
-      }
-      const filePath = path.join(sessionDir, file);
-      const mtime = fs.statSync(filePath).mtimeMs;
-      if (!latest || mtime > latest.mtime) {
-        latest = { path: filePath, mtime };
-      }
-    }
-    return latest?.path ?? null;
-  } catch {
-    return null;
-  }
-}
-
-export {
-  getFinalOutput,
-  getSingleResultOutput,
-  formatResourceLimitExceeded,
-  getDisplayItems,
-  compactForegroundResult,
-  detectSubagentError,
-} from "./message-output.ts";
-export { extractToolArgsPreview, extractTextFromContent } from "./content-preview.ts";
-
-// ============================================================================
-// Concurrency Utilities
-// ============================================================================
-
-export { mapConcurrent } from "./concurrency.ts";

package/src/slash/command-discovery.ts

@@ -1,110 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { discoverAgents, discoverChains } from "../agents/agents.ts";
-import type { ChainConfig } from "../shared/types/config.ts";
-import { resolveExecutionCwd } from "../shared/execution-cwd.ts";
-
-export interface SlashDiscoveryState {
-  readonly lastUiContext: ExtensionContext | null;
-  readonly baseCwd: string;
-}
-interface Completion {
-  readonly value: string;
-  readonly label: string;
-}
-
-function projectTrusted(state: SlashDiscoveryState): boolean {
-  return state.lastUiContext ? state.lastUiContext.isProjectTrusted() : true;
-}
-
-function completionCwd(pi: ExtensionAPI, state: SlashDiscoveryState): string | null {
-  try {
-    return state.lastUiContext ? resolveExecutionCwd(pi, state.lastUiContext) : state.baseCwd;
-  } catch {
-    return null;
-  }
-}
-
-export function assertKnownAgents(cwd: string, names: readonly string[], trusted: boolean): void {
-  const agents = discoverAgents(cwd, "both", { projectTrusted: trusted }).agents;
-  for (const name of names) {
-    if (!agents.some((agent) => agent.name === name)) {
-      throw new Error(`Unknown agent: ${name}`);
-    }
-  }
-}
-
-function completionPosition(
-  prefix: string,
-): { readonly word: string; readonly before: string } | undefined {
-  const lastArrow = prefix.lastIndexOf(" -> ");
-  const segment = lastArrow !== -1 ? prefix.slice(lastArrow + 4) : prefix;
-  if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'")) {
-    return undefined;
-  }
-  const word = prefix.match(/(\S*)$/)?.at(1) ?? "";
-  return { word, before: prefix.slice(0, prefix.length - word.length) };
-}
-
-export function makeAgentCompletions(
-  pi: ExtensionAPI,
-  state: SlashDiscoveryState,
-  multiAgent: boolean,
-): (prefix: string) => Completion[] | null {
-  return (prefix) => {
-    const position = multiAgent ? completionPosition(prefix) : { word: prefix, before: "" };
-    if (!position || (!multiAgent && prefix.includes(" "))) {
-      return null;
-    }
-    const cwd = completionCwd(pi, state);
-    if (cwd === null || cwd.length === 0) {
-      return null;
-    }
-    const agents = discoverAgents(cwd, "both", { projectTrusted: projectTrusted(state) }).agents;
-    if (!multiAgent) {
-      return agents
-        .filter((agent) => agent.name.startsWith(prefix))
-        .map((agent) => ({ value: agent.name, label: agent.name }));
-    }
-    const { word: lastWord, before: beforeLastWord } = position;
-    if (lastWord === "->") {
-      return agents.map((agent) => ({ value: `${prefix} ${agent.name}`, label: agent.name }));
-    }
-    return agents
-      .filter((agent) => agent.name.startsWith(lastWord))
-      .map((agent) => ({ value: `${beforeLastWord}${agent.name}`, label: agent.name }));
-  };
-}
-
-export function discoverSavedChains(cwd: string, trusted: boolean): ChainConfig[] {
-  const chains = new Map<string, ChainConfig>();
-  for (const chain of discoverChains(cwd, { projectTrusted: trusted }).chains) {
-    const existing = chains.get(chain.name);
-    const projectOverride = existing?.source === "user" && chain.source === "project";
-    const jsonOverride =
-      existing?.source === chain.source &&
-      chain.filePath.endsWith(".chain.json") &&
-      !existing.filePath.endsWith(".chain.json");
-    if (!existing || projectOverride || jsonOverride) {
-      chains.set(chain.name, chain);
-    }
-  }
-  return [...chains.values()];
-}
-
-export function makeChainCompletions(
-  pi: ExtensionAPI,
-  state: SlashDiscoveryState,
-): (prefix: string) => Completion[] | null {
-  return (prefix) => {
-    if (prefix.includes(" ")) {
-      return null;
-    }
-    const cwd = completionCwd(pi, state);
-    if (cwd === null || cwd.length === 0) {
-      return null;
-    }
-    return discoverSavedChains(cwd, projectTrusted(state))
-      .filter((chain) => chain.name.startsWith(prefix))
-      .map((chain) => ({ value: chain.name, label: chain.name }));
-  };
-}

package/src/slash/command-input.ts

@@ -1,232 +0,0 @@
-import type { Writable } from "type-fest";
-
-export interface InlineConfig {
-  readonly output?: string | false;
-  readonly outputMode?: "inline" | "file-only";
-  readonly reads?: readonly string[] | false;
-  readonly model?: string;
-  readonly skill?: readonly string[] | false;
-  readonly progress?: boolean;
-}
-
-export interface ParsedStep {
-  readonly name: string;
-  readonly config: InlineConfig;
-  readonly task?: string;
-}
-
-export interface ExecutionFlags {
-  readonly args: string;
-  readonly async?: boolean;
-  readonly fork: boolean;
-  readonly error?: string;
-}
-
-function inlineOption(key: string, value: string): InlineConfig {
-  switch (key) {
-    case "output":
-      return { output: value === "false" ? false : value };
-    case "outputMode":
-      if (value !== "inline" && value !== "file-only") {
-        throw new Error("outputMode must be inline or file-only.");
-      }
-      return { outputMode: value };
-    case "reads":
-      return {
-        reads: value === "false" ? false : value.split("+").filter((item) => item.length > 0),
-      };
-    case "model":
-      return { model: value.length > 0 ? value : undefined };
-    case "skill":
-    case "skills":
-      return {
-        skill: value === "false" ? false : value.split("+").filter((item) => item.length > 0),
-      };
-    case "progress":
-      if (value !== "true" && value !== "false") {
-        throw new Error("progress must be true or false.");
-      }
-      return { progress: value === "true" };
-    default:
-      throw new Error(`Unknown inline option '${key}'.`);
-  }
-}
-
-function parseInlineConfig(raw: string): InlineConfig {
-  const config: Writable<InlineConfig> = {};
-  for (const part of raw.split(",")) {
-    const trimmed = part.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    const eq = trimmed.indexOf("=");
-    if (eq === -1) {
-      if (trimmed !== "progress") {
-        throw new Error(`Unknown inline option '${trimmed}'.`);
-      }
-      config.progress = true;
-    } else {
-      Object.assign(
-        config,
-        inlineOption(trimmed.slice(0, eq).trim(), trimmed.slice(eq + 1).trim()),
-      );
-    }
-  }
-  return config;
-}
-
-export function parseAgentToken(token: string): ParsedStep {
-  const bracket = token.indexOf("[");
-  if (bracket === -1) {
-    return { name: token, config: {} };
-  }
-  const end = token.lastIndexOf("]");
-  if (end !== token.length - 1 || end < bracket) {
-    throw new Error(`Malformed inline options in '${token}'; close the trailing ].`);
-  }
-  const name = token.slice(0, bracket);
-  if (name.length === 0) {
-    throw new Error("Agent name is required before inline options.");
-  }
-  return { name, config: parseInlineConfig(token.slice(bracket + 1, end)) };
-}
-
-export function extractExecutionFlags(rawArgs: string): ExecutionFlags {
-  let args = rawArgs.trim();
-  let asyncMode: boolean | undefined;
-  let fork = false;
-  while (true) {
-    const match = args.match(/(?:^| )(--bg|--fg|--fork)$/);
-    if (!match) {
-      break;
-    }
-    const flag = match.at(1);
-    if (flag === "--fork") {
-      fork = true;
-    } else {
-      const nextAsync = flag === "--bg";
-      if (asyncMode !== undefined && asyncMode !== nextAsync) {
-        return { args, fork, error: "Choose only one of --bg or --fg" };
-      }
-      asyncMode = nextAsync;
-    }
-    args = args.slice(0, match.index).trim();
-  }
-  return { args, async: asyncMode, fork };
-}
-
-function parseSegment(segment: string): ParsedStep {
-  const trimmed = segment.trim();
-  const quoted = trimmed.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
-  if (quoted) {
-    const agent = quoted.at(1) ?? "";
-    const task = quoted.at(2) ?? quoted.at(3) ?? "";
-    return { ...parseAgentToken(agent), task: task.length > 0 ? task : undefined };
-  }
-  const delimiter = trimmed.indexOf(" -- ");
-  if (delimiter === -1) {
-    return parseAgentToken(trimmed);
-  }
-  const task = trimmed.slice(delimiter + 4).trim();
-  return {
-    ...parseAgentToken(trimmed.slice(0, delimiter).trim()),
-    task: task.length > 0 ? task : undefined,
-  };
-}
-
-function sharedArguments(input: string, usage: string): { steps: ParsedStep[]; task: string } {
-  const delimiter = input.indexOf(" -- ");
-  if (delimiter === -1) {
-    throw new Error(usage);
-  }
-  const agents = input.slice(0, delimiter).trim();
-  const task = input.slice(delimiter + 4).trim();
-  if (agents.length === 0 || task.length === 0) {
-    throw new Error(usage);
-  }
-  return {
-    steps: agents
-      .split(/\s+/)
-      .filter((token) => token.length > 0)
-      .map(parseAgentToken),
-    task,
-  };
-}
-
-function hasTask(step: ParsedStep | undefined): boolean {
-  return step?.task !== undefined && step.task.length > 0;
-}
-
-export interface ParsedAgentArgs {
-  readonly steps: readonly ParsedStep[];
-  readonly task: string;
-  readonly perStep: boolean;
-}
-
-export function assertCommandTask(parsed: ParsedAgentArgs, command: "chain" | "parallel"): void {
-  const { steps, task, perStep } = parsed;
-  if (command === "chain" && !hasTask(steps.at(0)) && (perStep || task.length === 0)) {
-    throw new Error('First step must have a task: /chain agent "task" -> agent2');
-  }
-  if (command === "parallel" && !steps.some(hasTask) && task.length === 0) {
-    throw new Error("At least one step must have a task");
-  }
-}
-
-export function parseAgentArgs(args: string, command: "chain" | "parallel"): ParsedAgentArgs {
-  const input = args.trim();
-  const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
-  const perStep = input.includes(" -> ");
-  const parsed = perStep
-    ? {
-        steps: input
-          .split(" -> ")
-          .filter((segment) => segment.trim().length > 0)
-          .map(parseSegment),
-      }
-    : sharedArguments(input, usage);
-  const task = "task" in parsed ? parsed.task : (parsed.steps.find(hasTask)?.task ?? "");
-  if (parsed.steps.length === 0) {
-    throw new Error(usage);
-  }
-  return { steps: parsed.steps, task, perStep };
-}
-
-export function parseSingleArgs(args: string): { agent: ParsedStep; task: string } {
-  const input = args.trim();
-  if (input.length === 0) {
-    throw new Error("Usage: /run <agent> [task] [--bg|--fg] [--fork]");
-  }
-  const space = input.indexOf(" ");
-  const rawTask = space === -1 ? "" : input.slice(space + 1).trim();
-  const quoted = rawTask.match(/^(?:"([\s\S]*)"|'([\s\S]*)')$/);
-  return {
-    agent: parseAgentToken(space === -1 ? input : input.slice(0, space)),
-    task: quoted ? (quoted.at(1) ?? quoted.at(2) ?? "") : rawTask,
-  };
-}
-
-export function parseSavedChainArgs(args: string): { name: string; task: string } {
-  const delimiter = args.indexOf(" -- ");
-  const usage = "Usage: /run-chain <chainName> -- <task> [--bg|--fg] [--fork]";
-  if (delimiter === -1) {
-    throw new Error(usage);
-  }
-  const name = args.slice(0, delimiter).trim();
-  const task = args.slice(delimiter + 4).trim();
-  if (name.length === 0 || task.length === 0) {
-    throw new Error(usage);
-  }
-  return { name, task };
-}
-
-export function inlineOverrides(config: InlineConfig): InlineConfig {
-  return {
-    ...(config.output !== undefined ? { output: config.output } : {}),
-    ...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-    ...(config.reads !== undefined ? { reads: config.reads } : {}),
-    ...(config.model !== undefined && config.model.length > 0 ? { model: config.model } : {}),
-    ...(config.skill !== undefined ? { skill: config.skill } : {}),
-    ...(config.progress !== undefined ? { progress: config.progress } : {}),
-  };
-}