pi-subagents-lite 0.2.0

package/src/model-precedence.ts

@@ -0,0 +1,71 @@
+/**
+ * model-precedence.ts — Model resolution with explicit precedence.
+ *
+ * Pure function — no side effects, no file I/O, no pi SDK imports.
+ *
+ * Precedence chain (highest to lowest):
+ *   1. config.agent[subagentType]  (per-type override)
+ *   2. config.agent["default"]     (global default)
+ *   3. agentConfig?.model          (agent config / frontmatter)
+ *   4. parentModelId               (inherit from parent)
+ */
+
+/** Shape of the subagents-lite.json config file. */
+export interface SubagentsConfig {
+  agent: {
+    default: string | null;
+    [agentType: string]: string | null | undefined;
+  };
+  concurrency: {
+    default: number;
+    providers?: Record<string, number>;
+    models?: Record<string, number>;
+  };
+}
+
+/**
+ * Resolve the model for a subagent invocation.
+ *
+ * Returns the first non-null, non-undefined, non-empty-string value
+ * from the precedence chain. If all are empty/null, returns parentModelId.
+ *
+ * @param subagentType - The type of subagent being spawned
+ * @param agentConfig - The agent's config (from .md frontmatter or defaults)
+ * @param config - The global subagents-lite.json config (model overrides)
+ * @param parentModelId - The parent agent's model ID (final fallback)
+ * @returns The resolved model ID string
+ */
+export function resolveModel(
+  subagentType: string,
+  agentConfig: { model?: string } | undefined,
+  config: SubagentsConfig,
+  parentModelId: string,
+): string {
+  // Level 1: per-type override
+  const perTypeOverride = config.agent[subagentType];
+  if (isValidValue(perTypeOverride)) {
+    return perTypeOverride;
+  }
+
+  // Level 2: global default override
+  const globalDefault = config.agent["default"];
+  if (isValidValue(globalDefault)) {
+    return globalDefault;
+  }
+
+  // Level 3: agent config/frontmatter model
+  if (agentConfig && isValidValue(agentConfig.model)) {
+    return agentConfig.model;
+  }
+
+  // Level 4: parent model (final fallback)
+  return parentModelId;
+}
+
+/**
+ * Check if a value is a valid non-empty model string.
+ * Returns true for non-null, non-undefined, non-empty strings.
+ */
+function isValidValue(value: string | null | undefined): value is string {
+  return typeof value === "string" && value.length > 0;
+}

package/src/model-selector.ts

