@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/shared/agent-context-policy.ts

@@ -1,215 +0,0 @@
-import type { AgentConfig } from "./types/config.ts";
-import type { ReadonlyInput } from "./types/inputs.ts";
-import {
-  type ChainStep,
-  type SequentialStep,
-  getStepAgents,
-  isDynamicParallelStep,
-  isParallelStep,
-} from "./settings.ts";
-import { createForkContextResolver, resolveSubagentContext } from "./fork-context.ts";
-import { wrapForkTask } from "./types.ts";
-
-export type SubagentExecutionContext = "fresh" | "fork";
-
-interface ForkableSessionManager {
-  readonly getSessionFile: () => string | undefined;
-  readonly getLeafId: () => string | null;
-  readonly getSessionDir: () => string;
-}
-
-export interface SubagentParamsLikeForContext {
-  agent?: string;
-  model?: string;
-  tasks?: Array<{ agent: string; model?: string }>;
-  chain?: ChainStep[];
-  context?: SubagentExecutionContext;
-}
-
-interface InvocationAgentTarget {
-  agent: string;
-  model?: string;
-}
-
-export function resolveAgentContext(
-  explicitContext: unknown,
-  agentName: string | undefined,
-  agents: readonly AgentConfig[],
-): SubagentExecutionContext {
-  if (explicitContext !== undefined) {
-    return resolveSubagentContext(explicitContext);
-  }
-  if (agentName === undefined || agentName === "") {
-    return "fresh";
-  }
-  const agent = agents.find((entry) => entry.name === agentName);
-  return agent?.defaultContext === "fork" ? "fork" : "fresh";
-}
-
-function chainAgentTargets(step: ReadonlyInput<ChainStep>): InvocationAgentTarget[] {
-  if (isParallelStep(step)) {
-    return step.parallel.map((task) => ({ agent: task.agent, model: task.model }));
-  }
-  const task = isDynamicParallelStep(step) ? step.parallel : step;
-  return [{ agent: task.agent, model: task.model }];
-}
-
-function collectInvocationAgentTargets(
-  params: ReadonlyInput<SubagentParamsLikeForContext>,
-): InvocationAgentTarget[] {
-  if (params.tasks !== undefined && params.tasks.length > 0) {
-    return params.tasks.map((task) => ({ agent: task.agent, model: task.model }));
-  }
-  if (params.chain !== undefined && params.chain.length > 0) {
-    return params.chain.flatMap(chainAgentTargets);
-  }
-  return params.agent !== undefined && params.agent !== ""
-    ? [{ agent: params.agent, model: params.model }]
-    : [];
-}
-
-export function validateForkContextModelPolicy(
-  params: ReadonlyInput<SubagentParamsLikeForContext>,
-  agents: readonly AgentConfig[],
-  resolveModel?: (model: string) => string | undefined,
-): string | undefined {
-  for (const target of collectInvocationAgentTargets(params)) {
-    const agent = agents.find((entry) => entry.name === target.agent);
-    if (!agent || resolveAgentContext(params.context, target.agent, agents) !== "fork") {
-      continue;
-    }
-    const anthropicModel = (
-      target.model !== undefined && target.model !== ""
-        ? [target.model]
-        : [agent.model, ...(agent.fallbackModels ?? [])]
-    )
-      .filter((model): model is string => Boolean(model?.trim()))
-      .map((model) => resolveModel?.(model) ?? model)
-      .find((model) => model.trim().toLowerCase().startsWith("anthropic/"));
-    if (anthropicModel !== undefined && anthropicModel !== "") {
-      return `Fork context cannot be used with anthropic/* models. Agent '${target.agent}' has effective model candidate '${anthropicModel}'. Use context: "fresh" or a non-Anthropic model; this restriction cannot be overridden.`;
-    }
-  }
-  return undefined;
-}
-
-export function invocationUsesForkContext(
-  explicitContext: unknown,
-  agentNames: readonly string[],
-  agents: readonly AgentConfig[],
-): boolean {
-  if (explicitContext !== undefined) {
-    return resolveSubagentContext(explicitContext) === "fork";
-  }
-  return agentNames.some((name) => resolveAgentContext(undefined, name, agents) === "fork");
-}
-
-export function buildFlatAgentNameResolver(
-  params: ReadonlyInput<SubagentParamsLikeForContext>,
-): (index: number) => string | undefined {
-  if ((params.tasks?.length ?? 0) > 0 || (params.chain?.length ?? 0) > 0) {
-    const names = collectInvocationAgentTargets(params).map((target) => target.agent);
-    return (index) => names[index];
-  }
-  return () => (params.agent === "" ? undefined : params.agent);
-}
-
-export function wrapTaskForAgentContext(
-  task: string,
-  explicitContext: unknown,
-  agentName: string | undefined,
-  agents: readonly AgentConfig[],
-): string {
-  return resolveAgentContext(explicitContext, agentName, agents) === "fork"
-    ? wrapForkTask(task)
-    : task;
-}
-
-export function wrapChainTasksForAgentContext(
-  chain: readonly ReadonlyInput<ChainStep>[],
-  explicitContext: unknown,
-  agents: readonly AgentConfig[],
-): ReadonlyInput<ChainStep>[] {
-  return chain.map((step, stepIndex) => {
-    if (isParallelStep(step)) {
-      return {
-        ...step,
-        parallel: step.parallel.map((task) => ({
-          ...task,
-          task: wrapTaskForAgentContext(
-            task.task ?? "{previous}",
-            explicitContext,
-            task.agent,
-            agents,
-          ),
-        })),
-      };
-    }
-    if (isDynamicParallelStep(step)) {
-      return {
-        ...step,
-        parallel: {
-          ...step.parallel,
-          task: wrapTaskForAgentContext(
-            step.parallel.task ?? "{previous}",
-            explicitContext,
-            step.parallel.agent,
-            agents,
-          ),
-        },
-      };
-    }
-    const sequential: ReadonlyInput<SequentialStep> = step;
-    const agentName = getStepAgents(step)[0];
-    return {
-      ...sequential,
-      task: wrapTaskForAgentContext(
-        sequential.task ?? (stepIndex === 0 ? "{task}" : "{previous}"),
-        explicitContext,
-        agentName,
-        agents,
-      ),
-    };
-  });
-}
-
-export function createPerAgentForkContextResolver(
-  sessionManager: ForkableSessionManager,
-  resolveContextForIndex: (index?: number) => SubagentExecutionContext,
-  options: {
-    readonly resolveContextForAgentIndex?: (
-      agentName: string | undefined,
-      index?: number,
-    ) => SubagentExecutionContext;
-  } = {},
-): {
-  readonly sessionFileForIndex: (index?: number) => string | undefined;
-  readonly sessionFileForAgentIndex: (
-    agentName: string | undefined,
-    index?: number,
-  ) => string | undefined;
-} {
-  let forkResolver: ReturnType<typeof createForkContextResolver> | undefined;
-  const sessionFileForContext = (
-    context: SubagentExecutionContext,
-    index = 0,
-  ): string | undefined => {
-    if (context !== "fork") {
-      return undefined;
-    }
-    if (!forkResolver) {
-      forkResolver = createForkContextResolver(sessionManager);
-    }
-    return forkResolver.sessionFileForIndex(index);
-  };
-  return {
-    sessionFileForIndex(index = 0): string | undefined {
-      return sessionFileForContext(resolveContextForIndex(index), index);
-    },
-    sessionFileForAgentIndex(agentName, index = 0): string | undefined {
-      const context =
-        options.resolveContextForAgentIndex?.(agentName, index) ?? resolveContextForIndex(index);
-      return sessionFileForContext(context, index);
-    },
-  };
-}

