tau-coding-agent 0.1.0

package/skills/oracle/scripts/oracle

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const THINKING_LEVEL = "xhigh";
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+const FAMILY_ORDER = {
+  openai: ["anthropic", "google", "openai"],
+  anthropic: ["openai", "google", "anthropic"],
+  google: ["openai", "anthropic", "google"],
+  unknown: ["anthropic", "openai", "google"],
+};
+
+const args = parseArgs(process.argv.slice(2));
+const settings = readSettings();
+const currentModel = args.currentModel ?? process.env.ORACLE_CURRENT_MODEL ?? defaultModel(settings);
+const currentFamily = modelFamily(currentModel ?? "") ?? "unknown";
+const availableModels = listPiModels();
+const enabledModels = new Set((settings.enabledModels ?? []).map(normalizeModelSpec));
+
+if (args.listModels) {
+  printModelPlan(availableModels, enabledModels, currentModel, currentFamily);
+  process.exit(0);
+}
+
+const oracleModel = args.model ?? selectOracleModel(availableModels, enabledModels, currentFamily);
+if (!oracleModel) {
+  die("Could not find a suitable oracle model from `pi --list-models`.");
+}
+
+console.error(
+  `[oracle] current=${currentModel ?? "unknown"} family=${currentFamily}; oracle=${oracleModel}`,
+);
+
+const bundle = run(path.join(SCRIPT_DIR, "oracle-bundle"), args.bundleArgs, {
+  cwd: repoRoot(),
+  encoding: "utf8",
+  maxBuffer: 64 * 1024 * 1024,
+});
+
+if (bundle.status !== 0) {
+  process.stderr.write(bundle.stderr ?? "");
+  process.exit(bundle.status ?? 1);
+}
+
+const pi = spawnSync("pi", ["-p", "--no-tools", "--model", oracleModel, "--thinking", THINKING_LEVEL], {
+  cwd: repoRoot(),
+  input: bundle.stdout,
+  stdio: ["pipe", "inherit", "inherit"],
+});
+
+if (pi.error) die(pi.error.message);
+process.exit(pi.status ?? 1);
+
+function parseArgs(argv) {
+  const bundleArgs = [];
+  let currentModel;
+  let model;
+  let listModels = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--current" || arg === "--current-model") {
+      currentModel = requireValue(argv, (index += 1), arg);
+    } else if (arg === "--model" || arg === "--oracle-model") {
+      model = normalizeModelSpec(requireValue(argv, (index += 1), arg));
+    } else if (arg === "--list-models") {
+      listModels = true;
+    } else {
+      bundleArgs.push(arg);
+    }
+  }
+
+  return { bundleArgs, currentModel: currentModel ? normalizeModelSpec(currentModel) : undefined, model, listModels };
+}
+
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value) die(`${flag} requires a value`);
+  return value;
+}
+
+function readSettings() {
+  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(homedir(), ".pi", "agent");
+  const settingsPath = path.join(agentDir, "settings.json");
+  if (!existsSync(settingsPath)) return {};
+
+  try {
+    return JSON.parse(readFileSync(settingsPath, "utf8"));
+  } catch (error) {
+    console.error(`[oracle] warning: failed to parse ${settingsPath}: ${error.message}`);
+    return {};
+  }
+}
+
+function defaultModel(settings) {
+  if (!settings.defaultProvider || !settings.defaultModel) return undefined;
+  return normalizeModelSpec(`${settings.defaultProvider}/${settings.defaultModel}`);
+}
+
+function listPiModels() {
+  const result = run("pi", ["--list-models"], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  if (result.error) die(result.error.message);
+  if (result.status !== 0) die(result.stderr || "pi --list-models failed");
+
+  const models = [];
+  const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+  for (const line of output.split("\n")) {
+    const match = line.match(/^(\S+)\s+(\S+)\s+/);
+    if (!match || match[1] === "provider") continue;
+    models.push({ provider: match[1], model: match[2], spec: `${match[1]}/${match[2]}` });
+  }
+  return models;
+}
+
+function selectOracleModel(models, enabledModels, currentFamily) {
+  for (const family of FAMILY_ORDER[currentFamily] ?? FAMILY_ORDER.unknown) {
+    const best = bestModelForFamily(models, enabledModels, family);
+    if (best) return best.spec;
+  }
+  return undefined;
+}
+
+function bestModelForFamily(models, enabledModels, family) {
+  return models
+    .map((model) => ({ model, score: scoreModel(model, enabledModels, family) }))
+    .filter((entry) => entry.score >= 0)
+    .sort((a, b) => b.score - a.score || a.model.spec.localeCompare(b.model.spec))[0]?.model;
+}
+
+function scoreModel(entry, enabledModels, targetFamily) {
+  if (modelFamily(entry.spec) !== targetFamily) return -1;
+
+  let score = enabledModels.has(normalizeModelSpec(entry.spec)) ? 10_000 : 0;
+  score += providerScore(entry.provider, targetFamily);
+  score += nameScore(entry.model, targetFamily);
+  return score;
+}
+
+function providerScore(provider, family) {
+  const normalized = provider.toLowerCase();
+  if (family === "openai") {
+    if (normalized === "openai-codex") return 700;
+    if (normalized === "openai") return 600;
+    if (normalized === "github-copilot") return 500;
+    if (normalized.includes("azure")) return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  if (family === "anthropic") {
+    if (normalized === "github-copilot") return 700;
+    if (normalized === "anthropic") return 600;
+    if (normalized === "amazon-bedrock") return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  if (family === "google") {
+    if (normalized === "google-gemini-cli") return 700;
+    if (normalized === "google") return 600;
+    if (normalized === "github-copilot") return 500;
+    if (normalized.includes("vertex")) return 450;
+    if (normalized === "openrouter") return 300;
+    return 100;
+  }
+
+  return 0;
+}
+
+function nameScore(model, family) {
+  const normalized = model.toLowerCase();
+
+  if (family === "openai") {
+    if (/gpt-5\.5/.test(normalized)) return 1_000;
+    if (/gpt-5\.4/.test(normalized)) return 950;
+    if (/gpt-5\.3.*codex/.test(normalized)) return 925;
+    if (/gpt-5\.3/.test(normalized)) return 900;
+    if (/gpt-5\.2/.test(normalized)) return 850;
+    if (/gpt-5\.1/.test(normalized)) return 800;
+    if (/gpt-5/.test(normalized)) return 750;
+    if (/gpt-4\.1/.test(normalized)) return 500;
+    return 100;
+  }
+
+  if (family === "anthropic") {
+    if (/claude[-_.]opus[-_.]4[-_.]7/.test(normalized)) return 1_000;
+    if (/claude[-_.]opus[-_.]4[-_.]6/.test(normalized)) return 950;
+    if (/claude[-_.]opus[-_.]4[-_.]5/.test(normalized)) return 900;
+    if (/claude[-_.]opus[-_.]4[-_.]1/.test(normalized)) return 850;
+    if (/claude[-_.]opus[-_.]4/.test(normalized)) return 800;
+    if (/claude[-_.]sonnet[-_.]4[-_.]6/.test(normalized)) return 700;
+    if (/claude[-_.]sonnet[-_.]4[-_.]5/.test(normalized)) return 650;
+    if (/claude[-_.]sonnet[-_.]4/.test(normalized)) return 600;
+    return 100;
+  }
+
+  if (family === "google") {
+    if (/gemini[-_.]3\.1[-_.]pro/.test(normalized)) return 1_000;
+    if (/gemini[-_.]3[-_.]pro/.test(normalized)) return 950;
+    if (/gemini[-_.]2\.5[-_.]pro/.test(normalized)) return 800;
+    return 100;
+  }
+
+  return 0;
+}
+
+function modelFamily(spec) {
+  const normalized = normalizeModelSpec(spec).toLowerCase();
+  if (!normalized) return undefined;
+  if (/(anthropic|claude)/.test(normalized)) return "anthropic";
+  if (/(google|gemini)/.test(normalized)) return "google";
+  if (/(openai|gpt|codex)/.test(normalized)) return "openai";
+  return undefined;
+}
+
+function normalizeModelSpec(spec) {
+  return String(spec).trim().replace(/:(off|minimal|low|medium|high|xhigh)$/i, "");
+}
+
+function printModelPlan(models, enabledModels, currentModel, currentFamily) {
+  console.log(`Current model: ${currentModel ?? "unknown"}`);
+  console.log(`Current family: ${currentFamily}`);
+  console.log(`Family order: ${(FAMILY_ORDER[currentFamily] ?? FAMILY_ORDER.unknown).join(" -> ")}`);
+  console.log("");
+
+  for (const family of ["anthropic", "openai", "google"]) {
+    const best = bestModelForFamily(models, enabledModels, family);
+    console.log(`${family}: ${best?.spec ?? "not found"}`);
+  }
+}
+
+function repoRoot() {
+  const result = run("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() : process.cwd();
+}
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, { ...options });
+}
+
+function die(message) {
+  console.error(`oracle: ${message}`);
+  process.exit(1);
+}

package/skills/oracle/scripts/oracle-bundle

@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+ROOT_DIR="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
+
+MAX_BYTES=$((1024 * 1024))
+DRY_RUN=0
+PROMPT=""
+FILE_SELECTORS=()
+
+usage() {
+  cat <<'EOF'
+Usage:
+  oracle-bundle -p "<task>" --file "path|dir|glob" [--file "..."] [--dry-run] [--max-bytes N]
+
+Notes:
+  - Runs from the git repo root when inside a repo; otherwise uses $PWD.
+  - --file accepts paths, dirs, or glob-like patterns (string globs).
+  - Exclude patterns by prefixing with "!" (e.g. --file "!**/*.test.*").
+EOF
+}
+
+trim() {
+  local s="$1"
+  s="${s#"${s%%[!$' \t\r\n']*}"}"
+  s="${s%"${s##*[!$' \t\r\n']}"}"
+  printf '%s' "$s"
+}
+
+has_glob_chars() {
+  case "$1" in
+    *'*'* | *'?'* | *'['* | *']'* ) return 0 ;;
+    * ) return 1 ;;
+  esac
+}
+
+file_size_bytes() {
+  local path="$1"
+  local size=""
+  size="$(stat -f%z "$path" 2>/dev/null || true)"
+  if [[ -n "$size" ]]; then
+    printf '%s' "$size"
+    return 0
+  fi
+
+  size="$(stat -c%s "$path" 2>/dev/null || true)"
+  if [[ -n "$size" ]]; then
+    printf '%s' "$size"
+    return 0
+  fi
+
+  wc -c <"$path" | tr -d ' '
+}
+
+path_has_ignored_dir() {
+  local rel="$1"
+  case "$rel" in
+    .git/* | */.git/*) return 0 ;;
+    node_modules/* | */node_modules/*) return 0 ;;
+    dist/* | */dist/*) return 0 ;;
+    build/* | */build/*) return 0 ;;
+    coverage/* | */coverage/*) return 0 ;;
+    .next/* | */.next/*) return 0 ;;
+    .turbo/* | */.turbo/*) return 0 ;;
+    tmp/* | */tmp/*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+matches_any_pattern() {
+  local rel="$1"
+  shift
+  local pat=""
+  for pat in "$@"; do
+    # shellcheck disable=SC2053
+    [[ "$rel" == $pat ]] && return 0
+  done
+  return 1
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p | --prompt)
+      PROMPT="${2-}"
+      shift 2
+      ;;
+    --file | -f)
+      FILE_SELECTORS+=("${2-}")
+      shift 2
+      ;;
+    --max-bytes)
+      MAX_BYTES="${2-}"
+      shift 2
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    -h | --help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "error: unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ -z "$PROMPT" && ! -t 0 ]]; then
+  PROMPT="$(cat)"
+fi
+
+if [[ -z "$(trim "$PROMPT")" ]]; then
+  echo "error: prompt is empty (use -p/--prompt)" >&2
+  exit 2
+fi
+
+cd "${ROOT_DIR}"
+
+selectors=()
+for raw in "${FILE_SELECTORS[@]-}"; do
+  IFS=',' read -r -a parts <<<"$raw"
+  for part in "${parts[@]}"; do
+    part="$(trim "$part")"
+    [[ -n "$part" ]] && selectors+=("$part")
+  done
+done
+
+include_patterns=()
+exclude_patterns=()
+
+for sel in "${selectors[@]}"; do
+  is_exclude=0
+  if [[ "$sel" == !* ]]; then
+    is_exclude=1
+    sel="${sel:1}"
+  fi
+
+  sel="$(trim "$sel")"
+  sel="${sel%/}"
+  if [[ -z "$sel" ]]; then
+    continue
+  fi
+
+  if [[ "$sel" == /* ]]; then
+    if [[ "$sel" == "${ROOT_DIR}/"* ]]; then
+      sel="${sel#"${ROOT_DIR}/"}"
+    else
+      echo "error: absolute paths must be under repo root: ${sel}" >&2
+      exit 2
+    fi
+  fi
+
+  if [[ -e "$sel" && -d "$sel" ]] && ! has_glob_chars "$sel"; then
+    sel="${sel}/**"
+  fi
+
+  if [[ $is_exclude -eq 1 ]]; then
+    exclude_patterns+=("$sel")
+  else
+    include_patterns+=("$sel")
+  fi
+done
+
+if [[ "${#include_patterns[@]}" -eq 0 ]]; then
+  echo "error: no include patterns provided (need at least one non-! --file)" >&2
+  exit 2
+fi
+
+all_files=()
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  while IFS= read -r f; do
+    [[ -n "$f" ]] && all_files+=("$f")
+  done < <(git ls-files -co --exclude-standard)
+else
+  while IFS= read -r f; do
+    f="${f#./}"
+    [[ -n "$f" ]] && all_files+=("$f")
+  done < <(find . -type f -print)
+fi
+
+selected=()
+skipped=()
+
+for rel in "${all_files[@]}"; do
+  [[ -z "$rel" ]] && continue
+  path_has_ignored_dir "$rel" && continue
+
+  if ! matches_any_pattern "$rel" "${include_patterns[@]}"; then
+    continue
+  fi
+
+  if [[ "${#exclude_patterns[@]}" -gt 0 ]] && matches_any_pattern "$rel" "${exclude_patterns[@]}"; then
+    continue
+  fi
+
+  if [[ ! -f "$rel" ]]; then
+    continue
+  fi
+
+  size="$(file_size_bytes "$rel")"
+  if [[ "$size" -gt "$MAX_BYTES" ]]; then
+    skipped+=("${rel} (too large: ${size} bytes)")
+    continue
+  fi
+
+  selected+=("$rel")
+done
+
+if [[ "$DRY_RUN" -eq 1 ]]; then
+  printf '%s\n' "${selected[@]}" | LC_ALL=C sort
+  if [[ "${#skipped[@]}" -gt 0 ]]; then
+    printf '\nSkipped:\n' >&2
+    printf '%s\n' "${skipped[@]}" >&2
+  fi
+  exit 0
+fi
+
+printf '# Task\n\n%s\n\n# Files\n' "$(trim "$PROMPT")"
+printf '%s\n' "${selected[@]}" | LC_ALL=C sort | while IFS= read -r rel; do
+  [[ -z "$rel" ]] && continue
+  printf '\n## %s\n\n```\n' "$rel"
+  cat "$rel"
+  printf '\n```\n'
+done

package/skills/sentry/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: sentry
+description: "Fetch and analyze Sentry issues, events, transactions, and logs. Helps agents debug errors, find root causes, and understand what happened at specific times."
+---
+
+# Sentry
+
+Access Sentry data via the Sentry API for debugging and investigation.
+
+## Requirements
+
+A Sentry auth token available to the scripts (by default they read `~/.sentryclirc`).
+
+## Quick reference
+
+Run these scripts from this skill directory.
+
+| Task                  | Command                                                                          |
+| --------------------- | -------------------------------------------------------------------------------- |
+| Find errors on a date | `"./scripts/search-events.js" --org X --start 2025-12-23T15:00:00 --level error` |
+| List open issues      | `"./scripts/list-issues.js" --org X --status unresolved`                         |
+| Get issue details     | `"./scripts/fetch-issue.js" <issue-id-or-url> --latest`                          |
+| Get event details     | `"./scripts/fetch-event.js" <event-id> --org X --project Y`                      |
+| Search logs           | `"./scripts/search-logs.js" --org X --project Y "level:error"`                   |
+
+## Common debugging workflows
+
+### “What went wrong at this time?”
+
+Find events around a specific timestamp:
+
+```bash
+# Find all events in a 2-hour window
+"./scripts/search-events.js" --org myorg --project backend \
+  --start 2025-12-23T15:00:00 --end 2025-12-23T17:00:00
+
+# Filter to just errors
+"./scripts/search-events.js" --org myorg --start 2025-12-23T15:00:00 \
+  --level error
+
+# Find a specific transaction type
+"./scripts/search-events.js" --org myorg --start 2025-12-23T15:00:00 \
+  --transaction process-incoming-email
+```
+
+### “What errors have occurred recently?”
+
+```bash
+# List unresolved errors from last 24 hours
+"./scripts/list-issues.js" --org myorg --status unresolved --level error --period 24h
+
+# Find high-frequency issues
+"./scripts/list-issues.js" --org myorg --query "times_seen:>50" --sort freq
+
+# Issues affecting users
+"./scripts/list-issues.js" --org myorg --query "is:unresolved has:user" --sort user
+```
+
+### “Get details about a specific issue/event”
+
+```bash
+# Get issue with latest stack trace
+"./scripts/fetch-issue.js" 5765604106 --latest
+"./scripts/fetch-issue.js" https://sentry.io/organizations/myorg/issues/123/ --latest
+"./scripts/fetch-issue.js" MYPROJ-123 --org myorg --latest
+
+# Get specific event with all breadcrumbs
+"./scripts/fetch-event.js" abc123def456 --org myorg --project backend --breadcrumbs
+```
+
+### “Find events with a specific tag”
+
+```bash
+# Find by custom tag (e.g., thread_id, user_id)
+"./scripts/search-events.js" --org myorg --tag thread_id:th_abc123
+
+# Find by user email
+"./scripts/search-events.js" --org myorg --query "user.email:*@example.com"
+```
+
+---
+
+## Fetch issue
+
+```bash
+"./scripts/fetch-issue.js" <issue-id-or-url> [options]
+```
+
+Get details about a specific issue (grouped error).
+
+**Accepts:**
+
+- Issue ID: `5765604106`
+- Issue URL: `https://sentry.io/organizations/sentry/issues/5765604106/`
+- New URL format: `https://myorg.sentry.io/issues/5765604106/`
+- Short ID: `JAVASCRIPT-ABC` (requires `--org`)
+
+**Options:**
+
+- `--latest` include the latest event with full stack trace
+- `--org <org>` organization slug (for short IDs)
+- `--json` output raw JSON
+
+---
+
+## Fetch event
+
+```bash
+"./scripts/fetch-event.js" <event-id> --org <org> --project <project> [options]
+```
+
+**Options:**
+
+- `--org, -o <org>` organization slug (required)
+- `--project, -p <project>` project slug (required)
+- `--breadcrumbs, -b` show all breadcrumbs (default: last 30)
+- `--spans` show span tree for transactions
+- `--json` output raw JSON
+
+---
+
+## Search events (Discover)
+
+```bash
+"./scripts/search-events.js" [options]
+```
+
+**Time range options:**
+
+- `--period, -t <period>` relative time (24h, 7d, 14d)
+- `--start <datetime>` start time (ISO 8601: 2025-12-23T15:00:00)
+- `--end <datetime>` end time (ISO 8601)
+
+**Filter options:**
+
+- `--org, -o <org>` organization slug (required)
+- `--project, -p <project>` project slug or ID
+- `--query, -q <query>` Discover search query
+- `--transaction <name>` transaction name filter
+- `--tag <key:value>` tag filter (repeatable)
+- `--level <level>` level filter (error, warning, info)
+- `--limit, -n <n>` max results (default: 25, max: 100)
+- `--fields <fields>` comma-separated fields to include
+
+**Query syntax (Discover):**
+
+```
+transaction:process-*     Wildcard transaction match
+level:error               Filter by level
+user.email:foo@bar.com    Filter by user
+environment:production    Filter by environment
+has:stack.filename        Has stack trace
+```
+
+---
+
+## List issues
+
+```bash
+"./scripts/list-issues.js" [options]
+```
+
+**Options:**
+
+- `--org, -o <org>` organization slug (required)
+- `--project, -p <project>` project slug (repeatable)
+- `--query, -q <query>` issue search query
+- `--status <status>` unresolved, resolved, ignored
+- `--level <level>` error, warning, info, fatal
+- `--period, -t <period>` time period (default: 14d)
+- `--limit, -n <n>` max results (default: 25)
+- `--sort <sort>` date, new, priority, freq, user
+- `--json` output raw JSON
+
+---
+
+## Search logs (Logs Explorer)
+
+```bash
+"./scripts/search-logs.js" [query|url] [options]
+```
+
+**Options:**
+
+- `--org, -o <org>` organization slug (required unless URL provided)
+- `--project, -p <project>` filter by project slug or ID
+- `--period, -t <period>` time period (default: 24h)
+- `--limit, -n <n>` max results (default: 100, max: 1000)
+- `--json` output raw JSON
+
+---
+
+## Tips
+
+1. Start broad (time window + simple query), then drill into a single event/issue.
+2. Use `--breadcrumbs` on `fetch-event.js` for the full lead-up to an error.
+3. Use `list-issues.js --sort freq` to find recurring problems.
+4. Use tags (`request_id`, `user_id`, etc.) to correlate events.