@@ -0,0 +1,271 @@
+/**
+ * model-selector.ts — TUI model selection dialog.
+ *
+ * Ported from subagent-lazy/model-selector.ts verbatim.
+ * Used by the /agents menu for model selection.
+ *
+ * Reuses the same building blocks as pi's ModelSelectorComponent but without
+ * the SettingsManager dependency — no side effects, just callbacks.
+ */
+
+import {
+  Container,
+  type Component,
+  type Focusable,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+
+// Theme type from ctx.ui.custom() callback — avoid deep import that may not resolve
+// in jiti extension loader. The constructor receives the theme instance directly.
+type Theme = any;
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export interface ModelOption {
+  /** "provider/model-id" — the value returned on selection */
+  value: string;
+  /** Display label (model-id without provider prefix) */
+  label: string;
+  /** Provider name for badge */
+  provider: string;
+}
+
+export interface ModelSelectorCallbacks {
+  onSelect: (value: string) => void;
+  onCancel: () => void;
+}
+
+/* ------------------------------------------------------------------ */
+/*  ModelSelectorDialog                                                */
+/* ------------------------------------------------------------------ */
+
+const MAX_VISIBLE = 10;
+
+/**
+ * A paginated, searchable model selector dialog.
+ *
+ * Rendering mirrors pi's ModelSelectorComponent:
+ *   - Top border
+ *   - Search input
+ *   - Paginated model list (10 at a time, centered on selection)
+ *   - Scroll indicator "(3/47)"
+ *   - Bottom border
+ *
+ * Key bindings: up/down/pageup/pagedown/enter/escape + pass-through to search.
+ */
+export class ModelSelectorDialog extends Container implements Focusable {
+  private searchInput: Input;
+  private listContainer: Container;
+  private items: ModelOption[];
+  private filteredItems: ModelOption[];
+  private selectedIndex: number;
+  private currentModel: string | null;
+  private callbacks: ModelSelectorCallbacks;
+  private theme: Theme;
+
+  // Focusable implementation — propagate to searchInput for IME cursor
+  private _focused = false;
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
+
+  constructor(
+    items: ModelOption[],
+    currentModel: string | null,
+    callbacks: ModelSelectorCallbacks,
+    theme: Theme,
+  ) {
+    super();
+
+    this.items = items;
+    this.currentModel = currentModel;
+    this.callbacks = callbacks;
+    this.theme = theme;
+    this.filteredItems = [...items];
+
+    // Pre-select current model if present
+    const currentIdx = items.findIndex((m) => m.value === currentModel);
+    this.selectedIndex = currentIdx >= 0 ? currentIdx : 0;
+
+    // Build UI
+    this.addChild(new DynamicBorder());
+    this.addChild(new Spacer(1));
+
+    this.searchInput = new Input();
+    this.searchInput.onSubmit = () => {
+      if (this.filteredItems[this.selectedIndex]) {
+        this.callbacks.onSelect(this.filteredItems[this.selectedIndex].value);
+      }
+    };
+    this.addChild(this.searchInput);
+    this.addChild(new Spacer(1));
+
+    this.listContainer = new Container();
+    this.addChild(this.listContainer);
+    this.addChild(new Spacer(1));
+
+    this.addChild(new DynamicBorder());
+
+    this.updateList();
+  }
+
+  /** Handle keyboard input. Delegates non-navigation keys to searchInput. */
+  handleInput(keyData: string): void {
+    const kb = getKeybindings();
+
+    // Up — wrap to bottom
+    if (kb.matches(keyData, "tui.select.up")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.filteredItems.length - 1
+          : this.selectedIndex - 1;
+      this.updateList();
+      return;
+    }
+
+    // Down — wrap to top
+    if (kb.matches(keyData, "tui.select.down")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === this.filteredItems.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+      this.updateList();
+      return;
+    }
+
+    // PageUp — jump up one page
+    if (kb.matches(keyData, "tui.select.pageUp")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex = Math.max(0, this.selectedIndex - MAX_VISIBLE);
+      this.updateList();
+      return;
+    }
+
+    // PageDown — jump down one page
+    if (kb.matches(keyData, "tui.select.pageDown")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex = Math.min(
+        this.filteredItems.length - 1,
+        this.selectedIndex + MAX_VISIBLE,
+      );
+      this.updateList();
+      return;
+    }
+
+    // Enter — confirm selection
+    if (kb.matches(keyData, "tui.select.confirm")) {
+      const selected = this.filteredItems[this.selectedIndex];
+      if (selected) {
+        this.callbacks.onSelect(selected.value);
+      }
+      return;
+    }
+
+    // Escape / Ctrl+C — cancel
+    if (kb.matches(keyData, "tui.select.cancel")) {
+      this.callbacks.onCancel();
+      return;
+    }
+
+    // Everything else → search input (triggers fuzzy filter)
+    this.searchInput.handleInput(keyData);
+    this.filterModels();
+  }
+
+  invalidate(): void {
+    // No cached state to invalidate
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  Private helpers                                                    */
+  /* ------------------------------------------------------------------ */
+
+  private filterModels(): void {
+    const query = this.searchInput.getValue();
+    if (!query) {
+      this.filteredItems = [...this.items];
+    } else {
+      this.filteredItems = fuzzyFilter(
+        this.items,
+        query,
+        (item) => `${item.label} ${item.provider} ${item.value}`,
+      );
+    }
+    // Clamp selection index
+    this.selectedIndex = Math.min(
+      this.selectedIndex,
+      Math.max(0, this.filteredItems.length - 1),
+    );
+    this.updateList();
+  }
+
+  private updateList(): void {
+    this.listContainer.clear();
+
+    const { filteredItems } = this;
+    if (filteredItems.length === 0) {
+      this.listContainer.addChild(
+        new Text(this.theme.fg("muted", "  No matching models"), 0, 0),
+      );
+      return;
+    }
+
+    // Centered scroll window
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        this.selectedIndex - Math.floor(MAX_VISIBLE / 2),
+        filteredItems.length - MAX_VISIBLE,
+      ),
+    );
+    const endIndex = Math.min(startIndex + MAX_VISIBLE, filteredItems.length);
+
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = filteredItems[i];
+      if (!item) continue;
+
+      const isSelected = i === this.selectedIndex;
+      const isCurrent = item.value === this.currentModel;
+
+      let line: string;
+      if (isSelected) {
+        const prefix = this.theme.fg("accent", "→ ");
+        const modelText = this.theme.fg("accent", item.label);
+        const providerBadge = this.theme.fg("muted", `[${item.provider}]`);
+        const checkmark = isCurrent ? this.theme.fg("success", " ✓") : "";
+        line = `${prefix}${modelText} ${providerBadge}${checkmark}`;
+      } else {
+        const modelText = `  ${item.label}`;
+        const providerBadge = this.theme.fg("muted", `[${item.provider}]`);
+        const checkmark = isCurrent ? this.theme.fg("success", " ✓") : "";
+        line = `${modelText} ${providerBadge}${checkmark}`;
+      }
+
+      this.listContainer.addChild(new Text(line, 0, 0));
+    }
+
+    // Scroll indicator when not all items visible
+    if (startIndex > 0 || endIndex < filteredItems.length) {
+      const scrollInfo = this.theme.fg(
+        "muted",
+        `  (${this.selectedIndex + 1}/${filteredItems.length})`,
+      );
+      this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+    }
+  }
+}