package/src/shared/agent-dir.ts

@@ -1,15 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-
-export function getAgentDir(): string {
-  const configured = process.env.PI_CODING_AGENT_DIR;
-  if (configured === "~") {
-    return os.homedir();
-  }
-  if (configured?.startsWith("~/") === true) {
-    return path.join(os.homedir(), configured.slice(2));
-  }
-  return configured !== undefined && configured !== ""
-    ? configured
-    : path.join(os.homedir(), ".pi", "agent");
-}

package/src/shared/artifacts.ts

@@ -1,126 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { TEMP_ARTIFACTS_DIR, type ArtifactPaths } from "./types.ts";
-import { getAgentDir } from "./agent-dir.ts";
-import { ensureSafeTempPath } from "./temp-root.ts";
-import { hasErrorCode } from "./unknown.ts";
-const CLEANUP_MARKER_FILE = ".last-cleanup";
-export const ARTIFACT_CLEANUP_DAYS = 7;
-
-export function getArtifactsDir(sessionFile: string | null): string {
-  if (sessionFile !== null && sessionFile !== "") {
-    const sessionDir = path.dirname(sessionFile);
-    return path.join(sessionDir, "subagent-artifacts");
-  }
-  return TEMP_ARTIFACTS_DIR;
-}
-
-export function getArtifactPaths(
-  artifactsDir: string,
-  runId: string,
-  agent: string,
-  index?: number,
-): ArtifactPaths {
-  ensureSafeTempPath(artifactsDir);
-  const suffix = index !== undefined ? `_${index}` : "";
-  const safeAgent = agent.replace(/[^\w.-]/g, "_").slice(0, 128);
-  const base = `${runId}_${safeAgent}${suffix}`;
-  return {
-    inputPath: path.join(artifactsDir, `${base}_input.md`),
-    outputPath: path.join(artifactsDir, `${base}_output.md`),
-    metadataPath: path.join(artifactsDir, `${base}_meta.json`),
-  };
-}
-
-export function appendJsonl(filePath: string, line: string): void {
-  fs.appendFileSync(filePath, `${line}\n`);
-}
-
-async function claimCleanup(dir: string, now: number): Promise<boolean> {
-  try {
-    await fs.promises.access(dir);
-  } catch {
-    return false;
-  }
-
-  const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-
-  try {
-    const stat = await fs.promises.lstat(markerPath);
-    if (!stat.isSymbolicLink() && now - stat.mtimeMs < 24 * 60 * 60 * 1000) {
-      return false;
-    }
-    await fs.promises.unlink(markerPath);
-  } catch (error) {
-    if (!hasErrorCode(error, "ENOENT")) {
-      return false;
-    }
-  }
-
-  return true;
-}
-export async function cleanupOldArtifacts(dir: string, maxAgeDays: number): Promise<void> {
-  ensureSafeTempPath(dir);
-  const now = Date.now();
-  if (!(await claimCleanup(dir, now))) {
-    return;
-  }
-  const markerPath = path.join(dir, CLEANUP_MARKER_FILE);
-  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-  const cutoff = now - maxAgeMs;
-
-  for (const file of await fs.promises.readdir(dir)) {
-    if (file === CLEANUP_MARKER_FILE) {
-      continue;
-    }
-    const filePath = path.join(dir, file);
-    try {
-      // Process one filesystem entry at a time to keep cleanup's I/O bounded.
-      // oxlint-disable-next-line no-await-in-loop
-      const stat = await fs.promises.lstat(filePath);
-      if (stat.mtimeMs < cutoff) {
-        // Finish deleting this entry before inspecting the next artifact.
-        // oxlint-disable-next-line no-await-in-loop
-        await fs.promises.unlink(filePath);
-      }
-    } catch {
-      // Artifact cleanup is best-effort housekeeping. Skip files that disappear
-      // or become unreadable while scanning so one bad entry does not block the rest.
-    }
-  }
-
-  try {
-    await fs.promises.writeFile(markerPath, String(now), { flag: "wx", mode: 0o600 });
-  } catch (error) {
-    if (!hasErrorCode(error, "EEXIST")) {
-      throw error;
-    }
-  }
-}
-
-export async function cleanupAllArtifactDirs(maxAgeDays: number): Promise<void> {
-  await cleanupOldArtifacts(TEMP_ARTIFACTS_DIR, maxAgeDays);
-
-  const sessionsBase = path.join(getAgentDir(), "sessions");
-
-  let dirs: string[];
-  try {
-    dirs = await fs.promises.readdir(sessionsBase);
-  } catch {
-    // Session artifact cleanup is best-effort. If the sessions root cannot be read,
-    // skip cleanup instead of failing extension startup.
-    return;
-  }
-
-  for (const dir of dirs) {
-    const artifactsDir = path.join(sessionsBase, dir, "subagent-artifacts");
-    try {
-      // Finish each session directory before starting another retention scan.
-      // oxlint-disable-next-line no-await-in-loop
-      await cleanupOldArtifacts(artifactsDir, maxAgeDays);
-    } catch {
-      // Session cleanup is best-effort. Keep going so one unreadable session dir
-      // does not block cleanup for the rest.
-    }
-  }
-}

