aw-ecc 1.4.32 → 1.4.47

package/scripts/hooks/aw-usage-post-tool-use-failure.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Usage telemetry — PostToolUseFailure hook.
+ *
+ * Claude: error (string/object) + is_interrupt (boolean).
+ * Cursor: error_message (string) + failure_type ("timeout"/"error"/"permission_denied").
+ * Codex: does NOT support PostToolUseFailure — this hook won't fire.
+ *
+ * Outputs {} on stdout.
+ */
+
+'use strict';
+
+const { buildEvent, sendAsync } = 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 toolName = input.tool_name || 'unknown';
+
+    // Normalize error fields across Claude and Cursor
+    let errorMessage;
+    let failureType;
+
+    if (input.error_message !== undefined) {
+      // Cursor format
+      errorMessage = String(input.error_message || '');
+      failureType = input.failure_type || 'error';
+    } else {
+      // Claude format
+      const err = input.error;
+      errorMessage = typeof err === 'string' ? err : (err?.message || JSON.stringify(err) || 'unknown');
+      failureType = input.is_interrupt ? 'interrupt' : 'error';
+    }
+
+    sendAsync(buildEvent(input, 'tool_error', {
+      tool_name: toolName,
+      error_message: errorMessage.slice(0, 500),
+      failure_type: failureType,
+    }));
+  } catch {
+    // Non-blocking.
+  }
+
+  process.stdout.write('{}');
+});