package/src/output-file.ts

@@ -0,0 +1,176 @@
+/**
+ * output-file.ts — Human-readable output logging for agent transcripts.
+ *
+ * Forked from upstream pi-subagents. Key modifications:
+ *   - Rewrote from JSONL to human-readable format
+ *   - Path changed to /tmp/pi-agent-outputs/<agentId>.log (no CID-encoded nesting)
+ *   - Directory created with 0o700 permissions
+ *   - Append-only, human-readable, supports `tail -f`
+ *   - Lines: [USER], [TOOL], [ASSISTANT], [DONE] with ISO timestamps
+ */
+
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+
+/** Get an ISO 8601 timestamp string suitable for log output. */
+function timestamp(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Create the output file path for an agent.
+ * Path: /tmp/pi-agent-outputs/<agentId>.log
+ * Ensures the parent directory exists with 0o700 permissions.
+ */
+export function createOutputFilePath(agentId: string): string {
+  const dir = "/tmp/pi-agent-outputs";
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return join(dir, `${agentId}.log`);
+}
+
+/**
+ * Write the initial user prompt entry to the output file.
+ * Format: <ISO timestamp> [USER] <prompt>
+ */
+export function writeInitialEntry(
+  path: string,
+  prompt: string,
+): void {
+  const line = `${timestamp()} [USER] ${prompt}\n`;
+  writeFileSync(path, line, "utf-8");
+}
+
+/** Split text into non-empty lines, prefixing each with a timestamp and role tag. */
+function splitAndPrefix(text: string, role: string): string {
+  return text
+    .split("\n")
+    .filter(Boolean)
+    .map((l) => `${timestamp()} [${role}] ${l}\n`)
+    .join("");
+}
+
+/** Format a toolUse/toolCall content item as a single log line. */
+function formatToolItem(item: Record<string, unknown>): string {
+  const name = item.name ?? item.toolName ?? "unknown";
+  // pi-ai ToolCall uses `arguments`, legacy/anthropic format uses `input`
+  const rawArgs = (item.arguments ?? item.input) as Record<string, unknown> | undefined;
+  let argsStr = "";
+  if (rawArgs && typeof rawArgs === "object" && Object.keys(rawArgs).length > 0) {
+    const keys = Object.keys(rawArgs);
+    if (keys.length === 1) {
+      // Single-arg shorthand: read("src/file.ts")
+      const val = rawArgs[keys[0]];
+      const display = typeof val === "string" && val.length > 200
+        ? JSON.stringify(val.slice(0, 200) + "...")
+        : JSON.stringify(val);
+      argsStr = `(${display})`;
+    } else {
+      argsStr = ` ${JSON.stringify(rawArgs)}`;
+    }
+  }
+  return `${timestamp()} [TOOL] ${name}${argsStr}\n`;
+}
+
+/** Extract text from a user message's content (string or array of items). */
+function extractUserText(content: string | ReadonlyArray<Record<string, unknown>> | undefined): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => String(c.text ?? "")).join("\n");
+  }
+  return "";
+}
+
+/**
+ * Format a single message content item as log lines.
+ * Handles text, toolUse/toolCall, and thinking content.
+ */
+function formatMessageLine(
+  role: "ASSISTANT" | "TOOL" | "USER",
+  content: string | ReadonlyArray<Record<string, unknown>> | undefined,
+): string {
+  if (typeof content === "string") {
+    return splitAndPrefix(content, role);
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (item.type === "text" && typeof item.text === "string") {
+          return splitAndPrefix(item.text, role);
+        }
+        if (item.type === "toolUse" || item.type === "toolCall") {
+          return formatToolItem(item);
+        }
+        if (item.type === "thinking" && typeof item.thinking === "string") {
+          const text = item.redacted ? "[redacted]" : item.thinking;
+          return splitAndPrefix(text, "THINKING");
+        }
+        return "";
+      })
+      .join("");
+  }
+
+  return "";
+}
+
+/**
+ * Subscribe to session events and flush new messages to the output file
+ * on each turn_end. Returns a cleanup function that writes the DONE line
+ * and unsubscribes.
+ *
+ * The optional stats parameter provides final summary data for the DONE line.
+ */
+export function streamToOutputFile(
+  session: AgentSession,
+  path: string,
+  stats?: { turnCount: number; toolUseCount: number; totalTokens: number },
+): () => void {
+  let writtenCount = 1; // initial user prompt already written
+
+  const flush = () => {
+    const messages = session.messages;
+    while (writtenCount < messages.length) {
+      const msg = messages[writtenCount];
+      if (msg.role === "assistant") {
+        const lines = formatMessageLine("ASSISTANT", msg.content as any);
+        if (lines) {
+          try { appendFileSync(path, lines, "utf-8"); } catch { /* ignore write errors */ }
+        }
+      } else if (msg.role === "user") {
+        const text = extractUserText(msg.content as any);
+        if (text.trim()) {
+          try { appendFileSync(path, `${timestamp()} [USER] ${text}\n`, "utf-8"); } catch { /* ignore */ }
+        }
+      }
+      // NOTE: toolResult messages are enumerated as text content and already
+      // included in the assistant message content. No separate TOOL_RESULT role.
+      writtenCount++;
+    }
+  };
+
+  const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+    if (event.type === "turn_end") flush();
+  });
+
+  return () => {
+    // Final flush
+    flush();
+
+    // Write DONE line
+    const { turnCount = 0, toolUseCount = 0, totalTokens = 0 } = stats ?? {};
+    const tokensStr = totalTokens >= 1000
+      ? `${(totalTokens / 1000).toFixed(1)}k tokens`
+      : `${totalTokens} tokens`;
+    try {
+      appendFileSync(
+        path,
+        `${timestamp()} [DONE] ${turnCount} turns, ${toolUseCount} tool uses, ${tokensStr}\n`,
+        "utf-8",
+      );
+    } catch { /* ignore write errors */ }
+
+    // Unsubscribe from session events
+    unsubscribe();
+  };
+}