package/src/shared/atomic-json.ts

@@ -1,19 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-export function writeAtomicJson(filePath: string, payload: object): void {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const tempPath = path.join(
-    path.dirname(filePath),
-    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
-  );
-  try {
-    fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), {
-      encoding: "utf-8",
-      mode: 0o600,
-    });
-    fs.renameSync(tempPath, filePath);
-  } finally {
-    fs.rmSync(tempPath, { force: true });
-  }
-}

package/src/shared/chain-files.ts

@@ -1,72 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CHAIN_RUNS_DIR } from "./types.ts";
-import { ensureSafeTempPath, ensureTempRoot } from "./temp-root.ts";
-const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000;
-const INITIAL_PROGRESS_CONTENT =
-  "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
-
-export function createChainDir(runId: string, baseDir?: string, cwd = process.cwd()): string {
-  const customBase = baseDir !== undefined && baseDir.length > 0;
-  if (!customBase) {
-    ensureTempRoot();
-  }
-  const chainDir = path.join(customBase ? path.resolve(cwd, baseDir) : CHAIN_RUNS_DIR, runId);
-  if (!customBase) {
-    ensureSafeTempPath(chainDir);
-  }
-  fs.mkdirSync(chainDir, { recursive: true });
-  return chainDir;
-}
-export function removeChainDir(chainDir: string): void {
-  try {
-    fs.rmSync(chainDir, { recursive: true });
-  } catch {
-    // Cleanup is best effort; another run may already have removed the directory.
-  }
-}
-async function cleanupOldDirectory(dir: string, now: number): Promise<void> {
-  try {
-    const dirPath = path.join(CHAIN_RUNS_DIR, dir);
-    const stat = await fs.promises.lstat(dirPath);
-    if (stat.isDirectory() && now - stat.mtimeMs > CHAIN_DIR_MAX_AGE_MS) {
-      await fs.promises.rm(dirPath, { recursive: true });
-    }
-  } catch {
-    // One unreadable directory must not prevent cleanup of the remaining runs.
-  }
-}
-export async function cleanupOldChainDirs(): Promise<void> {
-  ensureSafeTempPath(CHAIN_RUNS_DIR);
-  const now = Date.now();
-  let dirs: string[];
-  try {
-    dirs = await fs.promises.readdir(CHAIN_RUNS_DIR);
-  } catch {
-    // An unreadable scoped temp root must not fail extension startup.
-    return;
-  }
-  for (const dir of dirs) {
-    // Preserve the existing one-directory resource bound throughout startup pruning.
-    // oxlint-disable-next-line no-await-in-loop
-    await cleanupOldDirectory(dir, now);
-  }
-}
-export function writeInitialProgressFile(progressDir: string): void {
-  fs.mkdirSync(progressDir, { recursive: true });
-  try {
-    fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT, {
-      encoding: "utf-8",
-      flag: "wx",
-    });
-  } catch (error) {
-    if (
-      typeof error !== "object" ||
-      error === null ||
-      !("code" in error) ||
-      error.code !== "EEXIST"
-    ) {
-      throw error;
-    }
-  }
-}

