@tintinweb/pi-subagents 0.2.7 → 0.3.1

package/src/model-resolver.ts

@@ -0,0 +1,81 @@
+/**
+ * Model resolution: exact match ("provider/modelId") with fuzzy fallback.
+ */
+
+export interface ModelEntry {
+  id: string;
+  name: string;
+  provider: string;
+}
+
+export interface ModelRegistry {
+  find(provider: string, modelId: string): any;
+  getAll(): any[];
+  getAvailable?(): any[];
+}
+
+/**
+ * Resolve a model string to a Model instance.
+ * Tries exact match first ("provider/modelId"), then fuzzy match against all available models.
+ * Returns the Model on success, or an error message string on failure.
+ */
+export function resolveModel(
+  input: string,
+  registry: ModelRegistry,
+): any | string {
+  // Available models (those with auth configured)
+  const all = (registry.getAvailable?.() ?? registry.getAll()) as ModelEntry[];
+  const availableSet = new Set(all.map(m => `${m.provider}/${m.id}`.toLowerCase()));
+
+  // 1. Exact match: "provider/modelId" — only if available (has auth)
+  const slashIdx = input.indexOf("/");
+  if (slashIdx !== -1) {
+    const provider = input.slice(0, slashIdx);
+    const modelId = input.slice(slashIdx + 1);
+    if (availableSet.has(input.toLowerCase())) {
+      const found = registry.find(provider, modelId);
+      if (found) return found;
+    }
+  }
+
+  // 2. Fuzzy match against available models
+  const query = input.toLowerCase();
+
+  // Score each model: prefer exact id match > id contains > name contains > provider+id contains
+  let bestMatch: ModelEntry | undefined;
+  let bestScore = 0;
+
+  for (const m of all) {
+    const id = m.id.toLowerCase();
+    const name = m.name.toLowerCase();
+    const full = `${m.provider}/${m.id}`.toLowerCase();
+
+    let score = 0;
+    if (id === query || full === query) {
+      score = 100; // exact
+    } else if (id.includes(query) || full.includes(query)) {
+      score = 60 + (query.length / id.length) * 30; // substring, prefer tighter matches
+    } else if (name.includes(query)) {
+      score = 40 + (query.length / name.length) * 20;
+    } else if (query.split(/[\s\-/]+/).every(part => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))) {
+      score = 20; // all parts present somewhere
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = m;
+    }
+  }
+
+  if (bestMatch && bestScore >= 20) {
+    const found = registry.find(bestMatch.provider, bestMatch.id);
+    if (found) return found;
+  }
+
+  // 3. No match — list available models
+  const modelList = all
+    .map(m => `  ${m.provider}/${m.id}`)
+    .sort()
+    .join("\n");
+  return `Model not found: "${input}".\n\nAvailable models:\n${modelList}`;
+}

package/src/prompts.ts

@@ -1,53 +1,16 @@
 /**
- * prompts.ts — System prompts per agent type.
+ * prompts.ts — System prompt builder for agents.
  */
 
-import type { EnvInfo } from "./types.js";
+import type { AgentConfig, EnvInfo } from "./types.js";
 
