tau-all-agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gonçalo Silva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# tau-all-agent
+
+Full Tau package for [Pi](https://pi.dev).
+
+## Install
+
+```bash
+pi install npm:tau-all-agent
+```
+
+## Includes
+
+Extensions:
+
+- `answer`
+- `branch-term`
+- `btw`
+- `ghostty`
+- `git-diff-stats`
+- `git-pr-status`
+- `insights`
+- `interlude`
+- `loop`
+- `memory`
+- `notify`
+- `openai-fast`
+- `openai-verbosity`
+- `review`
+- `sandbox`
+- `telegram`
+- `usage`
+- `websearch`
+- `worktree`
+
+Skills:
+
+- `browser-tools`
+- `git-clean-history`
+- `git-commit`
+- `homeassistant-ops`
+- `openscad`
+- `oracle`
+- `sentry`
+- `update-changelog`
+- `web-design`

package/extensions/answer.ts

@@ -0,0 +1,601 @@
+/**
+ * Q&A extraction hook - extracts questions from assistant responses
+ *
+ * Custom interactive TUI for answering questions.
+ *
+ * Demonstrates the "prompt generator" pattern with custom TUI:
+ * 1. /answer command gets the last assistant message
+ * 2. Shows a spinner while extracting questions as structured JSON
+ * 3. Presents an interactive TUI to navigate and answer questions
+ * 4. Submits the compiled answers when done
+ */
+
+import { complete, type Model, type Api, type UserMessage } from "@mariozechner/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { BorderedLoader } from "@mariozechner/pi-coding-agent";
+import {
+  type Component,
+  Editor,
+  type EditorTheme,
+  Key,
+  matchesKey,
+  truncateToWidth,
+  type TUI,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@mariozechner/pi-tui";
+
+const SYSTEM_PROMPT = `You extract items that need user input from assistant text:
+
+- Direct questions
+- Choices between alternatives (even if not phrased as a question)
+- Other pending decisions that still require user input
+
+When a decision is implicit, rewrite it as a clear question.
+
+Output a JSON object with this structure:
+{
+  "questions": [
+    {
+      "question": "Clear question requiring user input",
+      "context": "Optional concise context (options, tradeoffs, constraints)"
+    }
+  ]
+}
+
+Rules:
+- Extract all pending decisions (questions, choices, etc)
+- Keep them in the order they appear
+- Be concise and specific in question text
+- Add context only when it is essential for the user to answer
+- If nothing requires input, return {"questions": []}
+
+Example input: "We can use PostgreSQL (stronger relational features) or SQLite (simpler local setup). Both are viable."
+Example output:
+{
+  "questions": [
+    {
+      "question": "PostgreSQL or SQLite?",
+      "context": "PostgreSQL has stronger relational features; SQLite offers a simpler local setup."
+    }
+  ]
+}
+
+Example input: "I can split this into two commits or keep it in one commit. Either is fine."
+Example output:
+{
+  "questions": [
+    {
+      "question": "Split into two commits or keep as one?"
+    }
+  ]
+}
+
+Example input: "I already started implementing Option A."
+Example output:
+{
+  "questions": []
+}`;
+
+const OPENAI_FAST_MODEL_ID = "gpt-5.3-codex-spark";
+const ANTHROPIC_FAST_MODEL_ID = "claude-haiku-4-5";
+
+// Structured output format for question extraction
+interface ExtractedQuestion {
+  question: string;
+  context?: string;
+}
+
+interface ExtractionResult {
+  questions: ExtractedQuestion[];
+}
+
+interface ModelRequestAuth {
+  model: Model<Api>;
+  apiKey?: string;
+  headers?: Record<string, string>;
+}
+
+type ModelAuthLookup = {
+  find: (provider: string, modelId: string) => Model<Api> | undefined;
+  getApiKeyAndHeaders: (
+    model: Model<Api>,
+  ) => Promise<
+    { ok: true; apiKey?: string; headers?: Record<string, string> } | { ok: false; error: string }
+  >;
+};
+
+type ModelFamily = "openai" | "anthropic";
+
+function detectModelFamily(provider: string): ModelFamily | null {
+  const normalizedProvider = provider.toLowerCase();
+  if (normalizedProvider.includes("openai")) return "openai";
+  if (normalizedProvider.includes("anthropic")) return "anthropic";
+  return null;
+}
+
+/**
+ * Prefer a fast model from the current model family when available.
+ */
+async function selectExtractionModel(
+  currentModel: Model<Api>,
+  modelRegistry: ModelAuthLookup,
+): Promise<ModelRequestAuth | null> {
+  const family = detectModelFamily(currentModel.provider);
+  if (!family) return resolveModelRequestAuth(modelRegistry, currentModel);
+
+  const modelId = family === "openai" ? OPENAI_FAST_MODEL_ID : ANTHROPIC_FAST_MODEL_ID;
+  const providerCandidates =
+    family === "openai"
+      ? [currentModel.provider, "openai-codex", "openai"]
+      : [currentModel.provider, "anthropic"];
+
+  for (const provider of new Set(providerCandidates)) {
+    const model = modelRegistry.find(provider, modelId);
+    if (!model) continue;
+
+    const auth = await resolveModelRequestAuth(modelRegistry, model);
+    if (auth) {
+      return auth;
+    }
+  }
+
+  return resolveModelRequestAuth(modelRegistry, currentModel);
+}
+
+async function resolveModelRequestAuth(
+  modelRegistry: ModelAuthLookup,
+  model: Model<Api>,
+): Promise<ModelRequestAuth | null> {
+  const auth = await modelRegistry.getApiKeyAndHeaders(model);
+  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers } : null;
+}
+
+/**
+ * Parse the JSON response from the LLM
+ */
+function parseExtractionResult(text: string): ExtractionResult | null {
+  try {
+    // Try to find JSON in the response (it might be wrapped in markdown code blocks)
+    let jsonStr = text;
+
+    // Remove markdown code block if present
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      jsonStr = jsonMatch[1].trim();
+    }
+
+    const parsed = JSON.parse(jsonStr);
+    if (parsed && Array.isArray(parsed.questions)) {
+      return parsed as ExtractionResult;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Interactive Q&A component for answering extracted questions
+ */
+class QnAComponent implements Component {
+  private questions: ExtractedQuestion[];
+  private answers: string[];
+  private currentIndex: number = 0;
+  private editor: Editor;
+  private tui: TUI;
+  private onDone: (result: string | null) => void;
+  private showingConfirmation: boolean = false;
+
+  // Cache
+  private cachedWidth?: number;
+  private cachedLines?: string[];
+
+  // Colors - using proper reset sequences
+  private dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
+  private bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
+  private cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
+  private green = (s: string) => `\x1b[32m${s}\x1b[0m`;
+  private yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
+  private gray = (s: string) => `\x1b[90m${s}\x1b[0m`;
+
+  constructor(questions: ExtractedQuestion[], tui: TUI, onDone: (result: string | null) => void) {
+    this.questions = questions;
+    this.answers = questions.map(() => "");
+    this.tui = tui;
+    this.onDone = onDone;
+
+    // Create a minimal theme for the editor
+    const selectedLine = (s: string) => `\x1b[44m${s}\x1b[0m`;
+    const editorTheme: EditorTheme = {
+      borderColor: this.dim,
+      selectList: {
+        selectedPrefix: selectedLine,
+        selectedText: selectedLine,
+        description: this.gray,
+        scrollInfo: this.gray,
+        noMatch: this.gray,
+      },
+    };
+
+    this.editor = new Editor(tui, editorTheme);
+    // Disable the editor's built-in submit (which clears the editor)
+    // We'll handle Enter ourselves to preserve the text
+    this.editor.disableSubmit = true;
+    this.editor.onChange = () => {
+      this.invalidate();
+      this.tui.requestRender();
+    };
+  }
+
+  private allQuestionsAnswered(): boolean {
+    this.saveCurrentAnswer();
+    return this.answers.every((a) => (a?.trim() || "").length > 0);
+  }
+
+  private saveCurrentAnswer(): void {
+    this.answers[this.currentIndex] = this.editor.getText();
+  }
+
+  private navigateTo(index: number): void {
+    if (index < 0 || index >= this.questions.length) return;
+    this.saveCurrentAnswer();
+    this.currentIndex = index;
+    this.editor.setText(this.answers[index] || "");
+    this.invalidate();
+  }
+
+  private submit(): void {
+    this.saveCurrentAnswer();
+
+    // Build the response text
+    const parts: string[] = [];
+    for (let i = 0; i < this.questions.length; i++) {
+      const q = this.questions[i];
+      const a = this.answers[i]?.trim() || "(no answer)";
+      parts.push(`Q: ${q.question}`);
+      if (q.context) {
+        for (const line of q.context.split("\n")) {
+          parts.push(`> ${line}`);
+        }
+        parts.push("");
+      }
+      parts.push(`A: ${a}`);
+      parts.push("");
+    }
+
+    this.onDone(parts.join("\n").trim());
+  }
+
+  private cancel(): void {
+    this.onDone(null);
+  }
+
+  invalidate(): void {
+    this.cachedWidth = undefined;
+    this.cachedLines = undefined;
+  }
+
+  handleInput(data: string): void {
+    // Handle confirmation dialog
+    if (this.showingConfirmation) {
+      if (matchesKey(data, Key.enter) || data.toLowerCase() === "y") {
+        this.submit();
+        return;
+      }
+      if (
+        matchesKey(data, Key.escape) ||
+        matchesKey(data, Key.ctrl("c")) ||
+        data.toLowerCase() === "n"
+      ) {
+        this.showingConfirmation = false;
+        this.invalidate();
+        this.tui.requestRender();
+        return;
+      }
+      return;
+    }
+
+    // Global navigation and commands
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      this.cancel();
+      return;
+    }
+
+    // Tab / Shift+Tab for navigation
+    if (matchesKey(data, Key.tab)) {
+      if (this.currentIndex < this.questions.length - 1) {
+        this.navigateTo(this.currentIndex + 1);
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesKey(data, Key.shift("tab"))) {
+      if (this.currentIndex > 0) {
+        this.navigateTo(this.currentIndex - 1);
+        this.tui.requestRender();
+      }
+      return;
+    }
+
+    // Arrow up/down for question navigation when editor is empty
+    // (Editor handles its own cursor navigation when there's content)
+    if (matchesKey(data, Key.up) && this.editor.getText() === "") {
+      if (this.currentIndex > 0) {
+        this.navigateTo(this.currentIndex - 1);
+        this.tui.requestRender();
+        return;
+      }
+    }
+    if (matchesKey(data, Key.down) && this.editor.getText() === "") {
+      if (this.currentIndex < this.questions.length - 1) {
+        this.navigateTo(this.currentIndex + 1);
+        this.tui.requestRender();
+        return;
+      }
+    }
+
+    // Handle Enter ourselves (editor's submit is disabled)
+    // Plain Enter moves to next question or shows confirmation on last question
+    // Shift+Enter adds a newline (handled by editor)
+    if (matchesKey(data, Key.enter) && !matchesKey(data, Key.shift("enter"))) {
+      this.saveCurrentAnswer();
+      if (this.currentIndex < this.questions.length - 1) {
+        this.navigateTo(this.currentIndex + 1);
+      } else {
+        // On last question - show confirmation
+        this.showingConfirmation = true;
+      }
+      this.invalidate();
+      this.tui.requestRender();
+      return;
+    }
+
+    // Pass to editor
+    this.editor.handleInput(data);
+    this.invalidate();
+    this.tui.requestRender();
+  }
+
+  render(width: number): string[] {
+    if (this.cachedLines && this.cachedWidth === width) {
+      return this.cachedLines;
+    }
+
+    const lines: string[] = [];
+    const boxWidth = Math.min(width - 4, 120); // Allow wider box
+    const contentWidth = boxWidth - 4; // 2 chars padding on each side
+
+    // Helper to create horizontal lines (dim the whole thing at once)
+    const horizontalLine = (count: number) => "─".repeat(count);
+
+    // Helper to create a box line
+    const boxLine = (content: string, leftPad: number = 2): string => {
+      const paddedContent = " ".repeat(leftPad) + content;
+      const contentLen = visibleWidth(paddedContent);
+      const rightPad = Math.max(0, boxWidth - contentLen - 2);
+      return this.dim("│") + paddedContent + " ".repeat(rightPad) + this.dim("│");
+    };
+
+    const emptyBoxLine = (): string => {
+      return this.dim("│") + " ".repeat(boxWidth - 2) + this.dim("│");
+    };
+
+    const padToWidth = (line: string): string => {
+      const len = visibleWidth(line);
+      return line + " ".repeat(Math.max(0, width - len));
+    };
+
+    // Title
+    lines.push(padToWidth(this.dim("╭" + horizontalLine(boxWidth - 2) + "╮")));
+    const title = `${this.bold(this.cyan("Questions"))} ${this.dim(`(${this.currentIndex + 1}/${this.questions.length})`)}`;
+    lines.push(padToWidth(boxLine(title)));
+    lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
+
+    // Progress indicator
+    const progressParts: string[] = [];
+    for (let i = 0; i < this.questions.length; i++) {
+      const answered = (this.answers[i]?.trim() || "").length > 0;
+      const current = i === this.currentIndex;
+      if (current) {
+        progressParts.push(this.cyan("●"));
+      } else if (answered) {
+        progressParts.push(this.green("●"));
+      } else {
+        progressParts.push(this.dim("○"));
+      }
+    }
+    lines.push(padToWidth(boxLine(progressParts.join(" "))));
+    lines.push(padToWidth(emptyBoxLine()));
+
+    // Current question
+    const q = this.questions[this.currentIndex];
+    const questionText = `> ${q.question}`;
+    const wrappedQuestion = wrapTextWithAnsi(questionText, contentWidth);
+    for (const line of wrappedQuestion) {
+      lines.push(padToWidth(boxLine(line)));
+    }
+
+    // Context if present
+    if (q.context) {
+      lines.push(padToWidth(emptyBoxLine()));
+      const contextText = this.gray(`${q.context}`);
+      const wrappedContext = wrapTextWithAnsi(contextText, contentWidth - 2);
+      for (const line of wrappedContext) {
+        lines.push(padToWidth(boxLine(line)));
+      }
+    }
+
+    lines.push(padToWidth(emptyBoxLine()));
+
+    // Render the editor component (multi-line input) with padding
+    // Skip the first and last lines (editor's own border lines)
+    const answerPrefix = this.bold("A: ");
+    const editorWidth = contentWidth - 4 - 3; // Extra padding + space for "A: "
+    const editorLines = this.editor.render(editorWidth);
+    for (let i = 1; i < editorLines.length - 1; i++) {
+      if (i === 1) {
+        // First content line gets the "A: " prefix
+        lines.push(padToWidth(boxLine(answerPrefix + editorLines[i])));
+      } else {
+        // Subsequent lines get padding to align with the first line
+        lines.push(padToWidth(boxLine("   " + editorLines[i])));
+      }
+    }
+
+    lines.push(padToWidth(emptyBoxLine()));
+
+    // Confirmation dialog or footer with controls
+    if (this.showingConfirmation) {
+      lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
+      const confirmMsg = `${this.yellow("Submit all answers?")} ${this.dim("(Enter/y to confirm, Esc/n to cancel)")}`;
+      lines.push(padToWidth(boxLine(truncateToWidth(confirmMsg, contentWidth))));
+    } else {
+      lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
+      const controls = `${this.dim("Tab/Enter")} next · ${this.dim("Shift+Tab")} prev · ${this.dim("Shift+Enter")} newline · ${this.dim("Esc")} cancel`;
+      lines.push(padToWidth(boxLine(truncateToWidth(controls, contentWidth))));
+    }
+    lines.push(padToWidth(this.dim("╰" + horizontalLine(boxWidth - 2) + "╯")));
+
+    this.cachedWidth = width;
+    this.cachedLines = lines;
+    return lines;
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  const answerHandler = async (ctx: ExtensionContext) => {
+    if (!ctx.hasUI) {
+      ctx.ui.notify("answer requires interactive mode", "error");
+      return;
+    }
+
+    if (!ctx.model) {
+      ctx.ui.notify("No model selected", "error");
+      return;
+    }
+
+    // Find the last assistant message on the current branch
+    const branch = ctx.sessionManager.getBranch();
+    let lastAssistantText: string | undefined;
+
+    for (let i = branch.length - 1; i >= 0; i--) {
+      const entry = branch[i];
+      if (entry.type === "message") {
+        const msg = entry.message;
+        if ("role" in msg && msg.role === "assistant") {
+          if (msg.stopReason !== "stop") {
+            ctx.ui.notify(`Last assistant message incomplete (${msg.stopReason})`, "error");
+            return;
+          }
+          const textParts = msg.content
+            .filter((c): c is { type: "text"; text: string } => c.type === "text")
+            .map((c) => c.text);
+          if (textParts.length > 0) {
+            lastAssistantText = textParts.join("\n");
+            break;
+          }
+        }
+      }
+    }
+
+    if (!lastAssistantText) {
+      ctx.ui.notify("No assistant messages found", "error");
+      return;
+    }
+
+    // Select the best model for extraction (prefer a fast model in the current family).
+    const extractionSelection = await selectExtractionModel(ctx.model, ctx.modelRegistry);
+    if (!extractionSelection) {
+      ctx.ui.notify("No configured Pi model is available for question extraction", "error");
+      return;
+    }
+
+    // Run extraction with loader UI
+    const extractionResult = await ctx.ui.custom<ExtractionResult | null>(
+      (tui, theme, _kb, done) => {
+        const loader = new BorderedLoader(
+          tui,
+          theme,
+          `Extracting questions using ${extractionSelection.model.id}...`,
+        );
+        loader.onAbort = () => done(null);
+
+        const doExtract = async () => {
+          const userMessage: UserMessage = {
+            role: "user",
+            content: [{ type: "text", text: lastAssistantText! }],
+            timestamp: Date.now(),
+          };
+
+          const response = await complete(
+            extractionSelection.model,
+            { systemPrompt: SYSTEM_PROMPT, messages: [userMessage] },
+            {
+              apiKey: extractionSelection.apiKey,
+              headers: extractionSelection.headers,
+              signal: loader.signal,
+            },
+          );
+
+          if (response.stopReason === "aborted") {
+            return null;
+          }
+
+          const responseText = response.content
+            .filter((c): c is { type: "text"; text: string } => c.type === "text")
+            .map((c) => c.text)
+            .join("\n");
+
+          return parseExtractionResult(responseText);
+        };
+
+        doExtract()
+          .then(done)
+          .catch(() => done(null));
+
+        return loader;
+      },
+    );
+
+    if (extractionResult === null) {
+      ctx.ui.notify("Cancelled", "info");
+      return;
+    }
+
+    if (extractionResult.questions.length === 0) {
+      ctx.ui.notify("No questions found in the last message", "info");
+      return;
+    }
+
+    // Show the Q&A component
+    const answersResult = await ctx.ui.custom<string | null>((tui, _theme, _kb, done) => {
+      return new QnAComponent(extractionResult.questions, tui, done);
+    });
+
+    if (answersResult === null) {
+      ctx.ui.notify("Cancelled", "info");
+      return;
+    }
+
+    // Send the answers directly as a message and trigger a turn
+    pi.sendMessage(
+      {
+        customType: "answers",
+        content: "Here are my answers to your questions:\n\n" + answersResult,
+        display: true,
+      },
+      { triggerTurn: true },
+    );
+  };
+
+  pi.registerCommand("answer", {
+    description: "Extract questions from last assistant message into interactive Q&A",
+    handler: (_args, ctx) => answerHandler(ctx),
+  });
+
+  pi.registerShortcut("ctrl+.", {
+    description: "Extract and answer questions",
+    handler: answerHandler,
+  });
+}