tau-all-agent 0.1.0

package/extensions/notify.ts

@@ -0,0 +1,161 @@
+/**
+ * Pi Notify Extension
+ *
+ * Sends native terminal notifications when Pi is waiting for input.
+ * - Agent finished and ready for the next prompt
+ * - Extension prompt is waiting for a question/confirmation answer
+ * Supports multiple terminal protocols:
+ * - OSC 777: Ghostty, iTerm2, WezTerm, rxvt-unicode
+ * - OSC 99: Kitty
+ * - Windows toast: Windows Terminal (WSL)
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+const REVIEW_EVENT_START = "review:start";
+const REVIEW_EVENT_END = "review:end";
+
+function windowsToastScript(title: string, body: string): string {
+  const type = "Windows.UI.Notifications";
+  const mgr = `[${type}.ToastNotificationManager, ${type}, ContentType = WindowsRuntime]`;
+  const template = `[${type}.ToastTemplateType]::ToastText01`;
+  const toast = `[${type}.ToastNotification]::new($xml)`;
+  return [
+    `${mgr} > $null`,
+    `$xml = [${type}.ToastNotificationManager]::GetTemplateContent(${template})`,
+    `$xml.GetElementsByTagName('text')[0].AppendChild($xml.CreateTextNode('${body}')) > $null`,
+    `[${type}.ToastNotificationManager]::CreateToastNotifier('${title}').Show(${toast})`,
+  ].join("; ");
+}
+
+function notifyOSC777(title: string, body: string): void {
+  process.stdout.write(`\x1b]777;notify;${title};${body}\x07`);
+}
+
+function notifyOSC99(title: string, body: string): void {
+  // Kitty OSC 99: i=notification id, d=0 means not done yet, p=body for second part
+  process.stdout.write(`\x1b]99;i=1:d=0;${title}\x1b\\`);
+  process.stdout.write(`\x1b]99;i=1:p=body;${body}\x1b\\`);
+}
+
+function notifyWindows(title: string, body: string): void {
+  const { execFile } = require("child_process");
+  execFile("powershell.exe", ["-NoProfile", "-Command", windowsToastScript(title, body)]);
+}
+
+function notify(title: string, body: string): void {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) return;
+
+  if (process.env.WT_SESSION) {
+    notifyWindows(title, body);
+  } else if (process.env.KITTY_WINDOW_ID) {
+    notifyOSC99(title, body);
+  } else {
+    notifyOSC777(title, body);
+  }
+}
+
+function getPromptSource(event: unknown): string | undefined {
+  if (!event || typeof event !== "object") return undefined;
+  const source = (event as Record<string, unknown>).source;
+  if (typeof source !== "string") return undefined;
+  const trimmed = source.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function getSessionKey(ctx: ExtensionContext): string {
+  return ctx.sessionManager.getSessionFile() ?? `session:${ctx.sessionManager.getSessionId()}`;
+}
+
+function extractReviewSessionKey(data: unknown): string | undefined {
+  if (!data || typeof data !== "object") return undefined;
+  const payload = data as { sessionKey?: unknown };
+  if (typeof payload.sessionKey !== "string") return undefined;
+  const sessionKey = payload.sessionKey.trim();
+  return sessionKey.length > 0 ? sessionKey : undefined;
+}
+
+function extractReviewOutcome(data: unknown): "success" | "failed" | "cancelled" | undefined {
+  if (!data || typeof data !== "object") return undefined;
+  const payload = data as { outcome?: unknown };
+  if (
+    payload.outcome === "success" ||
+    payload.outcome === "failed" ||
+    payload.outcome === "cancelled"
+  ) {
+    return payload.outcome;
+  }
+  return undefined;
+}
+
+export default function (pi: ExtensionAPI) {
+  let pendingPromptCount = 0;
+  const activeReviewSessions = new Set<string>();
+  let currentSessionKey: string | undefined;
+
+  const hasCurrentSessionReviewRun = () => {
+    if (!currentSessionKey) return false;
+    return activeReviewSessions.has(currentSessionKey);
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentSessionKey = getSessionKey(ctx);
+  });
+
+  pi.events.on("ui:prompt_start", (data) => {
+    const wasIdle = pendingPromptCount === 0;
+    pendingPromptCount += 1;
+
+    if (!wasIdle) return;
+    const source = getPromptSource(data);
+    notify("Pi", source ? `Question pending (${source})` : "Question pending");
+  });
+
+  pi.events.on("ui:prompt_end", () => {
+    if (pendingPromptCount === 0) return;
+    pendingPromptCount -= 1;
+  });
+
+  pi.events.on(REVIEW_EVENT_START, (data) => {
+    const sessionKey = extractReviewSessionKey(data);
+    if (!sessionKey) return;
+    activeReviewSessions.add(sessionKey);
+  });
+
+  pi.events.on(REVIEW_EVENT_END, (data) => {
+    const sessionKey = extractReviewSessionKey(data);
+    if (!sessionKey) return;
+
+    activeReviewSessions.delete(sessionKey);
+
+    if (pendingPromptCount > 0) return;
+    if (!currentSessionKey || sessionKey !== currentSessionKey) return;
+
+    const outcome = extractReviewOutcome(data);
+    if (outcome === "success") {
+      notify("Pi", "Review completed");
+      return;
+    }
+    if (outcome === "cancelled") {
+      notify("Pi", "Review cancelled");
+      return;
+    }
+    notify("Pi", "Review failed");
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    currentSessionKey = getSessionKey(ctx);
+    if (pendingPromptCount > 0) return;
+    if (hasCurrentSessionReviewRun()) return;
+    notify("Pi", "Ready for input");
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    pendingPromptCount = 0;
+    const sessionKey = getSessionKey(ctx);
+    activeReviewSessions.delete(sessionKey);
+    if (currentSessionKey === sessionKey) {
+      currentSessionKey = undefined;
+    }
+  });
+}

package/extensions/openai-fast.ts

@@ -0,0 +1,227 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+const STATUS_KEY = "openai-fast";
+const SUPPORTED_APIS = new Set([
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses",
+]);
+
+type FastMode = "fast";
+type FastSetting = FastMode | "auto";
+type JsonObject = Record<string, unknown>;
+type ModelInfo = NonNullable<ExtensionContext["model"]>;
+type FastConfig = {
+  models: Record<string, FastMode>;
+};
+
+function emptyConfig(): FastConfig {
+  return { models: {} };
+}
+
+function getConfigPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+  return path.join(agentDir, "openai-fast.json");
+}
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeFastMode(value: string): FastMode | undefined {
+  return value.trim().toLowerCase() === "fast" ? "fast" : undefined;
+}
+
+function parseFastSetting(value: string): FastSetting | undefined {
+  const normalized = value.trim().toLowerCase();
+
+  if (normalized === "on" || normalized === "enabled") return "fast";
+  if (normalized === "off" || normalized === "disabled") return "auto";
+
+  return undefined;
+}
+
+function getFastArgumentCompletions(
+  prefix: string,
+): Array<{ value: string; label: string }> | null {
+  const trimmed = prefix.trim().toLowerCase();
+  if (trimmed.includes(" ")) return null;
+
+  const options = ["on", "off", "enabled", "disabled"];
+  const matches = options.filter((option) => option.startsWith(trimmed));
+  if (!matches.length) return null;
+
+  return matches.map((option) => ({ value: option, label: option }));
+}
+
+function parseConfig(value: unknown): FastConfig {
+  if (!isObject(value) || !isObject(value.models)) return emptyConfig();
+
+  const models: Record<string, FastMode> = {};
+  for (const [key, rawMode] of Object.entries(value.models)) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey || typeof rawMode !== "string") continue;
+
+    const mode = normalizeFastMode(rawMode);
+    if (!mode) continue;
+
+    models[normalizedKey] = mode;
+  }
+
+  return { models };
+}
+
+async function loadConfig(): Promise<FastConfig> {
+  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(`[openai-fast] Failed to load config: ${message}`);
+    }
+
+    return emptyConfig();
+  }
+}
+
+async function saveConfig(config: FastConfig): Promise<void> {
+  const configPath = getConfigPath();
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+function isSupportedModel(model: ExtensionContext["model"]): model is ModelInfo {
+  return !!model && SUPPORTED_APIS.has(model.api);
+}
+
+function getExactModelKey(model: Pick<ModelInfo, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
+function resolveFastMode(
+  config: FastConfig,
+  model: Pick<ModelInfo, "provider" | "id">,
+): { key?: string; mode?: FastMode } {
+  const exactKey = getExactModelKey(model);
+  const exactMode = config.models[exactKey];
+  if (exactMode) return { key: exactKey, mode: exactMode };
+
+  const sharedMode = config.models[model.id];
+  if (sharedMode) return { key: model.id, mode: sharedMode };
+
+  return {};
+}
+
+function setFastMode(config: FastConfig, key: string, setting: FastSetting): FastConfig {
+  const models = { ...config.models };
+
+  if (setting === "auto") delete models[key];
+  else models[key] = setting;
+
+  return { models };
+}
+
+function updateStatus(ctx: ExtensionContext, config: FastConfig): void {
+  if (!ctx.hasUI) return;
+  if (!isSupportedModel(ctx.model)) {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+    return;
+  }
+
+  const { mode } = resolveFastMode(config, ctx.model);
+  ctx.ui.setStatus(STATUS_KEY, mode ? ctx.ui.theme.fg("dim", mode) : undefined);
+}
+
+export default function openaiFastExtension(pi: ExtensionAPI): void {
+  let config = emptyConfig();
+
+  async function applySetting(setting: FastSetting, ctx: ExtensionContext): Promise<void> {
+    const model = ctx.model;
+    if (!model) {
+      ctx.ui.notify("No active model.", "warning");
+      return;
+    }
+
+    if (!isSupportedModel(model)) {
+      ctx.ui.notify(
+        "Current model does not support fast mode. Supported APIs: openai-responses, openai-codex-responses, azure-openai-responses.",
+        "warning",
+      );
+      updateStatus(ctx, config);
+      return;
+    }
+
+    const resolved = resolveFastMode(config, model);
+    const configKey = resolved.key ?? getExactModelKey(model);
+    const nextConfig = setFastMode(config, configKey, setting);
+
+    try {
+      await saveConfig(nextConfig);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Failed to save ${getConfigPath()}: ${message}`, "error");
+      return;
+    }
+
+    config = nextConfig;
+    updateStatus(ctx, config);
+
+    const modelLabel = getExactModelKey(model);
+    if (setting === "auto") {
+      ctx.ui.notify(`Fast mode reset to auto for ${modelLabel}`, "info");
+      return;
+    }
+
+    ctx.ui.notify(`Fast mode enabled for ${modelLabel}`, "info");
+  }
+
+  pi.registerCommand("fast", {
+    description: "Toggle priority service tier for the current OpenAI model",
+    getArgumentCompletions: getFastArgumentCompletions,
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+      if (arg === "") {
+        const nextSetting: FastSetting =
+          isSupportedModel(ctx.model) && resolveFastMode(config, ctx.model).mode ? "auto" : "fast";
+        await applySetting(nextSetting, ctx);
+        return;
+      }
+
+      const setting = parseFastSetting(arg);
+      if (!setting) {
+        ctx.ui.notify("Usage: /fast [on|off|enabled|disabled]", "error");
+        return;
+      }
+
+      await applySetting(setting, ctx);
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    config = await loadConfig();
+    updateStatus(ctx, config);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    updateStatus(ctx, config);
+  });
+
+  pi.on("before_provider_request", (event, ctx) => {
+    const model = ctx.model;
+    if (!isSupportedModel(model)) return;
+    if (!resolveFastMode(config, model).mode) return;
+
+    const payload = event.payload;
+    if (!isObject(payload)) return;
+
+    return {
+      ...payload,
+      service_tier: "priority",
+    };
+  });
+}

package/extensions/openai-verbosity.ts

@@ -0,0 +1,223 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+const STATUS_KEY = "openai-verbosity";
+const SUPPORTED_APIS = new Set([
+  "openai-responses",
+  "openai-codex-responses",
+  "azure-openai-responses",
+]);
+
+type Verbosity = "low" | "medium" | "high";
+type VerbositySetting = Verbosity | "auto";
+type JsonObject = Record<string, unknown>;
+type ModelInfo = NonNullable<ExtensionContext["model"]>;
+type VerbosityConfig = {
+  models: Record<string, Verbosity>;
+};
+
+function emptyConfig(): VerbosityConfig {
+  return { models: {} };
+}
+
+function getConfigPath(): string {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+  return path.join(agentDir, "openai-verbosity.json");
+}
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeVerbosity(value: string): Verbosity | undefined {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "low" || normalized === "medium" || normalized === "high") return normalized;
+  return undefined;
+}
+
+function parseVerbositySetting(value: string): VerbositySetting | undefined {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "auto") return normalized;
+  return normalizeVerbosity(normalized);
+}
+
+function getVerbosityArgumentCompletions(
+  prefix: string,
+): Array<{ value: string; label: string }> | null {
+  const trimmed = prefix.trim().toLowerCase();
+  if (trimmed.includes(" ")) return null;
+
+  const options = ["low", "medium", "high", "auto"];
+  const matches = options.filter((option) => option.startsWith(trimmed));
+  if (!matches.length) return null;
+
+  return matches.map((option) => ({ value: option, label: option }));
+}
+
+function parseConfig(value: unknown): VerbosityConfig {
+  if (!isObject(value) || !isObject(value.models)) return emptyConfig();
+
+  const models: Record<string, Verbosity> = {};
+  for (const [key, rawVerbosity] of Object.entries(value.models)) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey || typeof rawVerbosity !== "string") continue;
+
+    const verbosity = normalizeVerbosity(rawVerbosity);
+    if (!verbosity) continue;
+
+    models[normalizedKey] = verbosity;
+  }
+
+  return { models };
+}
+
+async function loadConfig(): Promise<VerbosityConfig> {
+  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(`[openai-verbosity] Failed to load config: ${message}`);
+    }
+
+    return emptyConfig();
+  }
+}
+
+async function saveConfig(config: VerbosityConfig): Promise<void> {
+  const configPath = getConfigPath();
+  await mkdir(path.dirname(configPath), { recursive: true });
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+function isSupportedModel(model: ExtensionContext["model"]): model is ModelInfo {
+  return !!model && SUPPORTED_APIS.has(model.api);
+}
+
+function getExactModelKey(model: Pick<ModelInfo, "provider" | "id">): string {
+  return `${model.provider}/${model.id}`;
+}
+
+function resolveVerbosity(
+  config: VerbosityConfig,
+  model: Pick<ModelInfo, "provider" | "id">,
+): { key?: string; verbosity?: Verbosity } {
+  const exactKey = getExactModelKey(model);
+  const exactVerbosity = config.models[exactKey];
+  if (exactVerbosity) return { key: exactKey, verbosity: exactVerbosity };
+
+  const sharedVerbosity = config.models[model.id];
+  if (sharedVerbosity) return { key: model.id, verbosity: sharedVerbosity };
+
+  return {};
+}
+
+function setVerbosity(
+  config: VerbosityConfig,
+  key: string,
+  verbosity: VerbositySetting,
+): VerbosityConfig {
+  const models = { ...config.models };
+
+  if (verbosity === "auto") delete models[key];
+  else models[key] = verbosity;
+
+  return { models };
+}
+
+function updateStatus(ctx: ExtensionContext, config: VerbosityConfig): void {
+  if (!ctx.hasUI) return;
+  if (!isSupportedModel(ctx.model)) {
+    ctx.ui.setStatus(STATUS_KEY, undefined);
+    return;
+  }
+
+  const { verbosity } = resolveVerbosity(config, ctx.model);
+  ctx.ui.setStatus(STATUS_KEY, verbosity ? ctx.ui.theme.fg("dim", verbosity) : undefined);
+}
+
+export default function openaiVerbosityExtension(pi: ExtensionAPI): void {
+  let config = emptyConfig();
+
+  pi.registerCommand("verbosity", {
+    description: "Set OpenAI response verbosity for the current model",
+    getArgumentCompletions: getVerbosityArgumentCompletions,
+    handler: async (args, ctx) => {
+      const verbosity = parseVerbositySetting(args);
+      if (!verbosity) {
+        ctx.ui.notify("Usage: /verbosity <low|medium|high|auto>", "error");
+        return;
+      }
+
+      const model = ctx.model;
+      if (!model) {
+        ctx.ui.notify("No active model.", "warning");
+        return;
+      }
+
+      if (!isSupportedModel(model)) {
+        ctx.ui.notify(
+          "Current model does not support verbosity control. Supported APIs: openai-responses, openai-codex-responses, azure-openai-responses.",
+          "warning",
+        );
+        updateStatus(ctx, config);
+        return;
+      }
+
+      const resolved = resolveVerbosity(config, model);
+      const configKey = resolved.key ?? getExactModelKey(model);
+      const nextConfig = setVerbosity(config, configKey, verbosity);
+
+      try {
+        await saveConfig(nextConfig);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Failed to save ${getConfigPath()}: ${message}`, "error");
+        return;
+      }
+
+      config = nextConfig;
+      updateStatus(ctx, config);
+
+      if (verbosity === "auto") {
+        ctx.ui.notify("Verbosity reset to auto", "info");
+        return;
+      }
+
+      ctx.ui.notify(`Verbosity set to ${verbosity}`, "info");
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    config = await loadConfig();
+    updateStatus(ctx, config);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    updateStatus(ctx, config);
+  });
+
+  pi.on("before_provider_request", (event, ctx) => {
+    const model = ctx.model;
+    if (!isSupportedModel(model)) return;
+
+    const { verbosity } = resolveVerbosity(config, model);
+    if (!verbosity) return;
+
+    const payload = event.payload;
+    if (!isObject(payload)) return;
+
+    const text = isObject(payload.text) ? payload.text : {};
+    return {
+      ...payload,
+      text: {
+        ...text,
+        verbosity,
+      },
+    };
+  });
+}