tau-coding-agent 0.1.0

package/skills/sentry/scripts/fetch-issue.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+import { SENTRY_API_BASE, getAuthToken, fetchJson, formatTimestamp } from "../lib/auth.js";
+
+function parseIssueInput(input) {
+  // Full URL: https://sentry.io/organizations/sentry/issues/5765604106/
+  const urlMatch = input.match(/sentry\.io\/organizations\/([^/]+)\/issues\/(\d+)/);
+  if (urlMatch) {
+    return { org: urlMatch[1], issueId: urlMatch[2] };
+  }
+
+  // New URL format: https://ORG.sentry.io/issues/5765604106/
+  const newUrlMatch = input.match(/([^/.]+)\.sentry\.io\/issues\/(\d+)/);
+  if (newUrlMatch) {
+    return { org: newUrlMatch[1], issueId: newUrlMatch[2] };
+  }
+
+  // Numeric issue ID
+  if (/^\d+$/.test(input)) {
+    return { issueId: input };
+  }
+
+  // Short ID like JAVASCRIPT-ABC
+  if (/^[A-Z]+-[A-Z0-9]+$/i.test(input)) {
+    return { shortId: input };
+  }
+
+  return { issueId: input };
+}
+
+function formatStacktrace(frames, { maxFrames = 20, showContext = true } = {}) {
+  if (!frames || frames.length === 0) return "  (no frames)";
+
+  const reversed = frames.slice().reverse();
+  const appFrames = reversed.filter((f) => f.inApp !== false);
+  const framesToShow = appFrames.length > 0 ? appFrames : reversed;
+
+  return framesToShow
+    .slice(0, maxFrames)
+    .map((f, i) => {
+      const file = f.filename || f.absPath || f.module || "unknown";
+      const func = f.function || "(anonymous)";
+      const line = f.lineNo || f.lineno;
+      const col = f.colNo || f.colno;
+      const loc = line ? `:${line}${col ? `:${col}` : ""}` : "";
+
+      let out = `  ${i + 1}. ${file}${loc}\n     → ${func}`;
+
+      if (showContext && f.context_line) {
+        out += `\n     | ${f.context_line.trim()}`;
+      }
+
+      // Show pre/post context if available
+      if (showContext && f.preContext && f.preContext.length > 0) {
+        const pre = f.preContext
+          .slice(-2)
+          .map((l) => `     . ${l.trim()}`)
+          .join("\n");
+        const post =
+          f.postContext
+            ?.slice(0, 2)
+            .map((l) => `     . ${l.trim()}`)
+            .join("\n") || "";
+        if (pre || post) {
+          out = `  ${i + 1}. ${file}${loc}\n     → ${func}`;
+          if (pre) out += `\n${pre}`;
+          out += `\n     > ${f.context_line.trim()}`;
+          if (post) out += `\n${post}`;
+        }
+      }
+
+      return out;
+    })
+    .join("\n\n");
+}
+
+function formatException(exc) {
+  let out = `**${exc.type || "Error"}:** ${exc.value || "(no message)"}\n`;
+
+  if (exc.module) {
+    out += `Module: ${exc.module}\n`;
+  }
+
+  if (exc.stacktrace?.frames) {
+    out += "\n" + formatStacktrace(exc.stacktrace.frames);
+  }
+
+  return out;
+}
+
+function formatIssue(issue) {
+  const lines = [];
+
+  lines.push(`# ${issue.title}`);
+  lines.push("");
+  lines.push(`**Project:** ${issue.project?.slug || "unknown"}`);
+  lines.push(`**Short ID:** ${issue.shortId}`);
+  lines.push(`**Status:** ${issue.status}`);
+  lines.push(`**Level:** ${issue.level}`);
+  if (issue.culprit) {
+    lines.push(`**Culprit:** ${issue.culprit}`);
+  }
+  lines.push("");
+  lines.push(`**First Seen:** ${formatTimestamp(issue.firstSeen)}`);
+  lines.push(`**Last Seen:** ${formatTimestamp(issue.lastSeen)}`);
+  lines.push(`**Events:** ${issue.count || 0}`);
+  lines.push(`**Users Affected:** ${issue.userCount || 0}`);
+
+  if (issue.tags && issue.tags.length > 0) {
+    lines.push("");
+    lines.push("## Tags");
+    for (const tag of issue.tags.slice(0, 10)) {
+      const topValue = tag.topValues?.[0];
+      if (topValue) {
+        lines.push(`- **${tag.key}:** ${topValue.value} (${topValue.count})`);
+      }
+    }
+  }
+
+  if (issue.metadata) {
+    const m = issue.metadata;
+    if (m.type || m.value) {
+      lines.push("");
+      lines.push("## Exception");
+      lines.push(`**Type:** ${m.type || "unknown"}`);
+      lines.push(`**Value:** ${m.value || "unknown"}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function formatEvent(event) {
+  const lines = [];
+
+  lines.push(`## Latest Event`);
+  lines.push("");
+  lines.push(`**Event ID:** ${event.eventID}`);
+  lines.push(`**Timestamp:** ${formatTimestamp(event.dateCreated)}`);
+
+  // Show relevant tags (filter out noisy ones)
+  if (event.tags && event.tags.length > 0) {
+    const importantTags = [
+      "environment",
+      "release",
+      "server_name",
+      "transaction",
+      "url",
+      "browser",
+      "os",
+      "runtime",
+    ];
+    const filteredTags = event.tags.filter(
+      (t) => importantTags.includes(t.key) || t.key.startsWith("sentry:"),
+    );
+    if (filteredTags.length > 0) {
+      lines.push("");
+      lines.push("### Tags");
+      for (const tag of filteredTags) {
+        lines.push(`- **${tag.key}:** ${tag.value}`);
+      }
+    }
+  }
+
+  if (event.entries) {
+    // Show request info first if available
+    for (const entry of event.entries) {
+      if (entry.type === "request" && entry.data) {
+        const req = entry.data;
+        lines.push("");
+        lines.push("### Request");
+        if (req.method && req.url) {
+          lines.push(`**${req.method}** ${req.url}`);
+        }
+        if (req.headers && req.headers.length > 0) {
+          const importantHeaders = ["User-Agent", "Content-Type", "Accept", "Host", "Referer"];
+          const headers = req.headers.filter(([k]) => importantHeaders.includes(k));
+          if (headers.length > 0) {
+            lines.push("");
+            for (const [k, v] of headers) {
+              lines.push(`  ${k}: ${v}`);
+            }
+          }
+        }
+        if (req.data) {
+          lines.push("");
+          lines.push("**Body:**");
+          const body = typeof req.data === "string" ? req.data : JSON.stringify(req.data, null, 2);
+          lines.push("```");
+          lines.push(body.slice(0, 1000) + (body.length > 1000 ? "..." : ""));
+          lines.push("```");
+        }
+      }
+    }
+
+    // Show exceptions with stack traces
+    for (const entry of event.entries) {
+      if (entry.type === "exception" && entry.data?.values) {
+        lines.push("");
+        lines.push("### Exception");
+        for (const exc of entry.data.values) {
+          lines.push("");
+          lines.push(formatException(exc));
+        }
+      }
+
+      if (entry.type === "message" && entry.data?.formatted) {
+        lines.push("");
+        lines.push("### Message");
+        lines.push(entry.data.formatted);
+      }
+    }
+
+    // Show breadcrumbs last
+    for (const entry of event.entries) {
+      if (entry.type === "breadcrumbs" && entry.data?.values) {
+        const crumbs = entry.data.values.slice(-15);
+        if (crumbs.length > 0) {
+          lines.push("");
+          lines.push("### Recent Breadcrumbs");
+          for (const c of crumbs) {
+            let ts = "??:??:??";
+            if (c.timestamp) {
+              try {
+                // Handle both unix timestamps and ISO strings
+                const date =
+                  typeof c.timestamp === "number"
+                    ? new Date(c.timestamp * 1000)
+                    : new Date(c.timestamp);
+                if (!isNaN(date.getTime())) {
+                  ts = date.toISOString().slice(11, 19);
+                }
+              } catch {}
+            }
+            const cat = c.category || c.type || "?";
+            const level = c.level && c.level !== "info" ? `[${c.level}] ` : "";
+            let msg = c.message || "";
+            if (!msg && c.data) {
+              if (c.data.url) msg = c.data.url;
+              else if (c.data.method) msg = `${c.data.method} ${c.data.url || ""}`;
+              else msg = JSON.stringify(c.data);
+            }
+            lines.push(`  [${ts}] ${level}${cat}: ${msg}`);
+          }
+        }
+      }
+    }
+  }
+
+  // Show contexts (runtime, browser, os, device, etc.)
+  if (event.contexts) {
+    const ctx = event.contexts;
+    const contextLines = [];
+
+    if (ctx.runtime) {
+      contextLines.push(`- **Runtime:** ${ctx.runtime.name || "?"} ${ctx.runtime.version || ""}`);
+    }
+    if (ctx.browser) {
+      contextLines.push(`- **Browser:** ${ctx.browser.name || "?"} ${ctx.browser.version || ""}`);
+    }
+    if (ctx.os) {
+      contextLines.push(`- **OS:** ${ctx.os.name || "?"} ${ctx.os.version || ""}`);
+    }
+    if (ctx.device && ctx.device.family) {
+      contextLines.push(`- **Device:** ${ctx.device.family}`);
+    }
+
+    if (contextLines.length > 0) {
+      lines.push("");
+      lines.push("### Context");
+      lines.push(...contextLines);
+    }
+  }
+
+  // Fallback to old context field
+  if (!event.contexts && event.context) {
+    const ctx = event.context;
+    if (ctx.browser || ctx.os || ctx.device) {
+      lines.push("");
+      lines.push("### Context");
+      if (ctx.browser)
+        lines.push(`- **Browser:** ${ctx.browser.name} ${ctx.browser.version || ""}`);
+      if (ctx.os) lines.push(`- **OS:** ${ctx.os.name} ${ctx.os.version || ""}`);
+      if (ctx.device) lines.push(`- **Device:** ${ctx.device.family || "unknown"}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    console.log("Usage: fetch-issue.js <issue-id-or-url> [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  --latest     Fetch the latest event with full stack trace");
+    console.log("  --org <org>  Organization slug (for short IDs like PROJECT-123)");
+    console.log("  --json       Output raw JSON instead of formatted text");
+    console.log("");
+    console.log("Examples:");
+    console.log("  fetch-issue.js 5765604106");
+    console.log("  fetch-issue.js https://sentry.io/organizations/sentry/issues/123/");
+    console.log("  fetch-issue.js MYPROJ-ABC --org myorg");
+    console.log("  fetch-issue.js 5765604106 --latest");
+    process.exit(0);
+  }
+
+  const input = args[0];
+  const wantLatest = args.includes("--latest");
+  const wantJson = args.includes("--json");
+  const orgIndex = args.indexOf("--org");
+  const cliOrg = orgIndex !== -1 ? args[orgIndex + 1] : null;
+
+  const token = getAuthToken();
+  const parsed = parseIssueInput(input);
+
+  try {
+    let issue;
+
+    if (parsed.shortId) {
+      const org = cliOrg || parsed.org;
+      if (!org) {
+        console.error("Error: Short ID requires --org flag");
+        console.error("Example: fetch-issue.js MYPROJ-123 --org myorg");
+        process.exit(1);
+      }
+      // Use the shortids endpoint to resolve the short ID
+      const shortIdUrl = `${SENTRY_API_BASE}/organizations/${org}/shortids/${encodeURIComponent(parsed.shortId)}/`;
+      const result = await fetchJson(shortIdUrl, token);
+      if (!result || !result.group) {
+        console.error(`Error: Issue ${parsed.shortId} not found`);
+        process.exit(1);
+      }
+      issue = result.group;
+    } else {
+      const issueUrl = `${SENTRY_API_BASE}/issues/${parsed.issueId}/`;
+      issue = await fetchJson(issueUrl, token);
+    }
+
+    if (wantJson && !wantLatest) {
+      console.log(JSON.stringify(issue, null, 2));
+      return;
+    }
+
+    let output = formatIssue(issue);
+
+    if (wantLatest) {
+      const eventUrl = `${SENTRY_API_BASE}/issues/${issue.id}/events/latest/`;
+      const event = await fetchJson(eventUrl, token);
+
+      if (wantJson) {
+        console.log(JSON.stringify({ issue, event }, null, 2));
+        return;
+      }
+
+      output += "\n\n" + formatEvent(event);
+    }
+
+    console.log(output);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/sentry/scripts/list-issues.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+import {
+  SENTRY_API_BASE,
+  getAuthToken,
+  fetchJson,
+  formatTimestamp,
+  resolveProjectId,
+} from "../lib/auth.js";
+
+const HELP = `Usage: list-issues.js [options]
+
+List and search issues in Sentry.
+
+Options:
+  --org, -o <org>          Organization slug (required)
+  --project, -p <project>  Project slug (can be repeated for multiple projects)
+  --query, -q <query>      Search query (Sentry issue search syntax)
+  --status <status>        Filter by status (unresolved, resolved, ignored)
+  --level <level>          Filter by level (error, warning, info, fatal)
+  --period, -t <period>    Time period (default: 14d, e.g., 24h, 7d, 14d)
+  --limit, -n <n>          Max results (default: 25)
+  --sort <sort>            Sort order (date, new, priority, freq, user)
+  --json                   Output raw JSON
+  -h, --help               Show this help
+
+Query Syntax:
+  is:unresolved            Unresolved issues only
+  is:resolved              Resolved issues only
+  is:ignored               Ignored issues only
+  is:assigned              Assigned to someone
+  is:unassigned            Not assigned
+  assigned:me              Assigned to current user
+  level:error              Error level only
+  firstSeen:+7d            First seen more than 7 days ago
+  lastSeen:-24h            Last seen within 24 hours
+  event.timestamp:>=2025-12-23   Events since date
+  times_seen:>100          Seen more than 100 times
+  user.email:*@example.com User email pattern
+  has:user                 Has user context
+  error.handled:0          Unhandled errors
+
+Sort Options:
+  date       - Last seen (default)
+  new        - First seen (newest first)
+  priority   - Priority score
+  freq       - Frequency (events per time)
+  user       - Users affected
+
+Examples:
+  # List unresolved errors
+  list-issues.js --org myorg --project backend --status unresolved
+
+  # Find recent high-priority issues
+  list-issues.js --org myorg --query "is:unresolved lastSeen:-24h" --sort priority
+
+  # Search for specific error type
+  list-issues.js --org myorg --query "AI_NoOutputGeneratedError"
+
+  # Find issues first seen in a date range
+  list-issues.js --org myorg --query "firstSeen:>=2025-12-23 firstSeen:<=2025-12-24"
+
+  # Find issues with many events
+  list-issues.js --org myorg --query "times_seen:>50" --sort freq
+`;
+
+function parseArgs(args) {
+  const options = {
+    org: null,
+    projects: [],
+    query: null,
+    status: null,
+    level: null,
+    period: "14d",
+    limit: 25,
+    sort: null,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    switch (arg) {
+      case "--help":
+      case "-h":
+        options.help = true;
+        break;
+      case "--json":
+        options.json = true;
+        break;
+      case "--org":
+      case "-o":
+        options.org = args[++i];
+        break;
+      case "--project":
+      case "-p":
+        options.projects.push(args[++i]);
+        break;
+      case "--query":
+      case "-q":
+        options.query = args[++i];
+        break;
+      case "--status":
+        options.status = args[++i];
+        break;
+      case "--level":
+        options.level = args[++i];
+        break;
+      case "--period":
+      case "-t":
+        options.period = args[++i];
+        break;
+      case "--limit":
+      case "-n":
+        options.limit = parseInt(args[++i], 10);
+        break;
+      case "--sort":
+        options.sort = args[++i];
+        break;
+    }
+  }
+
+  return options;
+}
+
+function formatIssue(issue) {
+  const lines = [];
+
+  const id = issue.shortId || issue.id;
+  const title = issue.title || "(no title)";
+  const level = issue.level || "?";
+  const status = issue.status || "?";
+  const count = issue.count || 0;
+  const userCount = issue.userCount || 0;
+  const firstSeen = formatTimestamp(issue.firstSeen);
+  const lastSeen = formatTimestamp(issue.lastSeen);
+  const project = issue.project?.slug || "?";
+  const culprit = issue.culprit || "";
+  const permalink = issue.permalink || "";
+
+  lines.push(`[${id}] ${title}`);
+  lines.push(`  level: ${level} | status: ${status} | project: ${project}`);
+  lines.push(`  events: ${count} | users: ${userCount}`);
+  lines.push(`  first: ${firstSeen} | last: ${lastSeen}`);
+
+  if (culprit) {
+    lines.push(`  culprit: ${culprit}`);
+  }
+
+  if (permalink) {
+    lines.push(`  url: ${permalink}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatOutput(issues) {
+  if (!issues || issues.length === 0) {
+    return "No issues found matching your query.";
+  }
+
+  const lines = [];
+  lines.push(`Found ${issues.length} issues:\n`);
+
+  for (const issue of issues) {
+    lines.push(formatIssue(issue));
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  if (!options.org) {
+    console.error("Error: --org is required");
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+
+  const token = getAuthToken();
+
+  // Build query parameters
+  const params = new URLSearchParams();
+
+  if (options.period) {
+    params.set("statsPeriod", options.period);
+  }
+
+  params.set("limit", Math.min(options.limit, 100).toString());
+
+  // Build search query
+  const queryParts = [];
+
+  if (options.query) {
+    queryParts.push(options.query);
+  }
+
+  if (options.status) {
+    queryParts.push(`is:${options.status}`);
+  }
+
+  if (options.level) {
+    queryParts.push(`level:${options.level}`);
+  }
+
+  if (queryParts.length > 0) {
+    params.set("query", queryParts.join(" "));
+  }
+
+  if (options.sort) {
+    params.set("sort", options.sort);
+  }
+
+  // Build URL - always use org endpoint with resolved project IDs
+  // This handles both slugs and numeric IDs uniformly
+  for (const project of options.projects) {
+    const projectId = await resolveProjectId(options.org, project, token);
+    params.append("project", projectId);
+  }
+  const url = `${SENTRY_API_BASE}/organizations/${encodeURIComponent(options.org)}/issues/?${params.toString()}`;
+
+  try {
+    const data = await fetchJson(url, token);
+
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data));
+    }
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+main();