-// ---- Reusable prompt blocks ----
-
-const READ_ONLY_PROHIBITION = `You are STRICTLY PROHIBITED from:
-- Creating new files
-- Modifying existing files
-- Deleting files
-- Moving or copying files
-- Creating temporary files anywhere, including /tmp
-- Using redirect operators (>, >>, |) or heredocs to write to files
-- Running ANY commands that change system state`;
-
-const READ_ONLY_TOOLS = `# Tool Usage
-- Use the find tool for file pattern matching (NOT the bash find command)
-- Use the grep tool for content search (NOT bash grep/rg command)
-- Use the read tool for reading files (NOT bash cat/head/tail)
-- Use Bash ONLY for read-only operations`;
-
-const FULL_TOOL_USAGE = `# Tool Usage
-- Use the read tool instead of cat/head/tail
-- Use the edit tool instead of sed/awk
-- Use the write tool instead of echo/heredoc
-- Use the find tool instead of bash find/ls for file search
-- Use the grep tool instead of bash grep/rg for content search
-- Make independent tool calls in parallel`;
-
-const GIT_SAFETY = `# Git Safety
-- NEVER update git config
-- NEVER run destructive git commands (push --force, reset --hard, checkout ., restore ., clean -f, branch -D) without explicit request
-- NEVER skip hooks (--no-verify, --no-gpg-sign) unless explicitly asked
-- NEVER force push to main/master — warn the user if they request it
-- Always create NEW commits, never amend existing ones. When a pre-commit hook fails, the commit did NOT happen — so --amend would modify the PREVIOUS commit. Fix the issue, re-stage, and create a NEW commit
-- Stage specific files by name, not git add -A or git add .
-- NEVER commit changes unless the user explicitly asks
-- NEVER push unless the user explicitly asks
-- NEVER use git commands with the -i flag (like git rebase -i or git add -i) — they require interactive input
-- Do not use --no-edit with git rebase commands
-- Do not commit files that likely contain secrets (.env, credentials.json, etc); warn the user if they request it`;
-
-const OUTPUT_RULES = `# Output
-- Use absolute file paths
-- Do not use emojis
-- Be concise but complete`;
-
-export function buildSystemPrompt(type: string, cwd: string, env: EnvInfo): string {
+/**
+ * Build the system prompt for an agent from its config.
+ *
+ * - "replace" mode: common header + config.systemPrompt
+ * - "append" mode: common header + generic base + config.systemPrompt
+ */
+export function buildAgentPrompt(config: AgentConfig, cwd: string, env: EnvInfo): string {
   const commonHeader = `You are a pi coding agent sub-agent.
 You have been invoked to handle a specific task autonomously.
 
@@ -56,108 +19,30 @@ Working directory: ${cwd}
 ${env.isGitRepo ? `Git repository: yes\nBranch: ${env.branch}` : "Not a git repository"}
 Platform: ${env.platform}`;
 
-  switch (type) {
-    case "Explore":
-      return `${commonHeader}
-
-# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
-You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
-Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools.
-
-${READ_ONLY_PROHIBITION}
-
-Use Bash ONLY for read-only operations: ls, git status, git log, git diff, find, cat, head, tail.
-
-${READ_ONLY_TOOLS}
-- Make independent tool calls in parallel for efficiency
-- Adapt search approach based on thoroughness level specified
-
-# Output
-- Use absolute file paths in all references
-- Report findings as regular messages
-- Do not use emojis
-- Be thorough and precise`;
-
-    case "Plan":
-      return `${commonHeader}
-
-# CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS
-You are a software architect and planning specialist.
-Your role is EXCLUSIVELY to explore the codebase and design implementation plans.
-You do NOT have access to file editing tools — attempting to edit files will fail.
-
-${READ_ONLY_PROHIBITION}
-
-# Planning Process
-1. Understand requirements
-2. Explore thoroughly (read files, find patterns, understand architecture)
-3. Design solution based on your assigned perspective
-4. Detail the plan with step-by-step implementation strategy
-
-# Requirements
-- Consider trade-offs and architectural decisions
-- Identify dependencies and sequencing
-- Anticipate potential challenges
-- Follow existing patterns where appropriate
-
-${READ_ONLY_TOOLS}
-
-# Output Format
-- Use absolute file paths
-- Do not use emojis
-- End your response with:
-
-### Critical Files for Implementation
-List 3-5 files most critical for implementing this plan:
-- /absolute/path/to/file.ts - [Brief reason]`;
-
-    case "general-purpose":
-      return `${commonHeader}
+  if (config.promptMode === "append") {
+    const genericBase = `
 
 # Role
 You are a general-purpose coding agent for complex, multi-step tasks.
 You have full access to read, write, edit files, and execute commands.
 Do what has been asked; nothing more, nothing less.
 
-${FULL_TOOL_USAGE}
-
-# File Operations
-- NEVER create files unless absolutely necessary
-- Prefer editing existing files over creating new ones
-- NEVER create documentation files unless explicitly requested
-
-${GIT_SAFETY}
-
-${OUTPUT_RULES}`;
-
-    case "statusline-setup":
-      return `${commonHeader}
-
-# Role
-You configure settings. You can read and edit files only.
-Focus on the specific configuration task requested.
-Use absolute file paths.`;
-
-    case "claude-code-guide":
-      return `${commonHeader}
-
-# Role
-You help answer questions about the tool, its features, and capabilities.
-Search documentation, read config files, and provide accurate answers.
-You have read-only access to the codebase for reference.
-Use absolute file paths.`;
-
-    default:
-      // Custom agents or unknown: general-purpose base without git safety / file ops
-      return `${commonHeader}
-
-# Role
-You are a general-purpose coding agent for complex, multi-step tasks.
-You have full access to read, write, edit files, and execute commands.
-Do what has been asked; nothing more, nothing less.
+# Tool Usage
+- Use the read tool instead of cat/head/tail
+- Use the edit tool instead of sed/awk
+- Use the write tool instead of echo/heredoc
+- Use the find tool instead of bash find/ls for file search
+- Use the grep tool instead of bash grep/rg for content search
+- Make independent tool calls in parallel
 
-${FULL_TOOL_USAGE}
+# Output
+- Use absolute file paths
+- Do not use emojis
+- Be concise but complete`;
 
-${OUTPUT_RULES}`;
+    return commonHeader + genericBase + "\n\n" + config.systemPrompt;
   }
+
+  // "replace" mode — header + the config's full system prompt
+  return commonHeader + "\n\n" + config.systemPrompt;
 }

package/src/types.ts

@@ -7,44 +7,18 @@ import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
 
 export type { ThinkingLevel };
 
-/** Built-in agent types. Custom agents use arbitrary string names. */
-export type BuiltinSubagentType = "general-purpose" | "Explore" | "Plan" | "statusline-setup" | "claude-code-guide";
+/** Agent type: any string name (built-in defaults or user-defined). */
+export type SubagentType = string;
 
-/** Agent type: built-in or custom (any string). */
-export type SubagentType = BuiltinSubagentType | (string & {});
+/** Names of the three embedded default agents. */
+export const DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"] as const;
 
-/** Display name mapping for built-in types. */
-export const DISPLAY_NAMES: Record<BuiltinSubagentType, string> = {
-  "general-purpose": "Agent",
-  "Explore": "Explore",
-  "Plan": "Plan",
-  "statusline-setup": "Config",
-  "claude-code-guide": "Guide",
-};
-
-export const SUBAGENT_TYPES: BuiltinSubagentType[] = [
-  "general-purpose",
-  "Explore",
-  "Plan",
-  "statusline-setup",
-  "claude-code-guide",
-];
-
-export interface SubagentTypeConfig {
-  displayName: string;
-  description: string;
-  builtinToolNames: string[];
-  /** true = inherit all, string[] = only listed, false = none */
-  extensions: true | string[] | false;
-  /** true = inherit all, string[] = only listed, false = none */
-  skills: true | string[] | false;
-}
-
-/** Configuration for a custom agent loaded from .pi/agents/<name>.md */
-export interface CustomAgentConfig {
+/** Unified agent configuration — used for both default and user-defined agents. */
+export interface AgentConfig {
   name: string;
+  displayName?: string;
   description: string;
-  builtinToolNames: string[];
+  builtinToolNames?: string[];
   /** true = inherit all, string[] = only listed, false = none */
   extensions: true | string[] | false;
   /** true = inherit all, string[] = only listed, false = none */
@@ -60,6 +34,12 @@ export interface CustomAgentConfig {
   runInBackground: boolean;
   /** Default for spawn: no extension tools */
   isolated: boolean;
+  /** true = this is an embedded default agent (informational) */
+  isDefault?: boolean;
+  /** false = agent is hidden from the registry */
+  enabled?: boolean;
+  /** Where this agent was loaded from */
+  source?: "default" | "project" | "global";
 }
 
 export type JoinMode = 'async' | 'group' | 'smart';

package/src/ui/conversation-viewer.ts

@@ -0,0 +1,241 @@
+/**
+ * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ *
+ * Displays a scrollable, live-updating view of an agent's conversation.
+ * Subscribes to session events for real-time streaming updates.
+ */
+
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component, type TUI } from "@mariozechner/pi-tui";
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { Theme } from "./agent-widget.js";
+import { formatTokens, formatDuration, getDisplayName, describeActivity, type AgentActivity } from "./agent-widget.js";
+import type { AgentRecord } from "../types.js";
+import { extractText } from "../context.js";
+
+/** Lines consumed by chrome: top border + header + header sep + footer sep + footer + bottom border. */
+const CHROME_LINES = 6;
+const MIN_VIEWPORT = 3;
+
+export class ConversationViewer implements Component {
+  private scrollOffset = 0;
+  private autoScroll = true;
+  private unsubscribe: (() => void) | undefined;
+  private lastInnerW = 0;
+  private closed = false;
+
+  constructor(
+    private tui: TUI,
+    private session: AgentSession,
+    private record: AgentRecord,
+    private activity: AgentActivity | undefined,
+    private theme: Theme,
+    private done: (result: undefined) => void,
+  ) {
+    this.unsubscribe = session.subscribe(() => {
+      if (this.closed) return;
+      this.tui.requestRender();
+    });
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+      this.closed = true;
+      this.done(undefined);
+      return;
+    }
+
+    const totalLines = this.buildContentLines(this.lastInnerW).length;
+    const viewportHeight = this.viewportHeight();
+    const maxScroll = Math.max(0, totalLines - viewportHeight);
+
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "pageUp")) {
+      this.scrollOffset = Math.max(0, this.scrollOffset - viewportHeight);
+      this.autoScroll = false;
+    } else if (matchesKey(data, "pageDown")) {
+      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + viewportHeight);
+      this.autoScroll = this.scrollOffset >= maxScroll;
+    } else if (matchesKey(data, "home")) {
+      this.scrollOffset = 0;
+      this.autoScroll = false;
+    } else if (matchesKey(data, "end")) {
+      this.scrollOffset = maxScroll;
+      this.autoScroll = true;
+    }
+  }
+
+  render(width: number): string[] {
+    if (width < 6) return []; // too narrow for any meaningful rendering
+    const th = this.theme;
+    const innerW = width - 4; // border + padding
+    this.lastInnerW = innerW;
+    const lines: string[] = [];
+
+    const pad = (s: string, len: number) => {
+      const vis = visibleWidth(s);
+      return s + " ".repeat(Math.max(0, len - vis));
+    };
+    const row = (content: string) =>
+      th.fg("border", "│") + " " + truncateToWidth(pad(content, innerW), innerW) + " " + th.fg("border", "│");
+    const hrTop = th.fg("border", `╭${"─".repeat(width - 2)}╮`);
+    const hrBot = th.fg("border", `╰${"─".repeat(width - 2)}╯`);
+    const hrMid = row(th.fg("dim", "─".repeat(innerW)));
+
+    // Header
+    lines.push(hrTop);
+    const name = getDisplayName(this.record.type);
+    const statusIcon = this.record.status === "running"
+      ? th.fg("accent", "●")
+      : this.record.status === "completed"
+        ? th.fg("success", "✓")
+        : this.record.status === "error"
+          ? th.fg("error", "✗")
+          : th.fg("dim", "○");
+    const duration = formatDuration(this.record.startedAt, this.record.completedAt);
+
+    const headerParts: string[] = [duration];
+    const toolUses = this.activity?.toolUses ?? this.record.toolUses;
+    if (toolUses > 0) headerParts.unshift(`${toolUses} tool${toolUses === 1 ? "" : "s"}`);
+    if (this.activity?.session) {
+      try {
+        const tokens = this.activity.session.getSessionStats().tokens.total;
+        if (tokens > 0) headerParts.push(formatTokens(tokens));
+      } catch { /* */ }
+    }
+
+    lines.push(row(
+      `${statusIcon} ${th.bold(name)}  ${th.fg("muted", this.record.description)} ${th.fg("dim", "·")} ${th.fg("dim", headerParts.join(" · "))}`,
+    ));
+    lines.push(hrMid);
+
+    // Content area — rebuild every render (live data, no cache needed)
+    const contentLines = this.buildContentLines(innerW);
+    const viewportHeight = this.viewportHeight();
+    const maxScroll = Math.max(0, contentLines.length - viewportHeight);
+
+    if (this.autoScroll) {
+      this.scrollOffset = maxScroll;
+    }
+
+    const visibleStart = Math.min(this.scrollOffset, maxScroll);
+    const visible = contentLines.slice(visibleStart, visibleStart + viewportHeight);
+
+    for (let i = 0; i < viewportHeight; i++) {
+      lines.push(row(visible[i] ?? ""));
+    }
+
+    // Footer
+    lines.push(hrMid);
+    const scrollPct = contentLines.length <= viewportHeight
+      ? "100%"
+      : `${Math.round(((visibleStart + viewportHeight) / contentLines.length) * 100)}%`;
+    const footerLeft = th.fg("dim", `${contentLines.length} lines · ${scrollPct}`);
+    const footerRight = th.fg("dim", "↑↓ scroll · PgUp/PgDn · Esc close");
+    const footerGap = Math.max(1, innerW - visibleWidth(footerLeft) - visibleWidth(footerRight));
+    lines.push(row(footerLeft + " ".repeat(footerGap) + footerRight));
+    lines.push(hrBot);
+
+    return lines;
+  }
+
+  invalidate(): void { /* no cached state to clear */ }
+
+  dispose(): void {
+    this.closed = true;
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+    }
+  }
+
+  // ---- Private ----
+
+  private viewportHeight(): number {
+    return Math.max(MIN_VIEWPORT, this.tui.terminal.rows - CHROME_LINES);
+  }
+
+  private buildContentLines(width: number): string[] {
+    if (width <= 0) return [];
+
+    const th = this.theme;
+    const messages = this.session.messages;
+    const lines: string[] = [];
+
+    if (messages.length === 0) {
+      lines.push(th.fg("dim", "(waiting for first message...)"));
+      return lines;
+    }
+
+    let needsSeparator = false;
+    for (const msg of messages) {
+      if (msg.role === "user") {
+        const text = typeof msg.content === "string"
+          ? msg.content
+          : extractText(msg.content);
+        if (!text.trim()) continue;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.fg("accent", "[User]"));
+        for (const line of wrapTextWithAnsi(text.trim(), width)) {
+          lines.push(line);
+        }
+      } else if (msg.role === "assistant") {
+        const textParts: string[] = [];
+        const toolCalls: string[] = [];
+        for (const c of msg.content) {
+          if (c.type === "text" && c.text) textParts.push(c.text);
+          else if (c.type === "toolCall") {
+            toolCalls.push((c as any).toolName ?? "unknown");
+          }
+        }
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.bold("[Assistant]"));
+        if (textParts.length > 0) {
+          for (const line of wrapTextWithAnsi(textParts.join("\n").trim(), width)) {
+            lines.push(line);
+          }
+        }
+        for (const name of toolCalls) {
+          lines.push(truncateToWidth(th.fg("muted", `  [Tool: ${name}]`), width));
+        }
+      } else if (msg.role === "toolResult") {
+        const text = extractText(msg.content);
+        const truncated = text.length > 500 ? text.slice(0, 500) + "... (truncated)" : text;
+        if (!truncated.trim()) continue;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(th.fg("dim", "[Result]"));
+        for (const line of wrapTextWithAnsi(truncated.trim(), width)) {
+          lines.push(th.fg("dim", line));
+        }
+      } else if ((msg as any).role === "bashExecution") {
+        const bash = msg as any;
+        if (needsSeparator) lines.push(th.fg("dim", "───"));
+        lines.push(truncateToWidth(th.fg("muted", `  $ ${bash.command}`), width));
+        if (bash.output?.trim()) {
+          const out = bash.output.length > 500
+            ? bash.output.slice(0, 500) + "... (truncated)"
+            : bash.output;
+          for (const line of wrapTextWithAnsi(out.trim(), width)) {
+            lines.push(th.fg("dim", line));
+          }
+        }
+      } else {
+        continue;
+      }
+      needsSeparator = true;
+    }
+
+    // Streaming indicator for running agents
+    if (this.record.status === "running" && this.activity) {
+      const act = describeActivity(this.activity.activeTools, this.activity.responseText);
+      lines.push("");
+      lines.push(truncateToWidth(th.fg("accent", "▍ ") + th.fg("dim", act), width));
+    }
+
+    return lines;
+  }
+}