@ghl-ai/aw 0.1.37-beta.73 → 0.1.37-beta.75

package/commands/telemetry.mjs

@@ -1,13 +1,15 @@
-// commands/telemetry.mjs — `aw telemetry [push|flush|enable|disable|status]`
+// commands/telemetry.mjs — `aw telemetry [push|flush|flush-queue|scan-prs|enable|disable|status]`
 //
 // Subcommands:
-//   push   — Automatic telemetry push after every task run (called by collect-telemetry.sh)
-//   flush  — Flush token data from Claude JSONL sessions
-//   enable — Re-enable anonymous analytics
-//   disable — Opt out of anonymous analytics
-//   status — Show telemetry status (default)
-
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+//   push        — Automatic telemetry push after every task run (called by collect-telemetry.sh)
+//   flush       — Flush token data from Claude JSONL sessions
+//   flush-queue — Retry queued payloads that failed to push (offline queue)
+//   scan-prs    — Scan GitHub repos for AI-authored PRs (Co-Authored-By attribution)
+//   enable      — Re-enable anonymous analytics
+//   disable     — Opt out of anonymous analytics
+//   status      — Show telemetry status (default)
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -59,6 +61,10 @@ export async function telemetryCommand(args) {
     await pushCommand(args);
   } else if (subcommand === 'flush') {
     await flushCommand(args);
+  } else if (subcommand === 'flush-queue') {
+    await flushQueueCommand();
+  } else if (subcommand === 'scan-prs') {
+    await scanPrsCommand(args);
   } else if (subcommand === 'disable') {
     disableTelemetry();
     fmt.logSuccess('Telemetry disabled. No anonymous usage data will be sent.');
@@ -73,12 +79,14 @@ export async function telemetryCommand(args) {
     fmt.logStep(`Machine ID: ${chalk.dim(status.machine_id)}`);
     fmt.logStep(`Config:     ${chalk.dim(status.config_path)}`);
     fmt.logMessage('');
-    fmt.logMessage(`  ${chalk.dim('aw telemetry disable')}  — opt out of anonymous analytics`);
-    fmt.logMessage(`  ${chalk.dim('aw telemetry enable')}   — re-enable analytics`);
-    fmt.logMessage(`  ${chalk.dim('aw telemetry push')}     — push telemetry data`);
-    fmt.logMessage(`  ${chalk.dim('aw telemetry flush')}    — flush token data from sessions`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry disable')}      — opt out of anonymous analytics`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry enable')}       — re-enable analytics`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry push')}         — push telemetry data`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry flush')}        — flush token data from sessions`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry flush-queue')}  — retry queued payloads (offline queue)`);
+    fmt.logMessage(`  ${chalk.dim('aw telemetry scan-prs')}    — scan GitHub for AI-authored PRs`);
   } else {
-    fmt.cancel(`Unknown telemetry subcommand: ${subcommand}. Use: aw telemetry [push|flush|enable|disable|status]`);
+    fmt.cancel(`Unknown telemetry subcommand: ${subcommand}. Use: aw telemetry [push|flush|flush-queue|scan-prs|enable|disable|status]`);
   }
 }
 
@@ -146,6 +154,24 @@ async function pushCommand(args) {
     agents_used:          record.agents_used ?? [],
     skills_applied:       record.skills_applied ?? [],
     github_login:         record.github_login ?? resolveGithubLogin() ?? undefined,
+    // Phase 2 fields
+    cache_creation_tokens: record.cache_creation_tokens ?? null,
+    cache_read_tokens:    record.cache_read_tokens ?? null,
+    project_hash:         record.project_hash ?? null,
+    platform:             record.platform ?? null,
+    platform_version:     record.platform_version ?? null,
+    session_id:           record.session_id ?? null,
+    session_duration_ms:  record.session_duration_ms ?? null,
+    compaction_count:     record.compaction_count ?? null,
+    mcp_tools_used:       record.mcp_tools_used ?? [],
+    checkpoint_from:      record.checkpoint_from ?? null,
+    checkpoint_to:        record.checkpoint_to ?? null,
+    pr_url:               record.pr_url ?? null,
+    pr_number:            record.pr_number ?? null,
+    pr_repo:              record.pr_repo ?? null,
+    pr_files_changed:     record.pr_files_changed ?? null,
+    error_type:           record.error_type ?? null,
+    error_message:        record.error_message ?? null,
   };
 
   if (!dto.shell_run_id || !dto.command) {
@@ -393,3 +419,309 @@ async function pushDto(dto) {
     clearTimeout(timer);
   }
 }
+
+// ── telemetry flush-queue ────────────────────────────────────────────────────
+
+async function flushQueueCommand() {
+  const queuePath = join(homedir(), '.aw', 'telemetry-queue.jsonl');
+
+  if (!existsSync(queuePath)) {
+    fmt.logSuccess('Offline queue is empty — nothing to flush.');
+    return;
+  }
+
+  let lines;
+  try {
+    lines = readFileSync(queuePath, 'utf8').trim().split('\n').filter(Boolean);
+  } catch {
+    fmt.logWarn('flush-queue: could not read queue file');
+    return;
+  }
+
+  if (lines.length === 0) {
+    fmt.logSuccess('Offline queue is empty — nothing to flush.');
+    return;
+  }
+
+  fmt.logStep(`Found ${lines.length} queued payload(s). Flushing...`);
+
+  const QUEUE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+  const remaining = [];
+  let flushed = 0;
+  let expired = 0;
+
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+
+    // Skip expired (>7 days)
+    if (Date.now() - new Date(entry.queued_at).getTime() > QUEUE_TTL_MS) {
+      expired++;
+      continue;
+    }
+
+    const apiKey = process.env['AW_API_KEY'] ?? '';
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+      const res = await fetch(AW_TELEMETRY_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(apiKey ? { 'X-API-Key': apiKey } : {}),
+        },
+        body: JSON.stringify(entry.payload),
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+
+      if (res.ok) {
+        flushed++;
+      } else {
+        entry.attempts = (entry.attempts || 0) + 1;
+        remaining.push(entry);
+      }
+    } catch {
+      clearTimeout(timer);
+      entry.attempts = (entry.attempts || 0) + 1;
+      remaining.push(entry);
+    }
+  }
+
+  // Rewrite queue with remaining entries
+  if (remaining.length > 0) {
+    writeFileSync(queuePath, remaining.map(e => JSON.stringify(e)).join('\n') + '\n');
+  } else {
+    try { unlinkSync(queuePath); } catch { /* already gone */ }
+  }
+
+  fmt.logSuccess(`Queue flush complete: ${flushed} pushed, ${expired} expired, ${remaining.length} still queued.`);
+}
+
+// ── telemetry scan-prs ───────────────────────────────────────────────────────
+// Scans GitHub repos for commits with Co-Authored-By trailers from AI coding
+// assistants. For each match, finds the containing PR and POSTs attribution
+// back to the telemetry API.
+//
+// Usage:
+//   aw telemetry scan-prs                        # scan repos from config
+//   aw telemetry scan-prs --org=myorg            # scan all repos in an org
+//   aw telemetry scan-prs --repo=owner/repo      # scan a specific repo
+//   aw telemetry scan-prs --days=7               # how far back to scan (default: 7)
+
+const CO_AUTHOR_PATTERNS = [
+  'Co-Authored-By: Claude',
+  'Co-Authored-By: claude',
+  'Co-authored-by: Claude',
+  'Co-authored-by: claude',
+  // Cursor / Copilot / generic AI
+  'Co-Authored-By: GitHub Copilot',
+  'Co-authored-by: GitHub Copilot',
+];
+
+// GitHub search query qualifier for co-authored commits
+const SEARCH_TRAILER = 'Co-Authored-By Claude';
+
+async function scanPrsCommand(args) {
+  const ghToken = process.env.GITHUB_TOKEN || resolveGhToken();
+  if (!ghToken) {
+    fmt.cancel('scan-prs: GITHUB_TOKEN not set. Export it or run `gh auth login`.');
+    return;
+  }
+
+  const days = parseInt(args['--days'] || '7', 10);
+  const sinceDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+  const specificRepo = args['--repo'] || null;
+  const org = args['--org'] || null;
+
+  fmt.intro('aw telemetry scan-prs');
+  fmt.logStep(`Scanning for AI-authored commits since ${sinceDate}...`);
+
+  // Determine repos to scan
+  let repos = [];
+  if (specificRepo) {
+    repos = [specificRepo];
+  } else if (org) {
+    repos = await listOrgRepos(org, ghToken);
+    if (repos.length === 0) {
+      fmt.logWarn(`No repos found for org "${org}"`);
+      return;
+    }
+    fmt.logStep(`Found ${repos.length} repos in ${org}`);
+  } else {
+    // Try to get repos from config
+    const configPath = join(homedir(), '.aw', 'config.json');
+    if (existsSync(configPath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+        if (cfg.scan_repos && Array.isArray(cfg.scan_repos)) {
+          repos = cfg.scan_repos;
+        }
+        if (cfg.scan_org) {
+          repos = await listOrgRepos(cfg.scan_org, ghToken);
+        }
+      } catch { /* use empty */ }
+    }
+
+    if (repos.length === 0) {
+      // Fallback: try to detect from current git remote
+      try {
+        const remote = execSync('git remote get-url origin', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const match = remote.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+        if (match) repos = [match[1]];
+      } catch { /* no git */ }
+    }
+
+    if (repos.length === 0) {
+      fmt.cancel('scan-prs: no repos to scan. Use --repo=owner/repo, --org=myorg, or add scan_repos to ~/.aw/config.json');
+      return;
+    }
+  }
+
+  let totalFound = 0;
+  let totalAttributed = 0;
+
+  for (const repo of repos) {
+    const commits = await findAiAuthoredCommits(repo, sinceDate, ghToken);
+    if (commits.length === 0) continue;
+
+    fmt.logStep(`${repo}: found ${commits.length} AI-authored commit(s)`);
+    totalFound += commits.length;
+
+    for (const commit of commits) {
+      const pr = await findPrForCommit(repo, commit.sha, ghToken);
+      if (!pr) continue;
+
+      // POST attribution to API
+      const dto = {
+        shell_run_id: `pr-scan-${commit.sha.slice(0, 12)}`,
+        command: 'pr-scan',
+        status: 'complete',
+        github_login: commit.author,
+        pr_url: pr.html_url,
+        pr_number: pr.number,
+        pr_repo: repo,
+        pr_files_changed: pr.changed_files || null,
+        branch: pr.head?.ref || null,
+      };
+
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+      try {
+        const apiKey = process.env['AW_API_KEY'] ?? '';
+        const res = await fetch(AW_TELEMETRY_URL, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...(apiKey ? { 'X-API-Key': apiKey } : {}),
+          },
+          body: JSON.stringify(dto),
+          signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (res.ok) totalAttributed++;
+      } catch {
+        clearTimeout(timer);
+      }
+    }
+  }
+
+  fmt.logSuccess(`Scan complete: ${totalFound} AI commits found, ${totalAttributed} PRs attributed.`);
+
+  // Save last scan timestamp
+  const configPath = join(homedir(), '.aw', 'config.json');
+  try {
+    let cfg = {};
+    if (existsSync(configPath)) {
+      try { cfg = JSON.parse(readFileSync(configPath, 'utf8')); } catch { cfg = {}; }
+    }
+    cfg.last_pr_scan = new Date().toISOString();
+    cfg.last_pr_scan_found = totalFound;
+    cfg.last_pr_scan_attributed = totalAttributed;
+    writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n');
+  } catch { /* best effort */ }
+}
+
+/** Resolve GitHub token from gh CLI auth. */
+function resolveGhToken() {
+  try {
+    return execSync('gh auth token', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return null; }
+}
+
+/** List repos in a GitHub org (up to 100, public + private). */
+async function listOrgRepos(org, token) {
+  try {
+    const res = await fetch(`https://api.github.com/orgs/${encodeURIComponent(org)}/repos?per_page=100&sort=pushed&direction=desc`, {
+      headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' },
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.map(r => r.full_name);
+  } catch { return []; }
+}
+
+/**
+ * Find commits with AI Co-Authored-By trailers in a repo.
+ * Uses GitHub Search API for commit messages.
+ */
+async function findAiAuthoredCommits(repo, since, token) {
+  const commits = [];
+
+  // GitHub commit search: search for "Co-Authored-By Claude" in the repo
+  // The search API is rate-limited (30 req/min for auth users), so we batch.
+  const query = encodeURIComponent(`repo:${repo} "${SEARCH_TRAILER}" committer-date:>=${since}`);
+  const url = `https://api.github.com/search/commits?q=${query}&per_page=100&sort=committer-date&order=desc`;
+
+  try {
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github.cloak-preview+json',
+      },
+    });
+    if (!res.ok) {
+      if (res.status === 422) {
+        // Validation failed — repo might not exist or search syntax issue
+        return commits;
+      }
+      fmt.logWarn(`scan-prs: GitHub search returned ${res.status} for ${repo}`);
+      return commits;
+    }
+
+    const data = await res.json();
+    for (const item of (data.items || [])) {
+      const message = item.commit?.message || '';
+      if (CO_AUTHOR_PATTERNS.some(p => message.includes(p))) {
+        commits.push({
+          sha: item.sha,
+          message: message.slice(0, 256),
+          author: item.author?.login || item.commit?.author?.email || 'unknown',
+          date: item.commit?.committer?.date || null,
+        });
+      }
+    }
+  } catch (err) {
+    fmt.logWarn(`scan-prs: search failed for ${repo} — ${err.message}`);
+  }
+
+  return commits;
+}
+
+/**
+ * Find the PR that contains a specific commit SHA.
+ * Returns the first PR found, or null.
+ */
+async function findPrForCommit(repo, sha, token) {
+  try {
+    const res = await fetch(`https://api.github.com/repos/${repo}/commits/${sha}/pulls`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github+json',
+      },
+    });
+    if (!res.ok) return null;
+    const prs = await res.json();
+    return prs.length > 0 ? prs[0] : null;
+  } catch { return null; }
+}

