agent-trace 0.1.0 → 0.2.0

package/agent-trace.cjs

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // packages/runtime/src/standalone-entry.ts
-var import_node_path3 = __toESM(require("node:path"));
-var import_node_os2 = __toESM(require("node:os"));
-var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_path5 = __toESM(require("node:path"));
+var import_node_os3 = __toESM(require("node:os"));
+var import_node_fs5 = __toESM(require("node:fs"));
 
 // packages/dashboard/src/web-server.ts
 var import_node_http = __toESM(require("node:http"));
@@ -2202,32 +2202,32 @@ function isEventSource(value) {
 function isPrivacyTier(value) {
   return PRIVACY_TIERS.some((tier) => tier === value);
 }
-function addError(errors, path4, message) {
-  errors.push(`${path4}: ${message}`);
+function addError(errors, path6, message) {
+  errors.push(`${path6}: ${message}`);
 }
-function readRequiredString(source, key, errors, path4) {
+function readRequiredString(source, key, errors, path6) {
   const value = source[key];
   if (!isNonEmptyString(value)) {
-    addError(errors, path4, "must be a non-empty string");
+    addError(errors, path6, "must be a non-empty string");
     return void 0;
   }
   return value;
 }
-function readOptionalString(source, key, errors, path4) {
+function readOptionalString(source, key, errors, path6) {
   const value = source[key];
   if (value === void 0) {
     return void 0;
   }
   if (!isNonEmptyString(value)) {
-    addError(errors, path4, "must be a non-empty string when provided");
+    addError(errors, path6, "must be a non-empty string when provided");
     return void 0;
   }
   return value;
 }
-function readRequiredIsoDate(source, key, errors, path4) {
+function readRequiredIsoDate(source, key, errors, path6) {
   const value = source[key];
   if (!isValidIsoDate(value)) {
-    addError(errors, path4, "must be a valid ISO-8601 date");
+    addError(errors, path6, "must be a valid ISO-8601 date");
     return void 0;
   }
   return value;
@@ -3021,9 +3021,9 @@ function readStringArray(record, key) {
   }
   return output;
 }
-function readNestedString(record, path4) {
+function readNestedString(record, path6) {
   let current = record;
-  for (const key of path4) {
+  for (const key of path6) {
     const asObject = asRecord3(current);
     if (asObject === void 0) {
       return void 0;
@@ -4343,6 +4343,1126 @@ function createSqliteBackedRuntime(options) {
   };
 }
 
+// packages/cli/src/args.ts
+function isCliCommand(value) {
+  return value === "init" || value === "status" || value === "hook-handler";
+}
+function parsePrivacyTier(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === "1" || value === "2" || value === "3") {
+    return Number(value);
+  }
+  return void 0;
+}
+function parseArgs(argv) {
+  const commandCandidate = argv[2];
+  const command = isCliCommand(commandCandidate) ? commandCandidate : void 0;
+  let configDir;
+  let collectorUrl;
+  let privacyTier;
+  let installHooks;
+  let forward = false;
+  for (let i = 3; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--forward") {
+      forward = true;
+      continue;
+    }
+    if (token === "--install-hooks") {
+      installHooks = true;
+      continue;
+    }
+    if (token === "--no-install-hooks") {
+      installHooks = false;
+      continue;
+    }
+    if (token === "--config-dir") {
+      const value = argv[i + 1];
+      if (typeof value === "string" && value.length > 0) {
+        configDir = value;
+      }
+      i += 1;
+      continue;
+    }
+    if (token === "--collector-url") {
+      const value = argv[i + 1];
+      if (typeof value === "string" && value.length > 0) {
+        collectorUrl = value;
+      }
+      i += 1;
+      continue;
+    }
+    if (token === "--privacy-tier") {
+      const value = argv[i + 1];
+      privacyTier = parsePrivacyTier(value);
+      i += 1;
+      continue;
+    }
+  }
+  return {
+    command,
+    ...configDir !== void 0 ? { configDir } : {},
+    ...collectorUrl !== void 0 ? { collectorUrl } : {},
+    ...privacyTier !== void 0 ? { privacyTier } : {},
+    ...installHooks !== void 0 ? { installHooks } : {},
+    ...forward ? { forward: true } : {}
+  };
+}
+
+// packages/cli/src/claude-hooks.ts
+var HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "PostToolUse",
+  "Stop",
+  "TaskCompleted"
+];
+function buildClaudeHookConfig(hookCommand, generatedAt) {
+  return {
+    version: "1.0",
+    generatedAt,
+    hooks: HOOK_EVENTS.map((event) => ({
+      event,
+      command: hookCommand
+    }))
+  };
+}
+
+// packages/cli/src/config-store.ts
+var import_node_fs2 = __toESM(require("node:fs"));
+var import_node_os2 = __toESM(require("node:os"));
+var import_node_path3 = __toESM(require("node:path"));
+var CONFIG_FILE_NAME = "agent-trace.json";
+var CLAUDE_HOOKS_FILE_NAME = "agent-trace-claude-hooks.json";
+var CLAUDE_GLOBAL_SETTINGS_FILE_NAME = "settings.json";
+var CLAUDE_LOCAL_SETTINGS_FILE_NAME = "settings.local.json";
+function ensurePrivacyTier(value) {
+  return value === 1 || value === 2 || value === 3;
+}
+function parseConfig(raw) {
+  const parsedUnknown = JSON.parse(raw);
+  if (typeof parsedUnknown !== "object" || parsedUnknown === null) {
+    return void 0;
+  }
+  const parsed = parsedUnknown;
+  if (parsed["version"] !== "1.0") {
+    return void 0;
+  }
+  if (typeof parsed["collectorUrl"] !== "string" || parsed["collectorUrl"].length === 0) {
+    return void 0;
+  }
+  if (!ensurePrivacyTier(parsed["privacyTier"])) {
+    return void 0;
+  }
+  if (typeof parsed["hookCommand"] !== "string" || parsed["hookCommand"].length === 0) {
+    return void 0;
+  }
+  if (typeof parsed["updatedAt"] !== "string" || parsed["updatedAt"].length === 0) {
+    return void 0;
+  }
+  return {
+    version: "1.0",
+    collectorUrl: parsed["collectorUrl"],
+    privacyTier: parsed["privacyTier"],
+    hookCommand: parsed["hookCommand"],
+    updatedAt: parsed["updatedAt"]
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isGlobalClaudeConfigDir(configDir) {
+  const globalClaudeDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".claude");
+  return import_node_path3.default.resolve(configDir) === import_node_path3.default.resolve(globalClaudeDir);
+}
+function readSettingsDocument(filePath) {
+  if (!import_node_fs2.default.existsSync(filePath)) {
+    return {
+      exists: false,
+      settings: {}
+    };
+  }
+  try {
+    const parsed = JSON.parse(import_node_fs2.default.readFileSync(filePath, "utf8"));
+    if (!isRecord2(parsed)) {
+      return {
+        exists: true,
+        settings: {}
+      };
+    }
+    return {
+      exists: true,
+      settings: parsed
+    };
+  } catch {
+    return {
+      exists: true,
+      settings: {}
+    };
+  }
+}
+function toMutableHooks(settings) {
+  const mutableHooks = {};
+  const hooks = settings["hooks"];
+  if (!isRecord2(hooks)) {
+    return mutableHooks;
+  }
+  for (const [eventName, value] of Object.entries(hooks)) {
+    if (Array.isArray(value)) {
+      mutableHooks[eventName] = [...value];
+      continue;
+    }
+    mutableHooks[eventName] = [];
+  }
+  return mutableHooks;
+}
+function toMutableEnv(settings) {
+  const mutableEnv = {};
+  const env = settings["env"];
+  if (!isRecord2(env)) {
+    return mutableEnv;
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") {
+      mutableEnv[key] = value;
+    }
+  }
+  return mutableEnv;
+}
+function hasCommandOnEvent(entries, expectedCommand) {
+  return entries.some((entry) => {
+    if (!isRecord2(entry)) {
+      return false;
+    }
+    const hooks = entry["hooks"];
+    if (!Array.isArray(hooks)) {
+      return false;
+    }
+    return hooks.some((hook) => {
+      if (!isRecord2(hook)) {
+        return false;
+      }
+      return hook["type"] === "command" && hook["command"] === expectedCommand;
+    });
+  });
+}
+function createCommandEntry(command) {
+  const commandHook = {
+    type: "command",
+    command,
+    timeout: 10
+  };
+  return {
+    hooks: [commandHook]
+  };
+}
+function areHooksInstalled(hooksMap, config) {
+  return config.hooks.every((entry) => {
+    const entries = hooksMap[entry.event] ?? [];
+    return hasCommandOnEvent(entries, entry.command);
+  });
+}
+function toSettingsDocument(settings, hooksMap, envMap) {
+  const hooks = hooksMap;
+  const env = envMap;
+  return {
+    ...settings,
+    hooks,
+    ...Object.keys(env).length > 0 ? { env } : {}
+  };
+}
+var FileCliConfigStore = class {
+  resolveConfigDir(configDirOverride) {
+    if (configDirOverride !== void 0 && configDirOverride.length > 0) {
+      return configDirOverride;
+    }
+    const fromEnv = process.env["AGENT_TRACE_CONFIG_DIR"];
+    if (typeof fromEnv === "string" && fromEnv.length > 0) {
+      return fromEnv;
+    }
+    return import_node_path3.default.join(import_node_os2.default.homedir(), ".claude");
+  }
+  resolveConfigPath(configDirOverride) {
+    return import_node_path3.default.join(this.resolveConfigDir(configDirOverride), CONFIG_FILE_NAME);
+  }
+  resolveHooksPath(configDirOverride) {
+    return import_node_path3.default.join(this.resolveConfigDir(configDirOverride), CLAUDE_HOOKS_FILE_NAME);
+  }
+  resolveClaudeSettingsPath(configDirOverride) {
+    const configDir = this.resolveConfigDir(configDirOverride);
+    const settingsFileName = isGlobalClaudeConfigDir(configDir) ? CLAUDE_GLOBAL_SETTINGS_FILE_NAME : CLAUDE_LOCAL_SETTINGS_FILE_NAME;
+    return import_node_path3.default.join(configDir, settingsFileName);
+  }
+  readConfig(configDirOverride) {
+    const configPath = this.resolveConfigPath(configDirOverride);
+    if (!import_node_fs2.default.existsSync(configPath)) {
+      return void 0;
+    }
+    const raw = import_node_fs2.default.readFileSync(configPath, "utf8");
+    return parseConfig(raw);
+  }
+  writeConfig(config, configDirOverride) {
+    const configDir = this.resolveConfigDir(configDirOverride);
+    import_node_fs2.default.mkdirSync(configDir, { recursive: true });
+    const configPath = this.resolveConfigPath(configDirOverride);
+    import_node_fs2.default.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    return configPath;
+  }
+  writeClaudeHooks(config, configDirOverride) {
+    const configDir = this.resolveConfigDir(configDirOverride);
+    import_node_fs2.default.mkdirSync(configDir, { recursive: true });
+    const hooksPath = this.resolveHooksPath(configDirOverride);
+    import_node_fs2.default.writeFileSync(hooksPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    return hooksPath;
+  }
+  installClaudeHooks(config, configDirOverride, settingsEnv = {}) {
+    const configDir = this.resolveConfigDir(configDirOverride);
+    import_node_fs2.default.mkdirSync(configDir, { recursive: true });
+    const settingsPath = this.resolveClaudeSettingsPath(configDirOverride);
+    const read = readSettingsDocument(settingsPath);
+    const hooksMap = toMutableHooks(read.settings);
+    const envMap = toMutableEnv(read.settings);
+    let changed = !read.exists;
+    for (const hook of config.hooks) {
+      const eventEntries = hooksMap[hook.event] ?? [];
+      if (!hasCommandOnEvent(eventEntries, hook.command)) {
+        eventEntries.push(createCommandEntry(hook.command));
+        hooksMap[hook.event] = eventEntries;
+        changed = true;
+      }
+    }
+    Object.entries(settingsEnv).forEach(([key, value]) => {
+      if (envMap[key] !== value) {
+        envMap[key] = value;
+        changed = true;
+      }
+    });
+    const installed = areHooksInstalled(hooksMap, config);
+    if (changed) {
+      const updatedSettings = toSettingsDocument(read.settings, hooksMap, envMap);
+      import_node_fs2.default.writeFileSync(settingsPath, `${JSON.stringify(updatedSettings, null, 2)}
+`, "utf8");
+    }
+    return {
+      settingsPath,
+      installed
+    };
+  }
+  isClaudeHooksInstalled(config, configDirOverride) {
+    const settingsPath = this.resolveClaudeSettingsPath(configDirOverride);
+    const read = readSettingsDocument(settingsPath);
+    if (!read.exists) {
+      return false;
+    }
+    const hooksMap = toMutableHooks(read.settings);
+    return areHooksInstalled(hooksMap, config);
+  }
+};
+
+// packages/cli/src/init.ts
+function ensurePrivacyTierOrDefault(value) {
+  if (value === void 0) {
+    return 2;
+  }
+  return value;
+}
+function nowIso(inputNowIso) {
+  if (inputNowIso !== void 0) {
+    return inputNowIso;
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function shouldInstallHooks(value) {
+  if (value === void 0) {
+    return true;
+  }
+  return value;
+}
+function deriveOtelLogsEndpoint(collectorUrl) {
+  try {
+    const parsed = new URL(collectorUrl);
+    parsed.port = "4717";
+    parsed.pathname = "";
+    parsed.search = "";
+    parsed.hash = "";
+    const value = parsed.toString();
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+  } catch {
+    return "http://127.0.0.1:4717";
+  }
+}
+function buildTelemetryEnv(collectorUrl, privacyTier) {
+  const enablePromptAndToolDetail = privacyTier >= 2;
+  const otelLogsEndpoint = deriveOtelLogsEndpoint(collectorUrl);
+  return {
+    CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+    OTEL_METRICS_EXPORTER: "none",
+    OTEL_LOGS_EXPORTER: "otlp",
+    OTEL_EXPORTER_OTLP_PROTOCOL: "grpc",
+    OTEL_EXPORTER_OTLP_ENDPOINT: otelLogsEndpoint,
+    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: otelLogsEndpoint,
+    OTEL_LOG_USER_PROMPTS: enablePromptAndToolDetail ? "1" : "0",
+    OTEL_LOG_TOOL_DETAILS: enablePromptAndToolDetail ? "1" : "0"
+  };
+}
+function runInit(input, store = new FileCliConfigStore()) {
+  const timestamp = nowIso(input.nowIso);
+  const config = {
+    version: "1.0",
+    collectorUrl: input.collectorUrl ?? "http://127.0.0.1:8317/v1/hooks",
+    privacyTier: ensurePrivacyTierOrDefault(input.privacyTier),
+    hookCommand: "agent-trace hook-handler --forward",
+    updatedAt: timestamp
+  };
+  const telemetryEnv = buildTelemetryEnv(config.collectorUrl, config.privacyTier);
+  const hooks = buildClaudeHookConfig(config.hookCommand, timestamp);
+  const configPath = store.writeConfig(config, input.configDir);
+  const hooksPath = store.writeClaudeHooks(hooks, input.configDir);
+  const installResult = shouldInstallHooks(input.installHooks) ? store.installClaudeHooks(hooks, input.configDir, telemetryEnv) : {
+    settingsPath: store.resolveClaudeSettingsPath(input.configDir),
+    installed: store.isClaudeHooksInstalled(hooks, input.configDir)
+  };
+  return {
+    ok: true,
+    configPath,
+    hooksPath,
+    settingsPath: installResult.settingsPath,
+    settingsHooksInstalled: installResult.installed,
+    config,
+    hooks
+  };
+}
+
+// packages/cli/src/status.ts
+var import_node_fs3 = __toESM(require("node:fs"));
+function runStatus(configDir, store = new FileCliConfigStore()) {
+  const configPath = store.resolveConfigPath(configDir);
+  const hooksPath = store.resolveHooksPath(configDir);
+  const config = store.readConfig(configDir);
+  if (config === void 0) {
+    return {
+      ok: false,
+      message: "agent-trace config not found",
+      configPath
+    };
+  }
+  const settingsPath = store.resolveClaudeSettingsPath(configDir);
+  const expectedHooks = buildClaudeHookConfig(config.hookCommand, config.updatedAt);
+  return {
+    ok: true,
+    message: "agent-trace config found",
+    configPath,
+    hooksPath,
+    hooksConfigured: import_node_fs3.default.existsSync(hooksPath),
+    settingsPath,
+    settingsHooksInstalled: store.isClaudeHooksInstalled(expectedHooks, configDir),
+    config
+  };
+}
+
+// packages/cli/src/hook-handler.ts
+var import_node_crypto4 = __toESM(require("node:crypto"));
+var import_node_child_process = require("node:child_process");
+var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_path4 = __toESM(require("node:path"));
+function isIsoDate2(value) {
+  if (Number.isNaN(Date.parse(value))) {
+    return false;
+  }
+  return value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value);
+}
+function parseHookPayload(rawStdin) {
+  const trimmed = rawStdin.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const parsed = JSON.parse(trimmed);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function readString5(record, key) {
+  const value = record[key];
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return void 0;
+}
+function readNumber4(record, key) {
+  const value = record[key];
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return void 0;
+}
+function readStringArray3(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const output = [];
+  value.forEach((item) => {
+    if (typeof item === "string" && item.length > 0) {
+      output.push(item);
+    }
+  });
+  if (output.length === 0) {
+    return void 0;
+  }
+  return output;
+}
+function readNestedString2(record, path6) {
+  let current = record;
+  for (const key of path6) {
+    if (typeof current !== "object" || current === null || Array.isArray(current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  if (typeof current === "string" && current.length > 0) {
+    return current;
+  }
+  return void 0;
+}
+function pickCommand2(payload) {
+  const record = payload;
+  return readString5(record, "command") ?? readString5(record, "bash_command") ?? readString5(record, "bashCommand") ?? readNestedString2(record, ["tool_input", "command"]);
+}
+function pickToolName2(payload) {
+  const record = payload;
+  return readString5(record, "tool_name") ?? readString5(record, "toolName");
+}
+function isGitBashPayload(payload) {
+  const toolName = pickToolName2(payload);
+  const command = pickCommand2(payload);
+  if (toolName === void 0 || command === void 0) {
+    return false;
+  }
+  const cmd = command.trim();
+  return toolName.toLowerCase() === "bash" && (cmd.startsWith("git ") || cmd.startsWith("gh pr ") || cmd.includes("gh pr create"));
+}
+function isSessionEndEvent(payload) {
+  const eventType = pickEventType(payload).toLowerCase();
+  return eventType === "session_end" || eventType === "sessionend" || eventType === "stop" || eventType === "task_completed" || eventType === "taskcompleted";
+}
+function isSessionStartEvent(payload) {
+  const eventType = pickEventType(payload).toLowerCase();
+  return eventType === "session_start" || eventType === "sessionstart" || eventType === "startup";
+}
+function shouldAttemptGitEnrichment(payload) {
+  return isGitBashPayload(payload) || isSessionStartEvent(payload) || isSessionEndEvent(payload);
+}
+function isGitCommitCommand(command) {
+  return /\bgit\s+commit\b/.test(command);
+}
+function parseCommitMessage2(command) {
+  const regex = /(?:^|\s)-m\s+["']([^"']+)["']/;
+  const match = command.match(regex);
+  if (match?.[1] === void 0 || match[1].length === 0) {
+    return void 0;
+  }
+  const message = match[1];
+  if (message.startsWith("$(") || message.startsWith("`")) {
+    return void 0;
+  }
+  return message;
+}
+function extractPrUrl(payload) {
+  const record = payload;
+  const output = readString5(record, "tool_response") ?? readString5(record, "toolResponse") ?? readString5(record, "stdout") ?? readString5(record, "output");
+  const command = pickCommand2(payload);
+  const combined = [command, output].filter((s) => s !== void 0).join("\n");
+  if (combined.length === 0) return void 0;
+  const prUrlMatch = combined.match(/https:\/\/github\.com\/[^\s"']+\/pull\/\d+/);
+  if (prUrlMatch !== null && prUrlMatch[0] !== void 0) return prUrlMatch[0];
+  return void 0;
+}
+function parsePrFromUrl(url) {
+  const match = url.match(/https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
+  if (match === null || match[1] === void 0 || match[2] === void 0) return void 0;
+  const prNumber = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(prNumber)) return void 0;
+  return { repo: match[1], prNumber };
+}
+function pickRepositoryPath(payload) {
+  const record = payload;
+  return readString5(record, "project_path") ?? readString5(record, "projectPath") ?? readString5(record, "cwd") ?? readString5(record, "working_directory") ?? readString5(record, "workingDirectory");
+}
+function toUniqueStrings3(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  values.forEach((value) => {
+    if (value.length === 0 || seen.has(value)) {
+      return;
+    }
+    seen.add(value);
+    output.push(value);
+  });
+  return output;
+}
+function parseIntSafe(raw) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return void 0;
+  }
+  return parsed;
+}
+function parseNumstatOutput(raw) {
+  const lines = raw.split(/\r?\n/);
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  const filesChanged = [];
+  let matched = false;
+  lines.forEach((line) => {
+    const match = line.trim().match(/^(\d+|-)\s+(\d+|-)\s+(.+)$/);
+    if (match === null) {
+      return;
+    }
+    const addedRaw = match[1];
+    const removedRaw = match[2];
+    const filePath = match[3]?.trim();
+    if (filePath === void 0 || filePath.length === 0) {
+      return;
+    }
+    if (addedRaw !== void 0 && addedRaw !== "-") {
+      linesAdded += parseIntSafe(addedRaw) ?? 0;
+    }
+    if (removedRaw !== void 0 && removedRaw !== "-") {
+      linesRemoved += parseIntSafe(removedRaw) ?? 0;
+    }
+    filesChanged.push(filePath);
+    matched = true;
+  });
+  if (!matched) {
+    return void 0;
+  }
+  return {
+    linesAdded,
+    linesRemoved,
+    filesChanged: toUniqueStrings3(filesChanged)
+  };
+}
+function stableStringify(payload) {
+  const keys = Object.keys(payload).sort();
+  const record = {};
+  keys.forEach((key) => {
+    record[key] = payload[key];
+  });
+  return JSON.stringify(record);
+}
+function buildEventId3(payload, now) {
+  const material = `${now}:${stableStringify(payload)}`;
+  return import_node_crypto4.default.createHash("sha256").update(material).digest("hex");
+}
+function pickSessionId(payload) {
+  const fromSnake = payload["session_id"];
+  if (typeof fromSnake === "string" && fromSnake.length > 0) {
+    return fromSnake;
+  }
+  const fromCamel = payload["sessionId"];
+  if (typeof fromCamel === "string" && fromCamel.length > 0) {
+    return fromCamel;
+  }
+  return "unknown_session";
+}
+function pickPromptId2(payload) {
+  const fromSnake = payload["prompt_id"];
+  if (typeof fromSnake === "string" && fromSnake.length > 0) {
+    return fromSnake;
+  }
+  const fromCamel = payload["promptId"];
+  if (typeof fromCamel === "string" && fromCamel.length > 0) {
+    return fromCamel;
+  }
+  const fromMessageId = payload["message_id"];
+  if (typeof fromMessageId === "string" && fromMessageId.length > 0) {
+    return fromMessageId;
+  }
+  const fromMessageIdCamel = payload["messageId"];
+  if (typeof fromMessageIdCamel === "string" && fromMessageIdCamel.length > 0) {
+    return fromMessageIdCamel;
+  }
+  return void 0;
+}
+function pickEventType(payload) {
+  const event = payload["event"];
+  if (typeof event === "string" && event.length > 0) {
+    return event;
+  }
+  const type = payload["type"];
+  if (typeof type === "string" && type.length > 0) {
+    return type;
+  }
+  const hookEventNameSnake = payload["hook_event_name"];
+  if (typeof hookEventNameSnake === "string" && hookEventNameSnake.length > 0) {
+    return hookEventNameSnake;
+  }
+  const hookEventNameCamel = payload["hookEventName"];
+  if (typeof hookEventNameCamel === "string" && hookEventNameCamel.length > 0) {
+    return hookEventNameCamel;
+  }
+  const hookNameSnake = payload["hook_name"];
+  if (typeof hookNameSnake === "string" && hookNameSnake.length > 0) {
+    return hookNameSnake;
+  }
+  const hookNameCamel = payload["hookName"];
+  if (typeof hookNameCamel === "string" && hookNameCamel.length > 0) {
+    return hookNameCamel;
+  }
+  const hook = payload["hook"];
+  if (typeof hook === "string" && hook.length > 0) {
+    return hook;
+  }
+  return "hook_event";
+}
+function pickTimestamp(payload, now) {
+  const value = payload["timestamp"];
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return now;
+}
+function getPrivacyTier(store, configDir) {
+  const config = store.readConfig(configDir);
+  if (config === void 0) {
+    return 2;
+  }
+  return config.privacyTier;
+}
+function getCollectorUrl(store, configDir, collectorUrlOverride) {
+  if (collectorUrlOverride !== void 0 && collectorUrlOverride.length > 0) {
+    return collectorUrlOverride;
+  }
+  const config = store.readConfig(configDir);
+  if (config !== void 0) {
+    return config.collectorUrl;
+  }
+  return "http://127.0.0.1:8317/v1/hooks";
+}
+function normalizeBaseline(baseline) {
+  return {
+    ...baseline.repositoryPath !== void 0 ? { repositoryPath: baseline.repositoryPath } : {},
+    linesAdded: Math.max(0, Math.trunc(baseline.linesAdded)),
+    linesRemoved: Math.max(0, Math.trunc(baseline.linesRemoved)),
+    filesChanged: toUniqueStrings3(baseline.filesChanged),
+    capturedAt: baseline.capturedAt
+  };
+}
+function isHookSessionBaseline(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (typeof record["linesAdded"] !== "number" || typeof record["linesRemoved"] !== "number") {
+    return false;
+  }
+  if (typeof record["capturedAt"] !== "string") {
+    return false;
+  }
+  if (!Array.isArray(record["filesChanged"])) {
+    return false;
+  }
+  return record["filesChanged"].every((entry) => typeof entry === "string");
+}
+function parseBaselineFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      sessions: {}
+    };
+  }
+  const root = parsed;
+  const sessionsRaw = root["sessions"];
+  if (typeof sessionsRaw !== "object" || sessionsRaw === null || Array.isArray(sessionsRaw)) {
+    return {
+      sessions: {}
+    };
+  }
+  const sessionsRecord = sessionsRaw;
+  const sessions = {};
+  Object.keys(sessionsRecord).forEach((sessionId) => {
+    const candidate = sessionsRecord[sessionId];
+    if (!isHookSessionBaseline(candidate)) {
+      return;
+    }
+    sessions[sessionId] = normalizeBaseline(candidate);
+  });
+  return {
+    sessions
+  };
+}
+var FileHookSessionBaselineStore = class {
+  baselinePath;
+  constructor(store, configDir) {
+    this.baselinePath = import_node_path4.default.join(store.resolveConfigDir(configDir), "hook-session-baselines.json");
+  }
+  readState() {
+    try {
+      if (!import_node_fs4.default.existsSync(this.baselinePath)) {
+        return {
+          sessions: {}
+        };
+      }
+      const raw = import_node_fs4.default.readFileSync(this.baselinePath, "utf8");
+      return parseBaselineFile(raw);
+    } catch {
+      return {
+        sessions: {}
+      };
+    }
+  }
+  writeState(state) {
+    const dir = import_node_path4.default.dirname(this.baselinePath);
+    import_node_fs4.default.mkdirSync(dir, { recursive: true });
+    import_node_fs4.default.writeFileSync(this.baselinePath, JSON.stringify(state, null, 2), "utf8");
+  }
+  read(sessionId) {
+    const state = this.readState();
+    return state.sessions[sessionId];
+  }
+  write(sessionId, baseline) {
+    const state = this.readState();
+    const next = {
+      sessions: {
+        ...state.sessions,
+        [sessionId]: normalizeBaseline(baseline)
+      }
+    };
+    this.writeState(next);
+  }
+  delete(sessionId) {
+    const state = this.readState();
+    if (!(sessionId in state.sessions)) {
+      return;
+    }
+    const sessions = {
+      ...state.sessions
+    };
+    delete sessions[sessionId];
+    this.writeState({
+      sessions
+    });
+  }
+};
+function runGitCommand(args, repositoryPath) {
+  try {
+    const output = (0, import_node_child_process.execFileSync)("git", [...args], {
+      ...repositoryPath !== void 0 ? { cwd: repositoryPath } : {},
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    return trimmed;
+  } catch {
+    return void 0;
+  }
+}
+var ShellHookGitContextProvider = class {
+  readContext(request) {
+    const branch = runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], request.repositoryPath);
+    const headSha = runGitCommand(["rev-parse", "HEAD"], request.repositoryPath);
+    const diffStatsRaw = request.includeDiffStats && request.diffSource === "working_tree" ? runGitCommand(["diff", "--numstat", "HEAD"], request.repositoryPath) : request.includeDiffStats ? runGitCommand(["show", "--numstat", "--format="], request.repositoryPath) : void 0;
+    const diffStats = diffStatsRaw === void 0 ? void 0 : parseNumstatOutput(diffStatsRaw);
+    const commitMessage = request.includeCommitMessage === true ? runGitCommand(["log", "-1", "--format=%B"], request.repositoryPath) : void 0;
+    if (branch === void 0 && headSha === void 0 && commitMessage === void 0 && diffStats?.linesAdded === void 0 && diffStats?.linesRemoved === void 0 && diffStats?.filesChanged === void 0) {
+      return void 0;
+    }
+    return {
+      ...branch !== void 0 ? { branch } : {},
+      ...headSha !== void 0 ? { headSha } : {},
+      ...commitMessage !== void 0 ? { commitMessage } : {},
+      ...diffStats?.linesAdded !== void 0 ? { linesAdded: diffStats.linesAdded } : {},
+      ...diffStats?.linesRemoved !== void 0 ? { linesRemoved: diffStats.linesRemoved } : {},
+      ...diffStats?.filesChanged !== void 0 ? { filesChanged: diffStats.filesChanged } : {}
+    };
+  }
+};
+function enrichHookPayloadWithGitContext(payload, provider, baselineStore, now) {
+  if (!shouldAttemptGitEnrichment(payload)) {
+    return {
+      payload,
+      enriched: false,
+      usedSessionBaselineDelta: false
+    };
+  }
+  const record = payload;
+  const command = pickCommand2(payload);
+  const sessionStartEvent = isSessionStartEvent(payload);
+  const sessionEndEvent = isSessionEndEvent(payload);
+  const isCommit = command !== void 0 && isGitCommitCommand(command) && !sessionStartEvent && !sessionEndEvent;
+  const includeDiffStats = isCommit || sessionStartEvent || sessionEndEvent;
+  const diffSource = sessionStartEvent || sessionEndEvent ? "working_tree" : "head_commit";
+  const repositoryPath = pickRepositoryPath(payload);
+  const sessionId = pickSessionId(payload);
+  const contextRequest = {
+    includeDiffStats,
+    ...includeDiffStats ? { diffSource } : {},
+    ...isCommit ? { includeCommitMessage: true } : {},
+    ...repositoryPath !== void 0 ? { repositoryPath } : {}
+  };
+  const gitContext = provider.readContext(contextRequest);
+  let usedSessionBaselineDelta = false;
+  if (sessionStartEvent && sessionId !== "unknown_session" && gitContext !== void 0) {
+    baselineStore.write(sessionId, {
+      ...repositoryPath !== void 0 ? { repositoryPath } : {},
+      linesAdded: gitContext.linesAdded ?? 0,
+      linesRemoved: gitContext.linesRemoved ?? 0,
+      filesChanged: gitContext.filesChanged ?? [],
+      capturedAt: now
+    });
+  }
+  let linesAdded = gitContext?.linesAdded;
+  let linesRemoved = gitContext?.linesRemoved;
+  let filesChanged = gitContext?.filesChanged;
+  if (sessionStartEvent) {
+    linesAdded = void 0;
+    linesRemoved = void 0;
+    filesChanged = void 0;
+  }
+  if (sessionEndEvent && sessionId !== "unknown_session") {
+    const baseline = baselineStore.read(sessionId);
+    if (baseline !== void 0 && gitContext !== void 0) {
+      const currentLinesAdded = gitContext.linesAdded ?? 0;
+      const currentLinesRemoved = gitContext.linesRemoved ?? 0;
+      linesAdded = Math.max(0, currentLinesAdded - baseline.linesAdded);
+      linesRemoved = Math.max(0, currentLinesRemoved - baseline.linesRemoved);
+      const currentFiles = gitContext.filesChanged ?? [];
+      if (currentFiles.length > 0) {
+        const baselineFiles = new Set(baseline.filesChanged);
+        const deltaFiles = currentFiles.filter((filePath) => !baselineFiles.has(filePath));
+        filesChanged = deltaFiles.length > 0 ? deltaFiles : currentFiles;
+      }
+      usedSessionBaselineDelta = true;
+    }
+    baselineStore.delete(sessionId);
+  }
+  const patch = {};
+  if (isCommit) {
+    patch["is_commit"] = true;
+  }
+  const commitMessageFromCommand = command === void 0 ? void 0 : parseCommitMessage2(command);
+  const commitMessageFromGit = gitContext?.commitMessage;
+  const commitMessage = commitMessageFromCommand ?? commitMessageFromGit;
+  const existingCommitMessage = readString5(record, "commit_message") ?? readString5(record, "commitMessage");
+  if (existingCommitMessage === void 0 && commitMessage !== void 0) {
+    patch["commit_message"] = commitMessage;
+  }
+  const existingBranch = readString5(record, "git_branch") ?? readString5(record, "gitBranch");
+  if (existingBranch === void 0 && gitContext?.branch !== void 0) {
+    patch["git_branch"] = gitContext.branch;
+  }
+  const existingCommitSha = readString5(record, "commit_sha") ?? readString5(record, "commitSha");
+  if (existingCommitSha === void 0 && gitContext?.headSha !== void 0) {
+    patch["commit_sha"] = gitContext.headSha;
+  }
+  const existingLinesAdded = readNumber4(record, "lines_added") ?? readNumber4(record, "linesAdded");
+  if (existingLinesAdded === void 0 && linesAdded !== void 0) {
+    patch["lines_added"] = linesAdded;
+  }
+  const existingLinesRemoved = readNumber4(record, "lines_removed") ?? readNumber4(record, "linesRemoved");
+  if (existingLinesRemoved === void 0 && linesRemoved !== void 0) {
+    patch["lines_removed"] = linesRemoved;
+  }
+  const existingFilesChanged = readStringArray3(record, "files_changed") ?? readStringArray3(record, "filesChanged");
+  if (existingFilesChanged === void 0 && filesChanged !== void 0) {
+    patch["files_changed"] = filesChanged;
+  }
+  const prUrl = extractPrUrl(payload);
+  if (prUrl !== void 0) {
+    const existingPrUrl = readString5(record, "pr_url") ?? readString5(record, "prUrl");
+    if (existingPrUrl === void 0) {
+      patch["pr_url"] = prUrl;
+      const parsed = parsePrFromUrl(prUrl);
+      if (parsed !== void 0) {
+        patch["pr_repo"] = parsed.repo;
+        patch["pr_number"] = parsed.prNumber;
+      }
+    }
+  }
+  if (Object.keys(patch).length === 0) {
+    return {
+      payload,
+      enriched: false,
+      usedSessionBaselineDelta
+    };
+  }
+  return {
+    payload: {
+      ...payload,
+      ...patch
+    },
+    enriched: true,
+    usedSessionBaselineDelta
+  };
+}
+function toEnvelope(payload, privacyTier, now, extraAttributes = {}) {
+  const promptId = pickPromptId2(payload);
+  const eventType = pickEventType(payload);
+  const envelope = {
+    schemaVersion: "1.0",
+    source: "hook",
+    sourceVersion: "agent-trace-cli-v0.1",
+    eventId: buildEventId3(payload, now),
+    sessionId: pickSessionId(payload),
+    ...promptId !== void 0 ? { promptId } : {},
+    eventType,
+    eventTimestamp: pickTimestamp(payload, now),
+    ingestedAt: now,
+    privacyTier,
+    payload,
+    attributes: {
+      hook_name: eventType,
+      ...extraAttributes
+    }
+  };
+  return envelope;
+}
+function validateEnvelope(envelope) {
+  const errors = [];
+  if (envelope.schemaVersion !== "1.0") {
+    errors.push("schemaVersion must equal 1.0");
+  }
+  if (envelope.source !== "hook") {
+    errors.push("source must equal hook");
+  }
+  if (envelope.eventId.length === 0) {
+    errors.push("eventId must be non-empty");
+  }
+  if (envelope.sessionId.length === 0) {
+    errors.push("sessionId must be non-empty");
+  }
+  if (envelope.eventType.length === 0) {
+    errors.push("eventType must be non-empty");
+  }
+  if (!isIsoDate2(envelope.eventTimestamp)) {
+    errors.push("eventTimestamp must be ISO-8601");
+  }
+  if (!isIsoDate2(envelope.ingestedAt)) {
+    errors.push("ingestedAt must be ISO-8601");
+  }
+  if (envelope.privacyTier !== 1 && envelope.privacyTier !== 2 && envelope.privacyTier !== 3) {
+    errors.push("privacyTier must be 1, 2, or 3");
+  }
+  return errors;
+}
+function runHookHandler(input, store = new FileCliConfigStore(), gitContextProvider = new ShellHookGitContextProvider()) {
+  let payload;
+  try {
+    payload = parseHookPayload(input.rawStdin);
+  } catch {
+    return {
+      ok: false,
+      errors: ["hook payload is not valid JSON"]
+    };
+  }
+  if (payload === void 0) {
+    return {
+      ok: false,
+      errors: ["hook payload is empty or invalid"]
+    };
+  }
+  const now = input.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const privacyTier = getPrivacyTier(store, input.configDir);
+  const baselineStore = new FileHookSessionBaselineStore(store, input.configDir);
+  const enrichment = enrichHookPayloadWithGitContext(payload, gitContextProvider, baselineStore, now);
+  const envelope = toEnvelope(enrichment.payload, privacyTier, now, {
+    ...enrichment.enriched ? { git_enriched: "1" } : {},
+    ...enrichment.usedSessionBaselineDelta ? { git_session_delta: "1" } : {}
+  });
+  const errors = validateEnvelope(envelope);
+  if (errors.length > 0) {
+    return {
+      ok: false,
+      errors
+    };
+  }
+  return {
+    ok: true,
+    envelope
+  };
+}
+var FetchCollectorHttpClient = class {
+  async postJson(url, payload) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      const body = await response.text();
+      return {
+        ok: true,
+        statusCode: response.status,
+        body
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        statusCode: 0,
+        body: "",
+        error: String(error)
+      };
+    }
+  }
+};
+function isSuccessStatus(statusCode) {
+  return statusCode >= 200 && statusCode < 300;
+}
+async function runHookHandlerAndForward(input, client = new FetchCollectorHttpClient(), store = new FileCliConfigStore(), gitContextProvider = new ShellHookGitContextProvider()) {
+  const hookResult = runHookHandler(
+    {
+      rawStdin: input.rawStdin,
+      ...input.configDir !== void 0 ? { configDir: input.configDir } : {},
+      ...input.nowIso !== void 0 ? { nowIso: input.nowIso } : {}
+    },
+    store,
+    gitContextProvider
+  );
+  if (!hookResult.ok) {
+    return {
+      ok: false,
+      errors: hookResult.errors
+    };
+  }
+  const collectorUrl = getCollectorUrl(store, input.configDir, input.collectorUrl);
+  const postResult = await client.postJson(collectorUrl, hookResult.envelope);
+  if (!postResult.ok) {
+    return {
+      ok: false,
+      envelope: hookResult.envelope,
+      errors: [postResult.error ?? "failed to send hook event to collector"]
+    };
+  }
+  if (!isSuccessStatus(postResult.statusCode)) {
+    return {
+      ok: false,
+      envelope: hookResult.envelope,
+      statusCode: postResult.statusCode,
+      errors: [
+        `collector returned status ${String(postResult.statusCode)}`,
+        ...postResult.body.length > 0 ? [postResult.body] : []
+      ]
+    };
+  }
+  return {
+    ok: true,
+    envelope: hookResult.envelope,
+    collectorUrl,
+    statusCode: postResult.statusCode,
+    body: postResult.body
+  };
+}
+
 // packages/runtime/src/standalone-entry.ts
 function readNumberEnv(name, fallback) {
   const raw = process.env[name];
@@ -4358,11 +5478,77 @@ function readPrivacyTierEnv(name) {
   return 2;
 }
 function resolveDefaultSqlitePath() {
-  const dataDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".agent-trace");
-  import_node_fs2.default.mkdirSync(dataDir, { recursive: true });
-  return import_node_path3.default.join(dataDir, "data.db");
+  const dataDir = import_node_path5.default.join(import_node_os3.default.homedir(), ".agent-trace");
+  import_node_fs5.default.mkdirSync(dataDir, { recursive: true });
+  return import_node_path5.default.join(dataDir, "data.db");
 }
-async function main() {
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    process.stdin.on("end", () => resolve(buffer));
+    process.stdin.on("error", (error) => reject(error));
+  });
+}
+function printUsage() {
+  process.stdout.write(
+    "\nusage: agent-trace <command>\n\ncommands:\n  (none)        start the server (collector + api + dashboard)\n  init          configure Claude Code hooks\n  status        check if hooks are installed\n  hook-handler  process a hook event from stdin\n\noptions:\n  --collector-url <url>    collector endpoint (default: http://127.0.0.1:8317/v1/hooks)\n  --privacy-tier <1|2|3>   privacy tier (default: 2)\n  --install-hooks          install hooks into Claude settings (default for init)\n  --no-install-hooks       skip hook installation\n  --forward                forward hook event to collector (hook-handler)\n  --config-dir <path>      config directory (default: ~/.claude)\n\n"
+  );
+}
+async function handleCliCommand(args) {
+  const command = args.command;
+  if (command === "init") {
+    const result2 = runInit({
+      ...args.configDir !== void 0 ? { configDir: args.configDir } : {},
+      ...args.collectorUrl !== void 0 ? { collectorUrl: args.collectorUrl } : {},
+      ...args.privacyTier !== void 0 ? { privacyTier: args.privacyTier } : {},
+      ...args.installHooks !== void 0 ? { installHooks: args.installHooks } : {}
+    });
+    process.stdout.write(`${JSON.stringify(result2, null, 2)}
+`);
+    return;
+  }
+  if (command === "status") {
+    const result2 = runStatus(args.configDir);
+    process.stdout.write(`${JSON.stringify(result2, null, 2)}
+`);
+    process.exitCode = result2.ok ? 0 : 1;
+    return;
+  }
+  const rawStdin = await readStdin();
+  if (args.forward === true) {
+    const result2 = await runHookHandlerAndForward({
+      rawStdin,
+      ...args.configDir !== void 0 ? { configDir: args.configDir } : {},
+      ...args.collectorUrl !== void 0 ? { collectorUrl: args.collectorUrl } : {}
+    });
+    if (!result2.ok) {
+      process.stderr.write(`${JSON.stringify(result2, null, 2)}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(`${JSON.stringify(result2, null, 2)}
+`);
+    return;
+  }
+  const result = runHookHandler({
+    rawStdin,
+    ...args.configDir !== void 0 ? { configDir: args.configDir } : {}
+  });
+  if (!result.ok) {
+    process.stderr.write(`${JSON.stringify(result, null, 2)}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result.envelope, null, 2)}
+`);
+}
+async function startServer() {
   const host = process.env["RUNTIME_HOST"] ?? "127.0.0.1";
   const collectorPort = readNumberEnv("COLLECTOR_PORT", 8317);
   const apiPort = readNumberEnv("API_PORT", 8318);
@@ -4455,6 +5641,19 @@ async function main() {
     void shutdown();
   });
 }
+async function main() {
+  const args = parseArgs(process.argv);
+  const command = args.command;
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    printUsage();
+    return;
+  }
+  if (command === "init" || command === "status" || command === "hook-handler") {
+    await handleCliCommand(args);
+    return;
+  }
+  await startServer();
+}
 void main().catch((error) => {
   process.stderr.write(`${String(error)}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-trace",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Self-hosted observability for AI coding agents. One command, zero config.",
   "license": "Apache-2.0",
   "bin": {