package/scripts/hooks/aw-usage-post-tool-use.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/**
+ * Usage telemetry — PostToolUse hook.
+ *
+ * Detects: skill invocations, agent spawns, skill pushes.
+ * PR contribution is tracked via Co-Authored-By trailer in prepare-commit-msg hook.
+ * Outputs {} on stdout (Claude/Codex parse stdout as JSON).
+ */
+
+'use strict';
+
+const {
+  buildEvent,
+  detectHarness,
+  sendAsync,
+  readSessionSkill,
+  tryAcquireDedupe,
+} = require('../lib/aw-usage-telemetry');
+
+const MAX_STDIN = 1024 * 1024;
+function parseMaybeJsonObject(value) {
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed || !/^[{[]/.test(trimmed)) return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function toObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function getSessionId(input) {
+  return input?.session_id || input?.conversation_id || null;
+}
+
+function getCommand(input) {
+  return String(
+    input?.tool_input?.command
+    || input?.tool_input?.args?.command
+    || ''
+  );
+}
+
+function normalizeToolResult(input) {
+  const rawToolResponse = parseMaybeJsonObject(input?.tool_response);
+  const rawToolOutput = parseMaybeJsonObject(input?.tool_output);
+  const toolResponse = toObject(rawToolResponse);
+  const toolOutput = toObject(rawToolOutput);
+  const exitCode = [
+    input?.exit_code,
+    toolResponse.exit_code,
+    toolResponse.exitCode,
+    toolOutput.exit_code,
+    toolOutput.exitCode,
+  ].find(value => value !== undefined && value !== null && value !== '');
+  const messageParts = [
+    toolResponse.stderr,
+    toolOutput.stderr,
+    toolResponse.output,
+    toolOutput.output,
+    typeof rawToolResponse === 'string' ? rawToolResponse : '',
+    typeof rawToolOutput === 'string' ? rawToolOutput : '',
+    input?.stderr,
+    input?.output,
+  ].filter(value => typeof value === 'string' && value.trim());
+
+  return {
+    exitCode: exitCode === undefined ? null : Number(exitCode),
+    errorMessage: messageParts.join('\n').slice(0, 500),
+  };
+}
+
+function isExplicitFailureExitCode(exitCode) {
+  return exitCode !== null && Number.isFinite(exitCode) && exitCode !== 0;
+}
+
+function inferShellFailureFromMessage(toolName, errorMessage) {
+  if (toolName !== 'Shell' && toolName !== 'Bash') return false;
+  if (typeof errorMessage !== 'string' || !errorMessage.trim()) return false;
+  const patterns = [
+    /(?:^|\n)[^:\n]+:\s.*\bNo such file or directory\b/i,
+    /(?:^|\n)[^:\n]+:\s.*\bPermission denied\b/i,
+    /(?:^|\n)[^:\n]+:\s.*\bOperation not permitted\b/i,
+    /(?:^|\n)(?:bash|zsh|sh): .*?\bcommand not found\b/i,
+    /(?:^|\n)[^:\n]+:\s.*\bcannot access\b/i,
+    /(?:^|\n)[^:\n]+:\s.*\bis a directory\b/i,
+  ];
+  return patterns.some(pattern => pattern.test(errorMessage));
+}
+
+function shouldEmitSkillName(skillName) {
+  return Boolean(skillName) && skillName !== 'using-aw-skills';
+}
+
+function collectPostToolUseEvents(input, options = {}) {
+  const events = [];
+  const toolName = input?.tool_name || '';
+  const promptSkillOverride = options.promptSkillOverride || null;
+
+  // Skill detection: Claude uses tool_name='Skill', Cursor reads SKILL.md via 'Read' tool.
+  const filePath = input?.tool_input?.file_path || '';
+  const isSkillRead = toolName === 'Read' && /\/SKILL\.md$/i.test(filePath);
+
+  if (toolName === 'Skill' || isSkillRead) {
+    let skillName = input?.tool_input?.skill || input?.tool_input?.args?.skill || '';
+    // For Cursor: extract skill name from path (e.g. .../skills/<skill-name>/SKILL.md)
+    if (!skillName && isSkillRead) {
+      const pathMatch = filePath.match(/\/skills\/([^/]+)\/SKILL\.md$/i);
+      skillName = pathMatch ? pathMatch[1] : filePath.split('/').slice(-2, -1)[0] || '';
+    }
+    if (shouldEmitSkillName(skillName)) {
+      events.push({
+        eventType: 'skill_invoked',
+        payload: {
+          skill_name: skillName,
+          args: input?.tool_input?.args || '',
+        },
+      });
+    }
+  } else if (toolName === 'Agent') {
+    events.push({
+      eventType: 'agent_spawned',
+      payload: {
+        agent_type: input?.tool_input?.subagent_type || 'general-purpose',
+        description: input?.tool_input?.description || '',
+      },
+    });
+  }
+
+  const toolResult = normalizeToolResult(input);
+  if (isExplicitFailureExitCode(toolResult.exitCode)
+    || inferShellFailureFromMessage(toolName, toolResult.errorMessage)) {
+    const payload = {
+      tool_name: toolName || 'unknown',
+      error_message: toolResult.errorMessage,
+      failure_type: 'error',
+    };
+    if (isExplicitFailureExitCode(toolResult.exitCode)) {
+      payload.exit_code = toolResult.exitCode;
+    }
+    events.push({
+      eventType: 'tool_error',
+      payload,
+    });
+  }
+
+  if (toolName === 'Shell' || toolName === 'Bash') {
+    const cmd = getCommand(input);
+    // Codex skill detection: Bash commands that read SKILL.md files.
+    if (!promptSkillOverride) {
+      const skillCmdMatch = cmd.match(/\/skills\/([^/]+)\/SKILL\.md/i);
+      if (skillCmdMatch && shouldEmitSkillName(skillCmdMatch[1])) {
+        events.push({
+          eventType: 'skill_invoked',
+          payload: {
+            skill_name: skillCmdMatch[1],
+            args: '',
+          },
+        });
+      }
+    }
+    if (/\baw\s+push\b/.test(cmd)) {
+      const skillMatch = cmd.match(/aw\s+push\s+(\S+)/);
+      events.push({
+        eventType: 'skill_pushed',
+        payload: {
+          skill_name: skillMatch ? skillMatch[1] : '',
+        },
+      });
+    }
+  }
+
+  return events;
+}
+
+function processPostToolUseInput(input, deps = {}) {
+  const emit = typeof deps.emit === 'function' ? deps.emit : () => {};
+  const promptSkillOverride = deps.promptSkillOverride || readSessionSkill(
+    getSessionId(input),
+    input?.turn_id || null,
+  );
+  const events = collectPostToolUseEvents(input, { promptSkillOverride });
+  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);
+      const shouldDedup = detectHarness(input) === 'codex' || Boolean(input?.tool_use_id);
+      if (!shouldDedup || tryAcquireDedupe('post-tool-use', [
+        getSessionId(input),
+        input?.turn_id || '',
+        input?.tool_use_id || '',
+        input?.tool_name || '',
+        getCommand(input),
+        input?.tool_input?.file_path || '',
+        input?.tool_input?.description || '',
+      ])) {
+        processPostToolUseInput(input, {
+          emit(eventType, payload) {
+            sendAsync(buildEvent(input, eventType, payload));
+          },
+        });
+      }
+    } catch {
+      // Non-blocking — never fail the hook.
+    }
+
+    process.stdout.write('{}');
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  collectPostToolUseEvents,
+  inferShellFailureFromMessage,
+  isExplicitFailureExitCode,
+  normalizeToolResult,
+  parseMaybeJsonObject,
+  processPostToolUseInput,
+  shouldEmitSkillName,
+};

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

@@ -0,0 +1,112 @@
+#!/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,
+  resolvePromptText,
+  tryAcquireDedupe,
+  isCodexInternalTaskTitlePrompt,
+} = require('../lib/aw-usage-telemetry');
+
+const MAX_STDIN = 1024 * 1024;
+
+function extractAwSlashCommand(input) {
+  const prompt = resolvePromptText(input).trim();
+  const match = prompt.match(/^\/(aw:[a-z0-9-]+)(?:\s+([\s\S]*\S))?\s*$/i);
+  if (!match) return null;
+  return {
+    skill_name: match[1].toLowerCase(),
+    args: match[2] || '',
+    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 events = [];
+
+  events.push({ eventType: 'prompt_submitted', payload: {} });
+
+  const skill = extractAwSlashCommand(input);
+  if (skill) {
+    persistSkill(getSessionId(input), input?.turn_id || null, skill);
+    events.push({
+      eventType: 'skill_invoked',
+      payload: {
+        skill_name: skill.skill_name,
+        args: skill.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,
+        });
+      }
+    } catch {
+      // Non-blocking.
+    }
+
+    process.stdout.write('{}');
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  extractAwSlashCommand,
+  processPromptSubmitInput,
+  resolvePromptText,
+  shouldSkipPromptSubmitTelemetry,
+};

package/scripts/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/scripts/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,
+};