package/hooks/capabilities/telemetry.mjs

@@ -254,6 +254,8 @@ function extractFromTranscript(transcriptPath) {
     let toolTotal = 0;
     let toolFailed = 0;
     const prUrls = new Set();
+    let errorType = null;
+    let errorMessage = null;
 
     for (const line of lines) {
       try {
@@ -323,6 +325,21 @@ function extractFromTranscript(transcriptPath) {
             if (ec && ec !== 0) toolFailed++;
           }
         }
+
+        // ── Error detection ──────────────────────────────────────────────
+        // Capture last error from transcript for structured error reporting.
+        const entryError = entry.error || entry.message?.error;
+        if (entryError) {
+          const errStr = typeof entryError === 'string' ? entryError : (entryError.message || JSON.stringify(entryError));
+          errorMessage = errStr.slice(0, 1024);
+          // Classify error type
+          if (/rate.?limit|429|too many requests/i.test(errStr)) errorType = 'rate_limit';
+          else if (/context.?(overflow|length|window|limit|too long)/i.test(errStr)) errorType = 'context_overflow';
+          else if (/timeout|timed?\s*out|ETIMEDOUT/i.test(errStr)) errorType = 'timeout';
+          else if (/cancel|abort|interrupt/i.test(errStr)) errorType = 'user_cancel';
+          else if (/tool.?(fail|error)|execution.?error/i.test(errStr)) errorType = 'tool_failure';
+          else errorType = 'unknown';
+        }
       } catch { /* skip malformed lines */ }
     }
 
