@ghl-ai/aw 0.1.55 → 0.1.56-beta.1

package/hooks/aw-usage/hooks/aw-usage-prompt-submit.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Usage telemetry — UserPromptSubmit hook.
+ *
+ * Emits prompt_submitted as a boundary marker.
+ * No matchers on any harness — always fires.
+ *
+ * Outputs {} on stdout.
+ */
+
+'use strict';
+
+const {
+  buildEvent,
+  sendAsync,
+  persistSessionSkill,
+  persistSessionSlashCommand,
+  resolvePromptText,
+  tryAcquireDedupe,
+  isCodexInternalTaskTitlePrompt,
+} = require('../lib/aw-usage-telemetry');
+
+const MAX_STDIN = 1024 * 1024;
+
+// Slash commands we recognize beyond /aw:*. Each entry maps to a namespace
+// used in the emitted payload so the dashboard can group by tool family.
+//   namespace:command  → matched by ^/<namespace>:<command>
+//   bare-name          → matched by ^/<bare-name>  (Matt Pocock skills, codex `/tdd`)
+const NAMESPACED_PREFIXES = ['aw', 'caveman', 'codex', 'graphify', 'rtk', 'lean-ctx'];
+const BARE_SLASH_COMMANDS = new Set([
+  'tdd', 'diagnose', 'grill-me', 'grill-with-docs', 'triage', 'to-prd', 'zoom-out',
+]);
+// `/aw:` sub-commands that count as SDLC stages so the funnel can group by stage.
+const AW_SDLC_STAGES = new Set([
+  'plan', 'build', 'execute', 'test', 'verify', 'review',
+  'deploy', 'ship', 'tdd', 'investigate', 'feature',
+]);
+
+function extractAwSlashCommand(input) {
+  const prompt = resolvePromptText(input).trim();
+
+  // Try `/namespace:command` shape first.
+  const namespacedRe = new RegExp(
+    `^\\/((?:${NAMESPACED_PREFIXES.join('|')})(?::[a-z0-9-]+)?)(?:\\s+([\\s\\S]*\\S))?\\s*$`,
+    'i',
+  );
+  let match = prompt.match(namespacedRe);
+  let commandFull = null;
+  let commandArgs = '';
+  if (match) {
+    commandFull = match[1].toLowerCase();
+    commandArgs = match[2] || '';
+  } else {
+    // Try bare name shape (e.g. `/tdd ...`).
+    const bareRe = /^\/([a-z][a-z0-9-]*)(?:\s+([\s\S]*\S))?\s*$/i;
+    const bareMatch = prompt.match(bareRe);
+    if (bareMatch && BARE_SLASH_COMMANDS.has(bareMatch[1].toLowerCase())) {
+      commandFull = bareMatch[1].toLowerCase();
+      commandArgs = bareMatch[2] || '';
+    }
+  }
+  if (!commandFull) return null;
+
+  // Split into namespace + name. Bare names have no namespace.
+  let namespace = null;
+  let name = commandFull;
+  const colonIdx = commandFull.indexOf(':');
+  if (colonIdx > 0) {
+    namespace = commandFull.slice(0, colonIdx);
+    name = commandFull.slice(colonIdx + 1);
+  }
+
+  const isSdlcStage = namespace === 'aw' && AW_SDLC_STAGES.has(name);
+
+  return {
+    skill_name: commandFull,              // kept for backwards compat with existing skill_invoked consumers
+    command_namespace: namespace,
+    command_name: commandFull,
+    command_args: commandArgs,
+    is_sdlc_stage: isSdlcStage,
+    args: commandArgs,                    // backwards compat alias
+    source: 'user_prompt',
+  };
+}
+
+function getSessionId(input) {
+  return input?.session_id || input?.conversation_id || 'unknown';
+}
+
+function shouldSkipPromptSubmitTelemetry(input) {
+  return isCodexInternalTaskTitlePrompt(input);
+}
+
+function processPromptSubmitInput(input, deps = {}) {
+  const emit = typeof deps.emit === 'function' ? deps.emit : () => {};
+  const persistSkill = typeof deps.persistSkill === 'function' ? deps.persistSkill : () => {};
+  const persistSlashCmd = typeof deps.persistSlashCmd === 'function' ? deps.persistSlashCmd : () => {};
+  const events = [];
+
+  const slash = extractAwSlashCommand(input);
+  const promptPayload = {};
+  if (slash) {
+    promptPayload.command_namespace = slash.command_namespace;
+    promptPayload.command_name = slash.command_name;
+    promptPayload.command_args = slash.command_args;
+    promptPayload.is_sdlc_stage = slash.is_sdlc_stage;
+  }
+  events.push({ eventType: 'prompt_submitted', payload: promptPayload });
+
+  if (slash) {
+    persistSkill(getSessionId(input), input?.turn_id || null, slash);
+    persistSlashCmd(getSessionId(input), slash);
+    events.push({
+      eventType: 'skill_invoked',
+      payload: {
+        skill_name: slash.skill_name,
+        args: slash.args,
+      },
+    });
+  }
+
+  for (const event of events) {
+    emit(event.eventType, event.payload);
+  }
+
+  return events;
+}
+
+function main() {
+  let raw = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      raw += chunk.substring(0, MAX_STDIN - raw.length);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    try {
+      const input = JSON.parse(raw);
+      if (!shouldSkipPromptSubmitTelemetry(input)
+        && tryAcquireDedupe('prompt-submit', [
+          getSessionId(input),
+          input?.turn_id || '',
+          resolvePromptText(input),
+        ])) {
+        processPromptSubmitInput(input, {
+          emit(eventType, payload) {
+            sendAsync(buildEvent(input, eventType, payload));
+          },
+          persistSkill: persistSessionSkill,
+          persistSlashCmd: persistSessionSlashCommand,
+        });
+      }
+    } catch {
+      // Non-blocking.
+    }
+
+    process.stdout.write('{}');
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  extractAwSlashCommand,
+  processPromptSubmitInput,
+  resolvePromptText,
+  shouldSkipPromptSubmitTelemetry,
+};

