tau-coding-agent 0.1.0

package/skills/sentry/scripts/search-events.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+import { SENTRY_API_BASE, getAuthToken, fetchJson, resolveProjectId } from "../lib/auth.js";
+
+const HELP = `Usage: search-events.js [options]
+
+Search for events (transactions, errors) in Sentry Discover.
+
+Options:
+  --org, -o <org>          Organization slug (required)
+  --project, -p <project>  Project slug or ID
+  --query, -q <query>      Search query (Discover syntax)
+  --period, -t <period>    Time period (default: 24h, e.g., 1h, 7d, 14d)
+  --start <datetime>       Start time (ISO 8601, e.g., 2025-12-23T15:00:00)
+  --end <datetime>         End time (ISO 8601)
+  --transaction <name>     Filter by transaction name
+  --tag <key:value>        Filter by tag (can be repeated)
+  --level <level>          Filter by level (error, warning, info)
+  --limit, -n <n>          Max results (default: 25, max: 100)
+  --fields <fields>        Comma-separated fields to include
+  --json                   Output raw JSON
+  -h, --help               Show this help
+
+Common Fields:
+  id, title, timestamp, transaction, message, level, environment,
+  user.email, user.id, tags[key], http.method, http.url
+
+Query Syntax (Discover):
+  transaction:process-*    Match transaction names with wildcards
+  level:error              Filter by log level
+  user.email:foo@bar.com   Filter by user email
+  environment:production   Filter by environment
+  has:stack.filename       Events with stack traces
+  !has:user                Events without user
+
+Date Range Examples:
+  --period 7d                        Last 7 days
+  --start 2025-12-23T15:00:00        From specific time to now
+  --start 2025-12-23T15:00:00 --end 2025-12-23T18:00:00   Specific range
+
+Examples:
+  # Find all transactions for a transaction name
+  search-events.js --org myorg --project backend --transaction process-incoming-email
+
+  # Find errors in the last 7 days
+  search-events.js --org myorg --query "level:error" --period 7d
+
+  # Find events around a specific time
+  search-events.js --org myorg --start 2025-12-23T15:00:00 --end 2025-12-23T17:00:00
+
+  # Search with a specific tag
+  search-events.js --org myorg --tag thread_id:th_abc123
+
+  # Get more fields
+  search-events.js --org myorg --fields "id,title,timestamp,user.email"
+`;
+
+function parseArgs(args) {
+  const options = {
+    org: null,
+    project: null,
+    query: null,
+    period: null,
+    start: null,
+    end: null,
+    transaction: null,
+    tags: [],
+    level: null,
+    limit: 25,
+    fields: ["id", "title", "timestamp", "transaction", "message"],
+    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.project = args[++i];
+        break;
+      case "--query":
+      case "-q":
+        options.query = args[++i];
+        break;
+      case "--period":
+      case "-t":
+        options.period = args[++i];
+        break;
+      case "--start":
+        options.start = args[++i];
+        break;
+      case "--end":
+        options.end = args[++i];
+        break;
+      case "--transaction":
+        options.transaction = args[++i];
+        break;
+      case "--tag":
+        options.tags.push(args[++i]);
+        break;
+      case "--level":
+        options.level = args[++i];
+        break;
+      case "--limit":
+      case "-n":
+        options.limit = parseInt(args[++i], 10);
+        break;
+      case "--fields":
+        options.fields = args[++i].split(",").map((f) => f.trim());
+        break;
+    }
+  }
+
+  // Default to 24h if no time range specified
+  if (!options.period && !options.start) {
+    options.period = "24h";
+  }
+
+  return options;
+}
+
+function formatEvent(event, fields) {
+  const lines = [];
+
+  const id = event.id || event["event.type"] || "?";
+  const ts = event.timestamp || "N/A";
+  const title = event.title || event.transaction || event.message || "(no title)";
+  const transaction = event.transaction || "";
+
+  // Format timestamp
+  let displayTs = ts;
+  try {
+    const date = new Date(ts);
+    if (!isNaN(date.getTime())) {
+      displayTs = date.toISOString().replace("T", " ").slice(0, 19);
+    }
+  } catch {}
+
+  lines.push(`[${displayTs}] ${title}`);
+
+  if (transaction && transaction !== title) {
+    lines.push(`  transaction: ${transaction}`);
+  }
+
+  if (event.message && event.message !== title) {
+    lines.push(`  message: ${event.message}`);
+  }
+
+  // Show any extra fields the user requested
+  for (const field of fields) {
+    if (["id", "title", "timestamp", "transaction", "message"].includes(field)) continue;
+    const value = event[field];
+    if (value !== undefined && value !== null && value !== "") {
+      lines.push(`  ${field}: ${value}`);
+    }
+  }
+
+  lines.push(`  id: ${id}`);
+
+  return lines.join("\n");
+}
+
+function formatOutput(data, fields) {
+  if (!data.data || data.data.length === 0) {
+    return "No events found matching your query.";
+  }
+
+  const lines = [];
+  lines.push(`Found ${data.data.length} events:\n`);
+
+  for (const event of data.data) {
+    lines.push(formatEvent(event, fields));
+    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();
+  params.set("dataset", "discover");
+
+  // Time range
+  if (options.start) {
+    params.set("start", options.start);
+    if (options.end) {
+      params.set("end", options.end);
+    } else {
+      // If only start, use current time as end
+      params.set("end", new Date().toISOString());
+    }
+  } else if (options.period) {
+    params.set("statsPeriod", options.period);
+  }
+
+  params.set("per_page", Math.min(options.limit, 100).toString());
+  params.set("sort", "-timestamp");
+
+  // Add fields
+  for (const field of options.fields) {
+    params.append("field", field);
+  }
+
+  // Always include project.name for context
+  if (!options.fields.includes("project.name")) {
+    params.append("field", "project.name");
+  }
+
+  // Build search query
+  const queryParts = [];
+
+  if (options.project) {
+    const projectId = await resolveProjectId(options.org, options.project, token);
+    params.set("project", projectId);
+  }
+
+  if (options.query) {
+    queryParts.push(options.query);
+  }
+
+  if (options.transaction) {
+    queryParts.push(`transaction:${options.transaction}`);
+  }
+
+  if (options.level) {
+    queryParts.push(`level:${options.level}`);
+  }
+
+  for (const tag of options.tags) {
+    // Handle tags[key]:value format
+    if (tag.includes(":")) {
+      const [key, value] = tag.split(":", 2);
+      if (key.startsWith("tags[")) {
+        queryParts.push(`${key}:${value}`);
+      } else {
+        queryParts.push(`tags[${key}]:${value}`);
+      }
+    }
+  }
+
+  if (queryParts.length > 0) {
+    params.set("query", queryParts.join(" "));
+  }
+
+  const url = `${SENTRY_API_BASE}/organizations/${encodeURIComponent(options.org)}/events/?${params.toString()}`;
+
+  try {
+    const data = await fetchJson(url, token);
+
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, options.fields));
+    }
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/sentry/scripts/search-logs.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import { SENTRY_API_BASE, getAuthToken, fetchJson } from "../lib/auth.js";
+
+const LOG_FIELDS = ["sentry.item_id", "trace", "sentry.severity", "timestamp", "message"];
+
+/**
+ * Parse a Sentry logs explorer URL
+ * Examples:
+ *   https://earendil.sentry.io/explore/logs/?project=123&statsPeriod=14d
+ *   https://sentry.io/organizations/myorg/explore/logs/?project=123
+ */
+function parseLogsUrl(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    const params = url.searchParams;
+    const result = {};
+
+    // Extract org from subdomain (earendil.sentry.io) or path (/organizations/myorg/)
+    const subdomainMatch = url.hostname.match(/^([^.]+)\.sentry\.io$/);
+    if (subdomainMatch && subdomainMatch[1] !== "www") {
+      result.org = subdomainMatch[1];
+    } else {
+      const pathMatch = url.pathname.match(/\/organizations\/([^/]+)\//);
+      if (pathMatch) {
+        result.org = pathMatch[1];
+      }
+    }
+
+    // Extract project ID
+    if (params.has("project")) {
+      result.project = params.get("project");
+    }
+
+    // Extract time period
+    if (params.has("statsPeriod")) {
+      result.period = params.get("statsPeriod");
+    }
+
+    // Extract query
+    if (params.has("logsQuery")) {
+      result.query = params.get("logsQuery");
+    }
+
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+function parseArgs(args) {
+  const options = {
+    org: null,
+    project: null,
+    query: null,
+    period: "24h",
+    limit: 100,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--org" || arg === "-o") {
+      options.org = args[++i];
+    } else if (arg === "--project" || arg === "-p") {
+      options.project = args[++i];
+    } else if (arg === "--period" || arg === "-t") {
+      options.period = args[++i];
+    } else if (arg === "--limit" || arg === "-n") {
+      options.limit = parseInt(args[++i], 10);
+    } else if (!arg.startsWith("-")) {
+      // Check if it's a Sentry URL
+      if (arg.includes("sentry.io/") && arg.includes("/logs")) {
+        const urlOptions = parseLogsUrl(arg);
+        if (urlOptions) {
+          if (urlOptions.org) options.org = urlOptions.org;
+          if (urlOptions.project) options.project = urlOptions.project;
+          if (urlOptions.period) options.period = urlOptions.period;
+          if (urlOptions.query) options.query = urlOptions.query;
+        }
+      } else if (!options.query) {
+        options.query = arg;
+      }
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(`Usage: search-logs.js [query|url] [options]
+
+Search for logs in Sentry.
+
+Arguments:
+  query              Search query (e.g., "level:error", "user.id:123")
+  url                Sentry logs explorer URL (extracts org, project, period)
+
+Options:
+  --org, -o <org>    Organization slug (required unless URL provided)
+  --project, -p <p>  Project slug or ID to filter by
+  --period, -t <p>   Time period (default: 24h, e.g., 1h, 7d, 90d)
+  --limit, -n <n>    Max results (default: 100, max: 1000)
+  --json             Output raw JSON
+  -h, --help         Show this help
+
+Search Query Syntax:
+  level:error              Filter by log level (trace, debug, info, warn, error, fatal)
+  message:*timeout*        Search message text
+  trace:abc123             Filter by trace ID
+  project:my-project       Filter by project slug
+
+  Combine filters: level:error message:*failed*
+
+Examples:
+  search-logs.js --org myorg
+  search-logs.js "level:error" --org myorg --project backend
+  search-logs.js "message:*timeout*" --org myorg --period 7d
+  search-logs.js --org myorg --limit 50 --json
+
+  # Use a Sentry URL directly:
+  search-logs.js "https://myorg.sentry.io/explore/logs/?project=123&statsPeriod=7d"
+`);
+}
+
+function formatLogEntry(entry) {
+  const lines = [];
+
+  const ts = entry.timestamp || "N/A";
+  const severity = entry["sentry.severity"] || "info";
+  const message = entry.message || "(no message)";
+  const trace = entry.trace || null;
+
+  // Format timestamp for display
+  let displayTs = ts;
+  try {
+    const date = new Date(ts);
+    if (!isNaN(date.getTime())) {
+      displayTs = date.toISOString().replace("T", " ").slice(0, 19);
+    }
+  } catch {}
+
+  // Color-code severity in output
+  const severityDisplay = `[${severity.toUpperCase().padEnd(5)}]`;
+
+  lines.push(`${displayTs} ${severityDisplay} ${message}`);
+
+  if (trace) {
+    lines.push(`  trace: ${trace}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatOutput(data) {
+  if (!data.data || data.data.length === 0) {
+    return "No logs found matching your query.";
+  }
+
+  const lines = [];
+  lines.push(`Found ${data.data.length} log entries:\n`);
+
+  for (const entry of data.data) {
+    lines.push(formatLogEntry(entry));
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    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();
+  params.set("dataset", "logs");
+  params.set("statsPeriod", options.period);
+  params.set("per_page", Math.min(options.limit, 1000).toString());
+  params.set("sort", "-timestamp");
+
+  // Add fields
+  for (const field of LOG_FIELDS) {
+    params.append("field", field);
+  }
+
+  // Build search query
+  const queryParts = [];
+  if (options.project) {
+    queryParts.push(`project:${options.project}`);
+  }
+  if (options.query) {
+    queryParts.push(options.query);
+  }
+  if (queryParts.length > 0) {
+    params.set("query", queryParts.join(" "));
+  }
+
+  const url = `${SENTRY_API_BASE}/organizations/${encodeURIComponent(options.org)}/events/?${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();

package/skills/update-changelog/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: update-changelog
+description: "Update CHANGELOG.md following Keep a Changelog (https://keepachangelog.com/en/1.1.0/)"
+---
+
+# Update Changelog (Keep a Changelog)
+
+Update the repository changelog with user-facing changes that landed since the last release.
+
+This skill is **explicitly based on** Keep a Changelog v1.1.0:
+https://keepachangelog.com/en/1.1.0/
+
+## Rules (non-negotiable)
+
+- **Do not add installation instructions** to the changelog.
+- Only include **notable, user-visible** changes.
+- **Never add raw commit SHAs**. Prefer PR numbers (e.g. `#123`) and/or issue IDs.
+- Add entries **only under `Unreleased`** (unless you are also cutting a release and moving items into a versioned section).
+- Preserve the project’s existing formatting where possible, but align new content to Keep a Changelog.
+
+## File to edit
+
+- Prefer `CHANGELOG.md`.
+- If missing, use `CHANGELOG`.
+
+## Step-by-step
+
+### 1) Identify the baseline (last released version)
+
+Pick a baseline tag/version to compare against.
+
+- If the project uses git tags:
+
+```bash
+git describe --tags --abbrev=0
+```
+
+- If tags are missing/inconsistent, use the newest release section in the changelog as the baseline.
+
+### 2) Collect candidate changes
+
+Gather commits/PRs since the baseline and identify user-facing changes.
+
+```bash
+git log <baseline>..HEAD --oneline
+```
+
+If you have PR metadata available (e.g., via GitHub), use it to improve wording and include PR numbers.
+
+### 3) Ensure the changelog structure matches Keep a Changelog
+
+At minimum, Keep a Changelog expects:
+
+- A top `Unreleased` section
+- Optional subsections under `Unreleased` (and under each release):
+  - `Added`, `Changed`, `Deprecated`, `Removed`, `Fixed`, `Security`
+
+If `Unreleased` exists but is missing subsections, create only the ones you need for the new entries.
+
+### 4) Add entries under `Unreleased`
+
+Classify each change into one of the standard headings:
+
+- **Added**: new features
+- **Changed**: changes in existing functionality (including behavior changes)
+- **Deprecated**: soon-to-be removed features
+- **Removed**: removed features
+- **Fixed**: bug fixes
+- **Security**: vulnerability fixes
+
+Write entries as **consistent bullet points**:
+
+- Start with the category verb (Added/Changed/Deprecated/Removed/Fixed/Security) _only via the section heading_, not inside each bullet.
+- Each bullet should be a single, past-tense sentence fragment.
+- Prefer: `- Added … (#123)` / `- Fixed … (#456)` style (consistent grammar).
+
+### 5) Keep it user-facing
+
+Include:
+
+- visible behavior changes
+- new CLI flags/API additions
+- bug fixes with clear impact
+- security fixes (without leaking sensitive details)
+
+Exclude (unless they change user-visible behavior):
+
+- pure refactors
+- internal cleanup
+- dependency bumps with no user impact
+- typo-only doc edits
+
+### 6) Links (only if the file already uses them)
+
+Keep a Changelog commonly includes link references at the bottom, e.g.:
+
+- `[Unreleased]: <compare link>`
+- `[1.2.3]: <compare link>`
+
+If the project already uses these, update them accordingly (don’t introduce link refs if the changelog doesn’t use them).
+
+## Example (consistent Keep a Changelog format)
+
+```markdown
+## [Unreleased]
+
+### Added
+
+- Added widget-level caching for faster dashboard loads. (#123)
+
+### Changed
+
+- Changed default retry policy to exponential backoff. (#140)
+
+### Fixed
+
+- Fixed crash when importing a config with empty sections. (#155)
+
+## [1.4.0] - 2026-02-01
+
+### Added
+
+- Added support for exporting reports as CSV. (#110)
+
+### Fixed
+
+- Fixed incorrect timezone handling in scheduled jobs. (#117)
+```
+
+## Quality checklist
+
+- Entries are under **`Unreleased`** and categorized correctly.
+- Wording is consistent (same tense/style across bullets).
+- No installation instructions, no commit SHAs.
+- The changelog remains easy to scan and matches the repo’s established conventions.