mitsupi 1.0.0

package/skills/pi-share/fetch-session.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+/**
+ * Fetch and parse pi-share (shittycodingagent.ai/buildwithpi.ai/buildwithpi.com) session exports.
+ * 
+ * Usage:
+ *   node fetch-session.mjs <url-or-gist-id> [--header] [--entries] [--system] [--tools] [--human-summary] [--no-cache]
+ * 
+ * Options:
+ *   (no flag)        Output full session data JSON
+ *   --header         Output just the session header
+ *   --entries        Output entries as JSON lines (one per line)
+ *   --system         Output the system prompt
+ *   --tools          Output tool definitions
+ *   --human-summary  Summarize what the human did in this session (uses haiku-4-5)
+ *   --no-cache       Bypass cache and fetch fresh
+ */
+
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { spawnSync } from 'child_process';
+
+const CACHE_DIR = join(tmpdir(), 'pi-share-cache');
+
+const args = process.argv.slice(2);
+const input = args.find(a => !a.startsWith('--'));
+const flags = new Set(args.filter(a => a.startsWith('--')));
+
+if (!input) {
+  console.error('Usage: node fetch-session.mjs <url-or-gist-id> [--header|--entries|--system|--tools]');
+  process.exit(1);
+}
+
+// Cache functions
+function getCachePath(gistId) {
+  return join(CACHE_DIR, `${gistId}.json`);
+}
+
+function readCache(gistId) {
+  const path = getCachePath(gistId);
+  if (existsSync(path)) {
+    return JSON.parse(readFileSync(path, 'utf-8'));
+  }
+  return null;
+}
+
+function writeCache(gistId, data) {
+  mkdirSync(CACHE_DIR, { recursive: true });
+  writeFileSync(getCachePath(gistId), JSON.stringify(data));
+}
+
+// Extract gist ID from URL or use directly
+function extractGistId(input) {
+  // Handle full URLs like https://shittycodingagent.ai/session/?<id>
+  const queryMatch = input.match(/[?&]([a-f0-9]{32})/i);
+  if (queryMatch) return queryMatch[1];
+
+  // Handle path-based URLs like https://buildwithpi.ai/session/<id>
+  const pathMatch = input.match(/\/session\/?([a-f0-9]{32})/i);
+  if (pathMatch) return pathMatch[1];
+  
+  // Handle direct gist ID
+  if (/^[a-f0-9]{32}$/i.test(input)) return input;
+  
+  // Handle gist.github.com URLs
+  const gistMatch = input.match(/gist\.github\.com\/[^/]+\/([a-f0-9]+)/i);
+  if (gistMatch) return gistMatch[1];
+  
+  throw new Error(`Cannot extract gist ID from: ${input}`);
+}
+
+// Fetch session HTML from gist
+async function fetchSessionHtml(gistId) {
+  const gistRes = await fetch(`https://api.github.com/gists/${gistId}`);
+  if (!gistRes.ok) {
+    if (gistRes.status === 404) throw new Error('Session not found (gist deleted or invalid ID)');
+    throw new Error(`GitHub API error: ${gistRes.status}`);
+  }
+  
+  const gist = await gistRes.json();
+  const file = gist.files?.['session.html'];
+  if (!file) {
+    const available = Object.keys(gist.files || {}).join(', ') || 'none';
+    throw new Error(`No session.html in gist. Available: ${available}`);
+  }
+  
+  // Fetch raw content if truncated
+  if (file.truncated && file.raw_url) {
+    const rawRes = await fetch(file.raw_url);
+    if (!rawRes.ok) throw new Error('Failed to fetch raw content');
+    return rawRes.text();
+  }
+  
+  return file.content;
+}
+
+// Extract base64 session data from HTML
+function extractSessionData(html) {
+  // New format: <script id="session-data" type="application/json">BASE64</script>
+  const match = html.match(/<script[^>]*id="session-data"[^>]*>([^<]+)<\/script>/);
+  if (match) {
+    const base64 = match[1].trim();
+    const json = Buffer.from(base64, 'base64').toString('utf-8');
+    return JSON.parse(json);
+  }
+  
+  throw new Error('No session data found in HTML. This may be an older export format without embedded data.');
+}
+
+// Truncate text to maxLen, adding ellipsis if truncated
+function truncate(text, maxLen = 150) {
+  if (!text || text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + '...';
+}
+
+// Extract condensed session data for human summary
+function extractForSummary(data) {
+  const turns = [];
+  let turnNumber = 0;
+  
+  for (const entry of data.entries) {
+    if (entry.type !== 'message') continue;
+    
+    const msg = entry.message;
+    if (!msg || !msg.role) continue;
+    
+    if (msg.role === 'user') {
+      turnNumber++;
+      // Extract user text
+      const textParts = (msg.content || [])
+        .filter(c => c.type === 'text')
+        .map(c => c.text)
+        .join('\n');
+      
+      if (textParts.trim()) {
+        turns.push({
+          turn: turnNumber,
+          role: 'human',
+          text: textParts
+        });
+      }
+    } else if (msg.role === 'assistant') {
+      // Extract condensed assistant info: brief text + tool summary
+      const textParts = [];
+      const toolCalls = [];
+      
+      for (const block of (msg.content || [])) {
+        if (block.type === 'text' && block.text) {
+          // Just first 200 chars of assistant text for context
+          textParts.push(truncate(block.text, 200));
+        } else if (block.type === 'toolCall') {
+          // Condense tool call: name + truncated key info
+          let summary = block.toolName;
+          if (block.args) {
+            if (block.args.path) {
+              summary += `: ${truncate(block.args.path, 100)}`;
+            } else if (block.args.command) {
+              summary += `: ${truncate(block.args.command, 100)}`;
+            } else {
+              // Generic args truncation
+              const argsStr = JSON.stringify(block.args);
+              summary += `: ${truncate(argsStr, 100)}`;
+            }
+          }
+          toolCalls.push(summary);
+        }
+      }
+      
+      if (textParts.length || toolCalls.length) {
+        turns.push({
+          turn: turnNumber,
+          role: 'assistant',
+          text: textParts.length ? textParts[0] : null,
+          tools: toolCalls.length ? toolCalls : null
+        });
+      }
+    } else if (msg.role === 'toolResult') {
+      // Just note if there was an error
+      const hasError = (msg.content || []).some(c => c.isError);
+      if (hasError) {
+        turns.push({
+          turn: turnNumber,
+          role: 'tool_error',
+          text: 'Tool returned an error'
+        });
+      }
+    }
+  }
+  
+  return {
+    sessionId: data.header?.id,
+    timestamp: data.header?.timestamp,
+    cwd: data.header?.cwd,
+    turns
+  };
+}
+
+// Format condensed data as text for the summarizer
+function formatForSummary(condensed) {
+  const lines = [];
+  
+  lines.push(`Session: ${condensed.sessionId || 'unknown'}`);
+  lines.push(`Time: ${condensed.timestamp || 'unknown'}`);
+  lines.push(`Directory: ${condensed.cwd || 'unknown'}`);
+  lines.push('');
+  lines.push('=== Conversation ===');
+  lines.push('');
+  
+  for (const turn of condensed.turns) {
+    if (turn.role === 'human') {
+      lines.push(`[Turn ${turn.turn}] HUMAN:`);
+      lines.push(turn.text);
+      lines.push('');
+    } else if (turn.role === 'assistant') {
+      lines.push(`[Turn ${turn.turn}] ASSISTANT (condensed):`);
+      if (turn.text) {
+        lines.push(`  Response: ${turn.text}`);
+      }
+      if (turn.tools && turn.tools.length) {
+        lines.push(`  Tools used: ${turn.tools.join(', ')}`);
+      }
+      lines.push('');
+    } else if (turn.role === 'tool_error') {
+      lines.push(`[Turn ${turn.turn}] ⚠️ Tool error occurred`);
+      lines.push('');
+    }
+  }
+  
+  return lines.join('\n');
+}
+
+// Generate human summary using haiku via pi
+async function generateHumanSummary(data) {
+  const condensed = extractForSummary(data);
+  const formatted = formatForSummary(condensed);
+  
+  const prompt = `You are analyzing a coding agent session transcript. Your task is to summarize what the HUMAN did, not what the AI agent did.
+
+Focus on:
+1. What was the human's initial goal/request?
+2. How many times did they have to re-prompt or steer the agent?
+3. What kind of steering did they do? (corrections, clarifications, changes of direction, expressing frustration, etc.)
+4. Did the human have to intervene when things went wrong?
+5. How specific vs vague were their instructions?
+
+Write a ~300 word summary in third person ("The user asked...", "They then had to clarify...").
+Include a brief note about what domain/tools were involved for context, but keep focus on the human's actions and experience.
+
+Here is the condensed session transcript:
+
+${formatted}`;
+
+  try {
+    const result = spawnSync('pi', [
+      '--provider', 'anthropic',
+      '--model', 'claude-haiku-4-5',
+      '--no-tools',
+      '--no-session',
+      '-p',
+      prompt
+    ], {
+      encoding: 'utf-8',
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 60000
+    });
+    
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      throw new Error(result.stderr || 'pi command failed');
+    }
+    
+    return result.stdout.trim();
+  } catch (err) {
+    throw new Error(`Failed to generate summary: ${err.message}`);
+  }
+}
+
+// Main
+async function main() {
+  try {
+    const gistId = extractGistId(input);
+    
+    // Check cache first (unless --no-cache)
+    let data = null;
+    if (!flags.has('--no-cache')) {
+      data = readCache(gistId);
+    }
+    
+    if (!data) {
+      const html = await fetchSessionHtml(gistId);
+      data = extractSessionData(html);
+      writeCache(gistId, data);
+    }
+    
+    if (flags.has('--header')) {
+      console.log(JSON.stringify(data.header));
+    } else if (flags.has('--entries')) {
+      // Output as JSON lines - one entry per line
+      for (const entry of data.entries) {
+        console.log(JSON.stringify(entry));
+      }
+    } else if (flags.has('--system')) {
+      console.log(data.systemPrompt || '');
+    } else if (flags.has('--tools')) {
+      console.log(JSON.stringify(data.tools || []));
+    } else if (flags.has('--human-summary')) {
+      // Generate human-centric summary using haiku
+      const summary = await generateHumanSummary(data);
+      console.log(summary);
+    } else {
+      // Default: full session data
+      console.log(JSON.stringify(data));
+    }
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/sentry/SKILL.md

@@ -0,0 +1,239 @@
+---
+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 Skill
+
+Access Sentry data via the API for debugging and investigation. Uses auth token from `~/.sentryclirc`.
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Find errors on a date | `search-events.js --org X --start 2025-12-23T15:00:00 --level error` |
+| List open issues | `list-issues.js --org X --status unresolved` |
+| Get issue details | `fetch-issue.js <issue-id-or-url> --latest` |
+| Get event details | `fetch-event.js <event-id> --org X --project Y` |
+| Search logs | `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` flag)
+
+**Options:**
+- `--latest` - Include the latest event with full stack trace
+- `--org <org>` - Organization slug (for short IDs)
+- `--json` - Output raw JSON
+
+**Output includes:**
+- Title, culprit, status, level
+- First/last seen timestamps
+- Event count and user impact
+- Tags and environment info
+- With `--latest`: stack trace, request details, breadcrumbs, runtime context
+
+---
+
+## Fetch Event
+
+```bash
+./scripts/fetch-event.js <event-id> --org <org> --project <project> [options]
+```
+
+Get full details of a specific event by its ID.
+
+**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
+
+**Output includes:**
+- Timestamp, project, title, message
+- All tags
+- Context (runtime, browser, OS, trace info)
+- Request details
+- Exception with stack trace
+- Breadcrumbs
+- Spans (with `--spans`)
+
+---
+
+## Search Events
+
+```bash
+./scripts/search-events.js [options]
+```
+
+Search for events (transactions, errors) using Sentry Discover.
+
+**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:**
+```
+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]
+```
+
+List and search issues (grouped errors) in a project.
+
+**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
+
+**Query Syntax:**
+```
+is:unresolved             Status filter
+is:assigned               Has assignee
+assigned:me               Assigned to current user
+level:error               Level filter
+firstSeen:+7d             First seen > 7 days ago
+lastSeen:-24h             Last seen within 24h
+times_seen:>100           Event count filter
+has:user                  Has user context
+error.handled:0           Unhandled errors only
+```
+
+---
+
+## Search Logs
+
+```bash
+./scripts/search-logs.js [query|url] [options]
+```
+
+Search for logs in Sentry's Logs Explorer.
+
+**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
+
+**Query Syntax:**
+```
+level:error              Filter by level (trace, debug, info, warn, error, fatal)
+message:*timeout*        Search message text with wildcards
+trace:abc123             Filter by trace ID
+project:my-project       Filter by project slug
+```
+
+**Accepts Sentry URLs:**
+```bash
+./scripts/search-logs.js "https://myorg.sentry.io/explore/logs/?project=123&statsPeriod=7d"
+```
+
+---
+
+## Tips for Debugging
+
+1. **Start broad, then narrow down**: Use `search-events.js` with a time range first, then drill into specific events
+
+2. **Use breadcrumbs**: The `--breadcrumbs` flag on `fetch-event.js` shows the full history of what happened before an error
+
+3. **Look for patterns**: Use `list-issues.js --sort freq` to find frequently occurring problems
+
+4. **Check related events**: If you find one event, look for others with the same transaction name or trace ID
+
+5. **Tags are your friend**: Custom tags like `thread_id`, `user_id`, `request_id` help correlate events

package/skills/sentry/lib/auth.js

@@ -0,0 +1,99 @@
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export const SENTRY_API_BASE = "https://sentry.io/api/0";
+
+// Cache for project slug -> ID resolution
+const projectIdCache = new Map();
+
+/**
+ * Get auth token from ~/.sentryclirc
+ * @returns {string} The auth token
+ */
+export function getAuthToken() {
+  const rcPath = join(homedir(), ".sentryclirc");
+  if (!existsSync(rcPath)) {
+    console.error("Error: ~/.sentryclirc not found");
+    console.error("Run 'sentry-cli login' to authenticate");
+    process.exit(1);
+  }
+
+  const content = readFileSync(rcPath, "utf-8");
+  const match = content.match(/token\s*=\s*(.+)/);
+  if (!match) {
+    console.error("Error: No token found in ~/.sentryclirc");
+    process.exit(1);
+  }
+  return match[1].trim();
+}
+
+/**
+ * Fetch JSON from a Sentry API endpoint
+ * @param {string} url - The full URL to fetch
+ * @param {string} token - The auth token
+ * @returns {Promise<any>} The parsed JSON response
+ */
+export async function fetchJson(url, token) {
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+
+  return res.json();
+}
+
+/**
+ * Format a timestamp for display
+ * @param {string|number} ts - Timestamp (ISO string or unix)
+ * @returns {string} Formatted timestamp
+ */
+export function formatTimestamp(ts) {
+  if (!ts) return "N/A";
+  try {
+    const date = new Date(ts);
+    if (isNaN(date.getTime())) return ts;
+    return date.toLocaleString();
+  } catch {
+    return ts;
+  }
+}
+
+/**
+ * Resolve a project slug to its numeric ID.
+ * If the input is already a numeric ID, returns it as-is.
+ * @param {string} org - Organization slug
+ * @param {string} project - Project slug or numeric ID
+ * @param {string} token - Auth token
+ * @returns {Promise<string>} The numeric project ID
+ */
+export async function resolveProjectId(org, project, token) {
+  // If already numeric, return as-is
+  if (/^\d+$/.test(project)) {
+    return project;
+  }
+
+  // Check cache
+  const cacheKey = `${org}/${project}`;
+  if (projectIdCache.has(cacheKey)) {
+    return projectIdCache.get(cacheKey);
+  }
+
+  // Fetch project details to get the ID
+  const url = `${SENTRY_API_BASE}/projects/${encodeURIComponent(org)}/${encodeURIComponent(project)}/`;
+  const data = await fetchJson(url, token);
+
+  if (!data || !data.id) {
+    throw new Error(`Project '${project}' not found in organization '${org}'`);
+  }
+
+  const id = String(data.id);
+  projectIdCache.set(cacheKey, id);
+  return id;
+}