tau-coding-agent 0.1.1 → 0.1.3

package/README.md

@@ -1,6 +1,8 @@
 # tau-coding-agent
 
-Coding-focused Tau package for [Pi](https://pi.dev).
+Coding agent built on top of [Pi](https://pi.dev).
+
+Tau turns Pi's minimal core into an opinionated, polished coding-agent setup with web search, code review workflows, sandboxing, local memory, usage reporting, and a curated skill set for day-to-day software work.
 
 ## Install
 
@@ -8,39 +10,54 @@ Coding-focused Tau package for [Pi](https://pi.dev).
 pi install npm:tau-coding-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`
-- `usage`
-- `websearch`
-- `worktree`
-
-Skills:
-
-- `browser-tools`
-- `git-clean-history`
-- `git-commit`
-- `oracle`
-- `sentry`
-- `update-changelog`
-- `web-design`
-
-Themes:
-
-- `tau-dark`
+Project-local install lets a repository pin Tau for everyone working on it:
+
+```bash
+pi install -l npm:tau-coding-agent
+```
+
+## Extensions
+
+| Extension           | Command              | Description                                                                                                               |
+| ------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `answer`            | `/answer`            | Extract and interactively answer agent questions.                                                                         |
+| `branch-term`       | `/branch`            | Open a new terminal on the current session's git branch.                                                                  |
+| `btw`               | `/btw`               | Run a one-off side request with read-only tools and no context persistence.                                               |
+| `ghostty`           | —                    | Ghostty tab title enhancements while the agent is working, waiting, or idle.                                              |
+| `git-diff-stats`    | —                    | Status bar diff stats for local changes in the current repo.                                                              |
+| `git-pr-status`     | —                    | Status bar PR number and link for the current branch.                                                                     |
+| `insights`          | `/insights`          | Analyze Pi sessions and suggest reusable instructions, templates, skills, and extensions.                                 |
+| `interlude`         | `alt+x`              | Stash the current message draft, send one interlude message, then restore the draft.                                      |
+| `loop`              | `/loop`              | Repeat a prompt until the agent signals success.                                                                          |
+| `memory`            | `/memory`            | Opt-in project-local memory for learning and continuity across sessions.                                                  |
+| `notify`            | —                    | Terminal notification when the agent is waiting for input.                                                                |
+| `openai-fast`       | `/fast`              | Toggle priority service tier for supported OpenAI models.                                                                 |
+| `openai-verbosity`  | `/verbosity`         | Set verbosity for supported OpenAI models.                                                                                |
+| `review`            | `/review`, `/triage` | Multi-focus review and PR feedback triage for PRs, branches, commits, and local changes, with integrated follow-up fixes. |
+| `sandbox`           | `/sandbox`           | OS-level sandboxing for bash commands with runtime overrides.                                                             |
+| `tool-display-mode` | `ctrl+o`             | Cycle tool output between Pi's default rendering, expanded output, and compact summaries.                                 |
+| `usage`             | `/usage`             | Historical provider usage breakdown with all-provider history and live quota snapshots.                                   |
+| `websearch`         | —                    | Web search via Gemini, OpenAI, or Claude, leveraging Pi or browser session credentials.                                   |
+| `worktree`          | `/worktree`          | Create, list, and archive git worktrees, optionally opening them in a new terminal or tmux pane.                          |
+
+## Skills
+
+| Skill               | Description                                                                        |
+| ------------------- | ---------------------------------------------------------------------------------- |
+| `browser-tools`     | Interactive browser automation via Chrome DevTools Protocol.                       |
+| `git-clean-history` | Reimplement a branch on a fresh branch off `main` with a clean commit history.     |
+| `git-commit`        | Tidy, focused commits with clear rationale in messages.                            |
+| `oracle`            | Second opinion from another LLM for debugging, refactors, design, or code reviews. |
+| `sentry`            | Fetch and analyze Sentry issues, events, transactions, and logs.                   |
+| `update-changelog`  | Update CHANGELOG.md following Keep a Changelog.                                    |
+| `web-design`        | Distinctive, production-ready web interfaces.                                      |
+
+## Themes
+
+| Theme      | Description                                                   |
+| ---------- | ------------------------------------------------------------- |
+| `tau-dark` | Pi's official dark theme with a calmer, more cohesive polish. |
+
+## Agent configuration
+
+Tau does not include agent configuration; those files are highly personal. Configure Pi with your own `AGENTS.md`, `settings.json`, sandbox config, and model preferences.

package/extensions/sandbox/index.ts

@@ -74,24 +74,68 @@ const DEFAULT_CONFIG: SandboxConfig = {
   mode: DEFAULT_PROMPT_MODE,
   network: {
     allowedDomains: [
+      "localhost",
+      "127.0.0.1",
       "npmjs.org",
       "*.npmjs.org",
       "registry.npmjs.org",
       "registry.yarnpkg.com",
       "pypi.org",
       "*.pypi.org",
+      "pythonhosted.org",
+      "*.pythonhosted.org",
+      "crates.io",
+      "*.crates.io",
+      "proxy.golang.org",
+      "sum.golang.org",
+      "go.dev",
+      "golang.org",
+      "rubygems.org",
+      "*.rubygems.org",
       "github.com",
       "*.github.com",
+      "githubusercontent.com",
+      "*.githubusercontent.com",
       "api.github.com",
       "raw.githubusercontent.com",
+      "ghcr.io",
+      "docker.io",
+      "*.docker.io",
+      "production.cloudflare.docker.com",
+      "sentry.io",
+      "*.sentry.io",
+      "datadoghq.com",
+      "*.datadoghq.com",
+      "datadoghq.eu",
+      "*.datadoghq.eu",
+      "anthropic.com",
+      "*.anthropic.com",
+      "claude.ai",
+      "*.claude.ai",
+      "openai.com",
+      "*.openai.com",
+      "chatgpt.com",
+      "*.chatgpt.com",
+      "google.com",
+      "*.google.com",
+      "googleapis.com",
+      "*.googleapis.com",
+      "todoist.com",
+      "*.todoist.com",
+      "twist.com",
+      "*.twist.com",
+      "doist.com",
+      "*.doist.com",
     ],
     deniedDomains: [],
+    allowLocalBinding: true,
   },
   filesystem: {
     denyRead: ["~/.ssh", "~/.aws", "~/.gnupg"],
-    allowWrite: [".", "/tmp"],
+    allowWrite: [".", "/tmp", "/private/tmp", "~/.cache", "~/.npm"],
     denyWrite: [".env", ".env.*", "*.pem", "*.key"],
-    allowGitCommonDir: false,
+    allowGitConfig: true,
+    allowGitCommonDir: true,
   },
 };
 
@@ -2455,11 +2499,15 @@ export default function (pi: ExtensionAPI) {
           "  Network:",
           `    Allowed: ${runtimeConfig.network.allowedDomains.join(", ") || "(none)"}`,
           `    Denied: ${runtimeConfig.network.deniedDomains.join(", ") || "(none)"}`,
+          `    allowLocalBinding: ${runtimeConfig.network.allowLocalBinding ? "true" : "false"}`,
+          `    allowAllUnixSockets: ${runtimeConfig.network.allowAllUnixSockets ? "true" : "false"}`,
+          `    allowUnixSockets: ${runtimeConfig.network.allowUnixSockets?.join(", ") || "(none)"}`,
           "",
           "  Filesystem:",
           `    Deny Read: ${runtimeConfig.filesystem.denyRead.join(", ") || "(none)"}`,
           `    Allow Write: ${runtimeConfig.filesystem.allowWrite.join(", ") || "(none)"}`,
           `    Deny Write: ${runtimeConfig.filesystem.denyWrite.join(", ") || "(none)"}`,
+          `    allowGitConfig: ${runtimeConfig.filesystem.allowGitConfig ? "true" : "false"}`,
           `    allowGitCommonDir: ${sandboxConfig?.filesystem.allowGitCommonDir ? "true" : "false"}`,
           "",
           "  Advanced:",

package/extensions/tool-display-mode.ts

@@ -0,0 +1,387 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  CustomEditor,
+  createBashToolDefinition,
+  createFindToolDefinition,
+  createGrepToolDefinition,
+  createLsToolDefinition,
+  createReadToolDefinition,
+  type AgentToolResult,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type KeybindingsManager,
+  type Theme,
+  type ToolDefinition,
+  type ToolInfo,
+  type ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import { Container, Text, type Component, type EditorTheme, type TUI } from "@mariozechner/pi-tui";
+
+// --- Constants ---
+
+const CONFIG_FILE = "tool-display-mode.json";
+const MODES = ["default", "expanded", "minimal"] as const;
+const DEFAULT_MODE = "default";
+
+// These are current Pi built-in tool output messages, used only because grep/find/ls
+// do not expose structured zero-result details yet.
+const GREP_NO_MATCHES_OUTPUT = "No matches found"; // core/tools/grep.ts
+const FIND_NO_MATCHES_OUTPUT = "No files found matching pattern"; // core/tools/find.ts
+const LS_EMPTY_DIRECTORY_OUTPUT = "(empty directory)"; // core/tools/ls.ts
+
+const TOOL_FACTORIES = {
+  read: createReadToolDefinition,
+  bash: createBashToolDefinition,
+  grep: createGrepToolDefinition,
+  find: createFindToolDefinition,
+  ls: createLsToolDefinition,
+};
+
+// --- Types ---
+
+type Mode = (typeof MODES)[number];
+type ToolName = keyof typeof TOOL_FACTORIES;
+type AnyToolDefinition = ToolDefinition<any, any, any>;
+type AnyToolRenderContext = Parameters<NonNullable<AnyToolDefinition["renderResult"]>>[3];
+type JsonObject = Record<string, unknown>;
+
+type ToolDisplayModeConfig = {
+  mode: Mode;
+};
+
+// --- Config ---
+
+function emptyConfig(): ToolDisplayModeConfig {
+  return { mode: DEFAULT_MODE };
+}
+
+function getConfigPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+  return path.join(agentDir, CONFIG_FILE);
+}
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isMode(value: string): value is Mode {
+  return (MODES as readonly string[]).includes(value);
+}
+
+function parseMode(value: unknown): Mode | undefined {
+  if (typeof value !== "string") return undefined;
+
+  const normalized = value.trim().toLowerCase();
+  return isMode(normalized) ? normalized : undefined;
+}
+
+function parseConfig(value: unknown): ToolDisplayModeConfig {
+  if (!isObject(value)) return emptyConfig();
+
+  return {
+    mode: parseMode(value.mode) ?? DEFAULT_MODE,
+  };
+}
+
+async function loadConfig(): Promise<ToolDisplayModeConfig> {
+  try {
+    const raw = await readFile(getConfigPath(), "utf8");
+    return parseConfig(JSON.parse(raw) as unknown);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT") {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[tool-display-mode] Failed to load config: ${message}`);
+    }
+
+    return emptyConfig();
+  }
+}
+
+async function saveConfig(config: ToolDisplayModeConfig): Promise<void> {
+  const configPath = getConfigPath();
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+// --- Tool definitions ---
+
+function getToolDefinition(
+  cache: Map<string, Partial<Record<ToolName, AnyToolDefinition>>>,
+  name: ToolName,
+  cwd: string,
+): AnyToolDefinition {
+  let tools = cache.get(cwd);
+  if (!tools) {
+    tools = {};
+    cache.set(cwd, tools);
+  }
+
+  return (tools[name] ??= TOOL_FACTORIES[name](cwd));
+}
+
+function shouldRegisterToolRenderer(tools: ToolInfo[], name: ToolName): boolean {
+  const existingTool = tools.find((tool) => tool.name === name);
+  return existingTool?.sourceInfo.source === "builtin";
+}
+
+function createToolDisplayDefinition(options: {
+  cache: Map<string, Partial<Record<ToolName, AnyToolDefinition>>>;
+  name: ToolName;
+  getMode: () => Mode;
+}): AnyToolDefinition {
+  const { cache, name, getMode } = options;
+  const base = getToolDefinition(cache, name, process.cwd());
+
+  return {
+    ...base,
+
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getToolDefinition(cache, name, ctx.cwd).execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+        ctx,
+      );
+    },
+
+    renderCall(args, theme, context) {
+      const renderer = getToolDefinition(cache, name, context.cwd).renderCall;
+      return renderer?.(args, theme, { ...context, lastComponent: undefined }) ?? emptyComponent();
+    },
+
+    renderResult(result, options, theme, context) {
+      const mode = getMode();
+      const renderer = getToolDefinition(cache, name, context.cwd).renderResult;
+
+      if (mode === "minimal") {
+        if (name === "bash") {
+          renderer?.(result, options, theme, { ...context, lastComponent: undefined });
+        }
+
+        return renderMinimalResult(name, result, options, theme, context);
+      }
+
+      const expanded = mode === "expanded";
+      return (
+        renderer?.(result, { ...options, expanded }, theme, {
+          ...context,
+          expanded,
+          lastComponent: undefined,
+        }) ?? emptyComponent()
+      );
+    },
+  };
+}
+
+// --- Display mode ---
+
+function nextMode(currentMode: Mode): Mode {
+  const index = MODES.indexOf(currentMode);
+  return MODES[(index + 1) % MODES.length] ?? DEFAULT_MODE;
+}
+
+function applyMode(ctx: ExtensionContext, mode: Mode): void {
+  if (!ctx.hasUI) return;
+
+  ctx.ui.setToolsExpanded(mode === "expanded");
+}
+
+function showModeChange(ctx: ExtensionContext, mode: Mode): void {
+  if (!ctx.hasUI) return;
+
+  ctx.ui.notify(`Tool output: ${mode}`, "info");
+}
+
+function reportSaveError(ctx: ExtensionContext, error: unknown): void {
+  const message = error instanceof Error ? error.message : String(error);
+  if (ctx.hasUI) {
+    ctx.ui.notify(`Failed to save ${getConfigPath()}: ${message}`, "error");
+    return;
+  }
+
+  console.warn(`[tool-display-mode] Failed to save config: ${message}`);
+}
+
+// --- Minimal rendering ---
+
+function renderMinimalResult(
+  name: ToolName,
+  result: AgentToolResult<any>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: AnyToolRenderContext,
+): Component {
+  if (context.isError) {
+    return renderMinimalText(theme, "error", lastNonEmptyLine(textOutput(result)) ?? "error");
+  }
+
+  if (options.isPartial) {
+    return renderMinimalText(theme, "muted", "running...");
+  }
+
+  let summary: string;
+  switch (name) {
+    case "bash":
+      summary = bashSummary(result);
+      break;
+    case "read":
+      summary = readSummary(result);
+      break;
+    case "grep":
+      summary = grepSummary(result);
+      break;
+    case "find":
+      summary = resultsSummary(result, "path");
+      break;
+    case "ls":
+      summary = resultsSummary(result, "entry");
+      break;
+  }
+
+  return renderMinimalText(theme, "muted", `→ ${summary}`);
+}
+
+function renderMinimalText(theme: Theme, color: "error" | "muted", text: string): Text {
+  return new Text(theme.fg(color, `\n${text}`), 0, 0);
+}
+
+function bashSummary(result: AgentToolResult<any>): string {
+  const text = stripTrailingNotice(textOutput(result)).trim();
+  if (!text || text === "(no output)") return "no output";
+
+  const lines = countLines(text);
+  return `${lines} ${plural(lines, "line")}`;
+}
+
+function readSummary(result: AgentToolResult<any>): string {
+  if (result.content.some((content) => content.type === "image")) {
+    return "image";
+  }
+
+  const details = result.details as { truncation?: { outputLines?: number } } | undefined;
+  const lines =
+    details?.truncation?.outputLines ?? countLines(stripTrailingNotice(textOutput(result)));
+
+  return `${lines} ${plural(lines, "line")}`;
+}
+
+function grepSummary(result: AgentToolResult<any>): string {
+  const text = stripTrailingNotice(textOutput(result)).trim();
+  if (!text || text === GREP_NO_MATCHES_OUTPUT) {
+    return "0 lines";
+  }
+
+  const lines = text.split("\n").filter(Boolean);
+  const matchLines = lines.filter((line) => /:\d+: /.test(line));
+  const count = matchLines.length > 0 ? matchLines.length : lines.length;
+  return `${count} ${plural(count, "line")}`;
+}
+
+function resultsSummary(result: AgentToolResult<any>, noun: string): string {
+  const text = stripTrailingNotice(textOutput(result)).trim();
+  if (!text || text === FIND_NO_MATCHES_OUTPUT || text === LS_EMPTY_DIRECTORY_OUTPUT) {
+    return `0 ${plural(0, noun)}`;
+  }
+
+  const count = text.split("\n").filter(Boolean).length;
+  return `${count} ${plural(count, noun)}`;
+}
+
+function textOutput(result: AgentToolResult<any>): string {
+  return result.content
+    .filter((content) => content.type === "text")
+    .map((content) => content.text ?? "")
+    .join("\n");
+}
+
+function stripTrailingNotice(text: string): string {
+  return text.replace(/\n\n\[[\s\S]*\]$/, "");
+}
+
+function countLines(text: string): number {
+  if (text.length === 0) return 0;
+
+  const lines = text.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines.length;
+}
+
+function lastNonEmptyLine(text: string): string | undefined {
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .at(-1);
+}
+
+function plural(count: number, singular: string): string {
+  return count === 1 ? singular : `${singular}s`;
+}
+
+function emptyComponent(): Container {
+  return new Container();
+}
+
+// --- Editor ---
+
+class ToolDisplayEditor extends CustomEditor {
+  constructor(
+    tui: TUI,
+    theme: EditorTheme,
+    private readonly appKeybindings: KeybindingsManager,
+    private readonly cycleMode: () => void,
+  ) {
+    super(tui, theme, appKeybindings);
+  }
+
+  override handleInput(data: string): void {
+    if (this.appKeybindings.matches(data, "app.tools.expand")) {
+      this.cycleMode();
+      return;
+    }
+
+    super.handleInput(data);
+  }
+}
+
+export default function toolDisplayModeExtension(pi: ExtensionAPI): void {
+  let mode: Mode = DEFAULT_MODE;
+  let registeredToolRenderers = false;
+  const toolCache = new Map<string, Partial<Record<ToolName, AnyToolDefinition>>>();
+
+  const setMode = (ctx: ExtensionContext, next: Mode): void => {
+    mode = next;
+    applyMode(ctx, mode);
+    showModeChange(ctx, mode);
+
+    void saveConfig({ mode }).catch((error) => reportSaveError(ctx, error));
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    mode = (await loadConfig()).mode;
+
+    if (!registeredToolRenderers) {
+      const tools = pi.getAllTools();
+      for (const name of Object.keys(TOOL_FACTORIES) as ToolName[]) {
+        if (!shouldRegisterToolRenderer(tools, name)) continue;
+
+        pi.registerTool(
+          createToolDisplayDefinition({ cache: toolCache, name, getMode: () => mode }),
+        );
+      }
+      registeredToolRenderers = true;
+    }
+
+    applyMode(ctx, mode);
+    if (!ctx.hasUI) return;
+
+    ctx.ui.setEditorComponent(
+      (tui, theme, keybindings) =>
+        new ToolDisplayEditor(tui, theme, keybindings, () => setMode(ctx, nextMode(mode))),
+    );
+  });
+}

package/package.json

@@ -1,12 +1,24 @@
 {
   "name": "tau-coding-agent",
-  "version": "0.1.1",
-  "description": "Coding-focused Tau distribution for Pi",
+  "version": "0.1.3",
+  "description": "Opinionated Pi package with web search, review workflows, sandboxing, memory, usage reporting, skills, and a theme",
   "keywords": [
+    "agent-tools",
+    "code-review",
+    "coding-agent",
+    "memory",
+    "pi",
     "pi-extension",
     "pi-package",
-    "pi-skill"
+    "pi-skill",
+    "pi-theme",
+    "sandbox",
+    "websearch"
   ],
+  "homepage": "https://github.com/goncalossilva/tau#readme",
+  "bugs": {
+    "url": "https://github.com/goncalossilva/tau/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -49,6 +61,7 @@
       "extensions/openai-verbosity.ts",
       "extensions/review.ts",
       "extensions/sandbox/index.ts",
+      "extensions/tool-display-mode.ts",
       "extensions/usage/index.ts",
       "extensions/websearch/index.ts",
       "extensions/worktree.ts"