package/src/prompts.ts

@@ -0,0 +1,61 @@
+/**
+ * prompts.ts — System prompt builder for agents.
+ *
+ * Every agent gets a fresh context — no inherited parent identity.
+ * EnvInfo is imported from types.ts — branch is a string (empty when unknown).
+ */
+
+import type { AgentConfig, EnvInfo } from "./types.js";
+
+/** Extra sections to inject into the system prompt (skills only — no memoryBlock). */
+export interface PromptExtras {
+  /** Preloaded skill contents to inject. */
+  skillBlocks?: { name: string; content: string }[];
+}
+
+/**
+ * Build the system prompt for an agent from its config.
+ *
+ * Always uses fresh-context mode: env header + config.systemPrompt.
+ * Prepends an `<active_agent name=""/>` tag so downstream extensions
+ * (e.g. permission/policy systems) can resolve per-agent policy.
+ *
+ * @param extras  Optional extra sections to inject (preloaded skills).
+ */
+export function buildAgentPrompt(
+  config: AgentConfig,
+  cwd: string,
+  env: EnvInfo,
+  extras?: PromptExtras,
+): string {
+  const activeAgentTag = `<active_agent name="${config.name}"/>\n\n`;
+
+  const envLines = [
+    "# Environment",
+    `Working directory: ${cwd}`,
+    env.isGitRepo ? "Git repository: yes" : "Not a git repository",
+  ];
+  if (env.isGitRepo && env.branch) {
+    envLines.push(`Branch: ${env.branch}`);
+  }
+  envLines.push(`Platform: ${env.platform}`);
+  const envBlock = envLines.join("\n");
+
+  // Build optional extras suffix (skills only — no memoryBlock)
+  const extraSections: string[] = [];
+  if (extras?.skillBlocks?.length) {
+    for (const skill of extras.skillBlocks) {
+      extraSections.push(`\n# Preloaded Skill: ${skill.name}\n${skill.content}`);
+    }
+  }
+  const extrasSuffix = extraSections.length > 0 ? "\n\n" + extraSections.join("\n") : "";
+
+  const header = `You are a pi coding agent sub-agent.
+You have been invoked to handle a specific task autonomously.
+
+${envBlock}`;
+
+  return activeAgentTag + header + "\n\n" + config.systemPrompt + extrasSuffix;
+}
+
+