package/hooks/aw-usage/hooks/aw-usage-session-start.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * Usage telemetry — SessionStart hook.
+ *
+ * Captures session_start event and persists the model for later hooks.
+ * Claude sends model on SessionStart only — this is the only chance to capture it.
+ *
+ * Outputs {} on stdout.
+ */
+
+'use strict';
+
+const { buildEvent, sendAsync, persistSessionModel, pruneStaleSessionFiles } = require('../lib/aw-usage-telemetry');
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  if (raw.length < MAX_STDIN) {
+    raw += chunk.substring(0, MAX_STDIN - raw.length);
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const input = JSON.parse(raw);
+    const sessionId = input.session_id
+      || input._cursor?.conversation_id
+      || input.conversation_id
+      || null;
+    const model = input.model || input._cursor?.model || null;
+
+    // Prune stale session files (>24h) to prevent unbounded growth
+    pruneStaleSessionFiles();
+
+    // Persist model so PostToolUse/Stop hooks can read it
+    persistSessionModel(sessionId, model);
+
+    sendAsync(buildEvent(input, 'session_start', {
+      model: model || null,
+    }));
+  } catch {
+    // Non-blocking.
+  }
+
+  process.stdout.write('{}');
+});

package/hooks/aw-usage/hooks/aw-usage-stop.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * Usage telemetry — Stop hook.
+ *
+ * Captures response_completed per turn (fires after each Claude/Cursor/Codex response).
+ *
+ * No harness provides token usage in hook input directly. All three provide
+ * transcript_path — we parse the transcript JSONL to extract model, stop_reason,
+ * and usage for any harness.
+ *
+ * Pricing is resolved dynamically via OpenRouter API (24h cached) with a
+ * hardcoded fallback for when the API is unreachable and no cache exists.
+ *
+ * Outputs {} on stdout.
+ */
+
+'use strict';
+
+const {
+  buildEvent,
+  sendAsync,
+  detectHarness,
+  persistSessionModel,
+  readLastAssistantFromTranscript,
+  tryAcquireDedupe,
+  isCodexInternalTaskTitleCompletion,
+} = require('../lib/aw-usage-telemetry');
+const { estimateCost, toNumber } = require('../lib/aw-pricing');
+
+const MAX_STDIN = 1024 * 1024;
+function pickFirstNumber(...values) {
+  for (const value of values) {
+    const n = toNumber(value);
+    if (n !== 0) return n;
+  }
+  return 0;
+}
+
+function buildResponseCompletedData(input) {
+  const harness = detectHarness(input);
+
+  // Parse transcript for all harnesses — all three provide transcript_path.
+  // The shared parser now understands both Claude/Cursor JSONL and Codex
+  // response_item + token_count transcript shapes.
+  let transcriptData = null;
+  if (input.transcript_path) {
+    transcriptData = readLastAssistantFromTranscript(input.transcript_path);
+  }
+
+  // Normalize stop reason across harnesses.
+  let stopReason;
+  if (harness === 'cursor') {
+    // Cursor adapter maps sessionEnd.reason / stop.status to stop_reason.
+    stopReason = input.stop_reason || input.status || input.reason || 'unknown';
+  } else if (harness === 'codex') {
+    stopReason = input.last_assistant_message ? 'completed' : 'unknown';
+  } else {
+    // Claude: prefer hook input, fall back to transcript.
+    stopReason = input.stop_reason
+      || (transcriptData && transcriptData.stop_reason)
+      || 'unknown';
+  }
+
+  // Token usage — prefer top-level fields (Cursor sends these directly),
+  // then input.usage, then transcript as last resort.
+  const hookUsage = input.usage || {};
+  const txUsage = (transcriptData && transcriptData.usage) || {};
+  const usage = Object.keys(hookUsage).length > 0 ? hookUsage : txUsage;
+
+  const inputTokens = pickFirstNumber(
+    input.input_tokens,
+    usage.input_tokens,
+    usage.prompt_tokens,
+  );
+  const outputTokens = pickFirstNumber(
+    input.output_tokens,
+    usage.output_tokens,
+    usage.completion_tokens,
+  );
+  const cacheReadTokens = pickFirstNumber(
+    input.cache_read_tokens,
+    usage.cache_read_input_tokens,
+    usage.cached_input_tokens,
+  );
+  const cacheCreateTokens = pickFirstNumber(
+    input.cache_write_tokens,
+    usage.cache_creation_input_tokens,
+  );
+
+  // Model: prefer hook input → transcript → session file.
+  const model = input.model
+    || input._cursor?.model
+    || (transcriptData && transcriptData.model)
+    || null;
+
+  // Persist model so PostToolUse/UserPromptSubmit hooks can read it.
+  // Stop fires every turn (before those hooks), so this stays fresh.
+  const sessionId = input.session_id || input.conversation_id || 'unknown';
+  if (model && sessionId !== 'unknown') {
+    persistSessionModel(sessionId, model);
+  }
+
+  const payload = { stop_reason: stopReason };
+
+  if (model) {
+    payload.model = model;
+  }
+
+  if (inputTokens || outputTokens) {
+    payload.input_tokens = inputTokens;
+    payload.output_tokens = outputTokens;
+    payload.estimated_cost_usd = estimateCost(model, inputTokens, outputTokens, {
+      cacheReadTokens,
+      cacheWriteTokens: cacheCreateTokens,
+    });
+  }
+
+  if (cacheReadTokens || cacheCreateTokens) {
+    payload.cache_read_tokens = cacheReadTokens;
+    if (cacheCreateTokens) {
+      payload.cache_create_tokens = cacheCreateTokens;
+    }
+  }
+
+  return { model, payload, sessionId };
+}
+
+function shouldSkipResponseCompleted(input) {
+  return isCodexInternalTaskTitleCompletion(input);
+}
+
+function main() {
+  let raw = '';
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      raw += chunk.substring(0, MAX_STDIN - raw.length);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    try {
+      const input = JSON.parse(raw);
+      if (!shouldSkipResponseCompleted(input)) {
+        const { model, payload, sessionId } = buildResponseCompletedData(input);
+
+        if (tryAcquireDedupe('response-completed', [
+          sessionId,
+          input?.turn_id || '',
+          input?.transcript_path || '',
+          input?.last_assistant_message || '',
+          input?.model || '',
+          payload.stop_reason || '',
+          payload.input_tokens || '',
+          payload.output_tokens || '',
+        ])) {
+          // Override model in the event envelope too (buildEvent reads from hook input
+          // which doesn't have model for Claude — inject it so the top-level field is set).
+          const event = buildEvent(input, 'response_completed', payload);
+          if (model && !event.model) {
+            event.model = model;
+          }
+          sendAsync(event);
+        }
+      }
+    } catch {
+      // Non-blocking.
+    }
+
+    process.stdout.write('{}');
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  buildResponseCompletedData,
+  shouldSkipResponseCompleted,
+};