@@ -362,6 +379,8 @@ function extractFromTranscript(transcriptPath) {
       toolPassed: toolTotal - toolFailed,
       toolFailed,
       prUrls: [...prUrls],
+      errorType,
+      errorMessage,
     };
   } catch {
     return null;
@@ -687,6 +706,12 @@ export async function handleStop(input) {
       session.skills_applied = [...existing];
     }
 
+    // Track last error
+    if (transcript?.errorType) {
+      session.error_type = transcript.errorType;
+      session.error_message = transcript.errorMessage;
+    }
+
     writeSession(sessionId, session);
   }
 
@@ -773,6 +798,9 @@ export async function handlePreCompact(input) {
     pr_url: prUrl,
     pr_number: prNumber,
     pr_repo: prRepo,
+    // Error detail
+    error_type: session.error_type || null,
+    error_message: session.error_message || null,
   };
 
   const ok = await pushToApi(dto, session.namespace);
@@ -865,6 +893,9 @@ export async function handleSessionEnd(input) {
       pr_url: prUrl,
       pr_number: prNumber,
       pr_repo: prRepo,
+      // Error detail
+      error_type: session.error_type || null,
+      error_message: session.error_message || null,
     };
 
     const ok = await pushToApi(dto, session.namespace);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.73",
+  "version": "0.1.37-beta.75",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",