package/src/shared/concurrency.ts

@@ -1,27 +0,0 @@
-import type { ReadonlyInput } from "./types/inputs.ts";
-
-/** A bounded worker pool. Results retain input order even when workers finish out of order. */
-export async function mapConcurrent<T, R>(
-  items: readonly ReadonlyInput<T>[],
-  limit: number,
-  fn: (item: ReadonlyInput<T>, index: number) => Promise<R>,
-): Promise<R[]> {
-  const integralLimit = Math.floor(limit);
-  const safeLimit = Math.max(
-    1,
-    Number.isNaN(integralLimit) || integralLimit === 0 ? 1 : integralLimit,
-  );
-  const results: R[] = [];
-  results.length = items.length;
-  let next = 0;
-  async function worker(): Promise<void> {
-    while (next < items.length) {
-      const index = next++;
-      // Each worker awaits its own task before claiming another, bounding active work.
-      // oxlint-disable-next-line no-await-in-loop
-      results[index] = await fn(items[index], index);
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, () => worker()));
-  return results;
-}

package/src/shared/content-preview.ts

@@ -1,117 +0,0 @@
-import { isRecord, isUnknownArray } from "./unknown.ts";
-
-function truncate(value: string, length: number): string {
-  return value.length > length ? `${value.slice(0, length - 3)}...` : value;
-}
-function scalar(value: unknown): string | undefined {
-  if (typeof value === "string" && value.trim().length > 0) {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  return undefined;
-}
-function array(value: unknown): string | undefined {
-  if (!isUnknownArray(value) || value.length === 0) {
-    return undefined;
-  }
-  const first = scalar(value[0]);
-  if (first === undefined || first === "") {
-    return undefined;
-  }
-  return `${first}${value.length > 1 ? ` (+${value.length - 1} more)` : ""}`;
-}
-function mcpPreview(args: Readonly<Record<string, unknown>>): string | undefined {
-  if (typeof args.tool === "string" && args.tool !== "") {
-    const server = typeof args.server === "string" && args.server !== "" ? `${args.server}/` : "";
-    const toolArgs =
-      typeof args.args === "string" && args.args !== "" ? ` ${args.args.slice(0, 40)}` : "";
-    return `${server}${args.tool}${toolArgs}`;
-  }
-  return undefined;
-}
-function primaryPreview(args: Readonly<Record<string, unknown>>): string | undefined {
-  const mcp = mcpPreview(args);
-  if (mcp !== undefined) {
-    return mcp;
-  }
-  const queries = array(args.queries);
-  if (queries !== undefined) {
-    return truncate(queries, 60);
-  }
-  if (typeof args.query === "string" && args.query.trim().length > 0) {
-    return truncate(args.query, 60);
-  }
-  if (typeof args.workflow === "string" && args.workflow.trim().length > 0) {
-    return `workflow=${truncate(args.workflow, 48)}`;
-  }
-  return undefined;
-}
-function secondaryPreview(args: Readonly<Record<string, unknown>>): string | undefined {
-  if (typeof args.url === "string" && args.url.trim().length > 0) {
-    return truncate(args.url, 60);
-  }
-  const urls = array(args.urls);
-  if (urls !== undefined) {
-    return truncate(urls, 60);
-  }
-  if (typeof args.prompt === "string" && args.prompt.trim().length > 0) {
-    return truncate(args.prompt, 60);
-  }
-  for (const key of [
-    "command",
-    "path",
-    "file_path",
-    "pattern",
-    "query",
-    "url",
-    "task",
-    "describe",
-    "search",
-  ]) {
-    const value = args[key];
-    if (typeof value === "string" && value !== "") {
-      return truncate(value, 60);
-    }
-  }
-  return undefined;
-}
-/** Ordered tool-specific previews, then the first printable unknown argument. */
-export function extractToolArgsPreview(args: Readonly<Record<string, unknown>>): string {
-  const selected = primaryPreview(args) ?? secondaryPreview(args);
-  if (selected !== undefined) {
-    return selected;
-  }
-  for (const [key, value] of Object.entries(args)) {
-    const preview = array(value);
-    if (preview !== undefined) {
-      return `${key}=${truncate(preview, 50)}`;
-    }
-    if (typeof value === "string" && value.length > 0) {
-      return `${key}=${truncate(value, 50)}`;
-    }
-  }
-  return "";
-}
-function partText(part: unknown): string {
-  if (!isRecord(part)) {
-    return "";
-  }
-  if (part.type === "tool_result") {
-    return extractTextFromContent(part.content);
-  }
-  return typeof part.text === "string" ? part.text : "";
-}
-/** External content is accepted only as strings or known text/content fields. */
-export function extractTextFromContent(content: unknown): string {
-  if (typeof content === "string") {
-    return content;
-  }
-  return isUnknownArray(content)
-    ? content
-        .map(partText)
-        .filter((text) => text !== "")
-        .join("\n")
-    : "";
-}

package/src/shared/execution-cwd.ts

@@ -1,39 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { hasExecutionCwdOwner } from "../runs/shared/child-execution-cwd.ts";
-import type { ReadonlyInput } from "./types/inputs.ts";
-
-function validateDirectoryReply(
-  result: { readonly cwd?: string; readonly error?: string } | undefined,
-): void {
-  if (result?.error !== undefined && result.error !== "") {
-    throw new Error(result.error);
-  }
-  if (result && (result.cwd === undefined || result.cwd === "")) {
-    throw new Error("Working-directory owner did not return an execution directory.");
-  }
-}
-/** Capture the active directory owner once per invocation, before asynchronous preparation. */
-export function resolveExecutionCwd(
-  pi: ReadonlyInput<
-    Pick<ExtensionAPI, "events"> & Partial<Pick<ExtensionAPI, "getAllTools" | "getCommands">>
-  >,
-  ctx: ExtensionContext,
-): string {
-  const request: {
-    sessionManager: ExtensionContext["sessionManager"];
-    result?: { cwd?: string; error?: string };
-  } = { sessionManager: ctx.sessionManager };
-  pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
-  validateDirectoryReply(request.result);
-  if (
-    !request.result &&
-    pi.getAllTools &&
-    pi.getCommands &&
-    hasExecutionCwdOwner({ getAllTools: pi.getAllTools, getCommands: pi.getCommands })
-  ) {
-    throw new Error(
-      "The loaded directory extension did not resolve the execution directory. Update pi-change-working-dir before delegating work.",
-    );
-  }
-  return request.result?.cwd ?? ctx.cwd;
-}

package/src/shared/file-coalescer.ts

@@ -1,31 +0,0 @@
-interface FileCoalescer {
-  readonly schedule: (file: string, delayMs?: number) => boolean;
-  readonly clear: () => void;
-}
-
-export function createFileCoalescer(
-  handler: (file: string) => void,
-  defaultDelayMs: number,
-): FileCoalescer {
-  const pending = new Map<string, ReturnType<typeof setTimeout>>();
-
-  return {
-    schedule(file: string, delayMs = defaultDelayMs): boolean {
-      if (pending.has(file)) {
-        return false;
-      }
-      const timer = setTimeout(() => {
-        pending.delete(file);
-        handler(file);
-      }, delayMs);
-      pending.set(file, timer);
-      return true;
-    },
-    clear(): void {
-      for (const timer of pending.values()) {
-        clearTimeout(timer);
-      }
-      pending.clear();
-    },
-  };
-}