package/hooks/aw-usage/hooks/aw-usage-telemetry-send.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Detached sender — receives a single usage telemetry event as argv[2],
+ * POSTs it to the telemetry API, then exits.
+ *
+ * Spawned by sendAsync() in aw-usage-telemetry.js with { detached: true }.
+ * This script runs independently after the parent hook process exits.
+ */
+
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+const DEFAULT_URL = 'https://services.leadconnectorhq.com/agentic-workspace/api/telemetry/usage-events';
+const TIMEOUT_MS = 10_000;
+
+function post(url, body) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const transport = parsed.protocol === 'https:' ? https : http;
+
+    const req = transport.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: TIMEOUT_MS,
+      },
+      (res) => {
+        // Drain response
+        res.resume();
+        res.on('end', () => resolve(res.statusCode));
+      },
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('timeout'));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function main() {
+  const eventJson = process.argv[2];
+  if (!eventJson) {
+    process.exit(0);
+  }
+
+  // Resolve telemetry URL: env var → config file → production default.
+  // Config file fallback covers Cursor GUI which doesn't inherit shell env (Bug #9).
+  let baseUrl = process.env.AW_TELEMETRY_URL;
+  if (!baseUrl) {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const configPath = path.join(process.env.HOME || require('os').homedir(), '.aw', 'telemetry', 'config.json');
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      baseUrl = config.telemetry_url || null;
+    } catch { /* no config file — use default */ }
+  }
+  const url = baseUrl
+    ? `${baseUrl.replace(/\/+$/, '')}/telemetry/usage-events`
+    : DEFAULT_URL;
+
+  try {
+    await post(url, eventJson);
+  } catch (err) {
+    // Non-blocking — log and exit cleanly.
+    process.stderr.write(`[aw-telemetry] send failed: ${err.message}\n`);
+  }
+
+  process.exit(0);
+}
+
+main();