agent-trace 0.2.5 → 0.2.7

package/agent-trace.cjs

@@ -24988,7 +24988,7 @@ async function startDashboardServer(options = {}) {
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS agent_events (
-  event_id TEXT NOT NULL,
+  event_id TEXT NOT NULL UNIQUE,
   event_type TEXT NOT NULL,
   event_timestamp TEXT NOT NULL,
   session_id TEXT NOT NULL,
@@ -25100,7 +25100,9 @@ var SqliteClient = class {
     this.db = new import_better_sqlite3.default(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
+    this.migrateDeduplicateEvents();
     this.db.exec(SCHEMA_SQL);
+    this.migrateRebuildBrokenTraces();
   }
   async insertJsonEachRow(request) {
     if (request.rows.length === 0) return;
@@ -25319,9 +25321,181 @@ var SqliteClient = class {
   close() {
     this.db.close();
   }
+  /**
+   * Migration: deduplicate agent_events rows from older schemas that lacked a UNIQUE constraint.
+   * Runs once — if the old table exists without a unique index, it rebuilds it.
+   */
+  migrateDeduplicateEvents() {
+    const tableExists = this.db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='agent_events'"
+    ).get();
+    if (tableExists === void 0) {
+      return;
+    }
+    const hasUniqueIndex = this.db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='index' AND tbl_name='agent_events' AND sql LIKE '%UNIQUE%'"
+    ).get();
+    const indexInfo = this.db.prepare("PRAGMA index_list('agent_events')").all();
+    const hasAutoUnique = indexInfo.some((idx) => idx["unique"] === 1);
+    if (hasUniqueIndex !== void 0 || hasAutoUnique) {
+      return;
+    }
+    const countResult = this.db.prepare(
+      "SELECT COUNT(*) as total FROM agent_events"
+    ).get();
+    const distinctResult = this.db.prepare(
+      "SELECT COUNT(DISTINCT event_id) as distinct_count FROM agent_events"
+    ).get();
+    const total = countResult?.total ?? 0;
+    const distinct = distinctResult?.distinct_count ?? 0;
+    if (total === 0) {
+      this.db.exec("DROP TABLE agent_events");
+      const tracesExist = this.db.prepare(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_traces'"
+      ).get();
+      if (tracesExist !== void 0) {
+        this.db.exec("DELETE FROM session_traces");
+      }
+      return;
+    }
+    console.log(`[agent-trace] migrating: deduplicating agent_events (${total} rows \u2192 ${distinct} distinct)`);
+    this.db.exec(`
+      CREATE TABLE agent_events_dedup (
+        event_id TEXT NOT NULL UNIQUE,
+        event_type TEXT NOT NULL,
+        event_timestamp TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        prompt_id TEXT,
+        user_id TEXT NOT NULL DEFAULT 'unknown_user',
+        source TEXT NOT NULL DEFAULT 'hook',
+        agent_type TEXT NOT NULL DEFAULT 'claude_code',
+        tool_name TEXT,
+        tool_success INTEGER,
+        tool_duration_ms REAL,
+        model TEXT,
+        cost_usd REAL,
+        input_tokens INTEGER,
+        output_tokens INTEGER,
+        api_duration_ms REAL,
+        lines_added INTEGER,
+        lines_removed INTEGER,
+        files_changed TEXT NOT NULL DEFAULT '[]',
+        commit_sha TEXT,
+        attributes TEXT NOT NULL DEFAULT '{}'
+      );
+
+      INSERT OR IGNORE INTO agent_events_dedup SELECT * FROM agent_events;
+
+      DROP TABLE agent_events;
+      ALTER TABLE agent_events_dedup RENAME TO agent_events;
+
+      CREATE INDEX IF NOT EXISTS idx_events_session ON agent_events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON agent_events(event_timestamp);
+    `);
+    const afterCount = this.db.prepare("SELECT COUNT(*) as c FROM agent_events").get();
+    console.log(`[agent-trace] migration complete: ${afterCount.c} events after dedup (removed ${total - afterCount.c} duplicates)`);
+    this.rebuildSessionTracesFromEvents();
+  }
+  /**
+   * Migration v2: fix databases that ran v0.2.6's broken rebuild (models_used='[]' with data present).
+   * Re-runs the rebuild if session_traces exist but have empty models_used while events have model data.
+   */
+  migrateRebuildBrokenTraces() {
+    const tracesExist = this.db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_traces'"
+    ).get();
+    if (tracesExist === void 0) {
+      return;
+    }
+    const broken = this.db.prepare(`
+      SELECT 1 FROM session_traces st
+      WHERE st.models_used = '[]'
+        AND EXISTS (
+          SELECT 1 FROM agent_events ae
+          WHERE ae.session_id = st.session_id AND ae.model IS NOT NULL
+        )
+      LIMIT 1
+    `).get();
+    if (broken === void 0) {
+      return;
+    }
+    console.log("[agent-trace] migrating: rebuilding session traces with correct models/tools");
+    this.rebuildSessionTracesFromEvents();
+  }
+  /**
+   * Rebuild session_traces by aggregating deduplicated agent_events.
+   * Called after dedup migration so the dashboard has correct metrics immediately.
+   */
+  rebuildSessionTracesFromEvents() {
+    const tracesExist = this.db.prepare(
+      "SELECT 1 FROM sqlite_master WHERE type='table' AND name='session_traces'"
+    ).get();
+    if (tracesExist === void 0) {
+      return;
+    }
+    this.db.exec("DELETE FROM session_traces");
+    this.db.exec(`
+      INSERT OR REPLACE INTO session_traces
+        (session_id, version, started_at, ended_at, user_id, git_repo, git_branch,
+         prompt_count, tool_call_count, api_call_count, total_cost_usd,
+         total_input_tokens, total_output_tokens, lines_added, lines_removed,
+         models_used, tools_used, files_touched, commit_count, updated_at)
+      SELECT
+        session_id,
+        1,
+        MIN(event_timestamp),
+        MAX(event_timestamp),
+        COALESCE(MAX(CASE WHEN user_id != 'unknown_user' THEN user_id END), 'unknown_user'),
+        NULL,
+        NULL,
+        SUM(CASE WHEN event_type LIKE '%prompt%' THEN 1 ELSE 0 END),
+        SUM(CASE WHEN event_type LIKE '%tool%' THEN 1 ELSE 0 END),
+        SUM(CASE WHEN event_type LIKE '%api%' THEN 1 ELSE 0 END),
+        COALESCE(SUM(cost_usd), 0),
+        COALESCE(SUM(input_tokens), 0),
+        COALESCE(SUM(output_tokens), 0),
+        COALESCE(SUM(lines_added), 0),
+        COALESCE(SUM(lines_removed), 0),
+        '[]',
+        '[]',
+        '[]',
+        COUNT(DISTINCT commit_sha),
+        MAX(event_timestamp)
+      FROM agent_events
+      GROUP BY session_id
+    `);
+    const sessionIds = this.db.prepare(
+      "SELECT DISTINCT session_id FROM agent_events"
+    ).all();
+    const updateArrays = this.db.prepare(
+      "UPDATE session_traces SET models_used = ?, tools_used = ?, files_touched = ? WHERE session_id = ?"
+    );
+    const transaction = this.db.transaction((ids) => {
+      for (const { session_id } of ids) {
+        const models = this.db.prepare(
+          "SELECT DISTINCT model FROM agent_events WHERE session_id = ? AND model IS NOT NULL"
+        ).all(session_id);
+        const tools = this.db.prepare(
+          "SELECT DISTINCT tool_name FROM agent_events WHERE session_id = ? AND tool_name IS NOT NULL"
+        ).all(session_id);
+        const files = this.db.prepare(
+          "SELECT DISTINCT commit_sha FROM agent_events WHERE session_id = ? AND commit_sha IS NOT NULL"
+        ).all(session_id);
+        updateArrays.run(
+          JSON.stringify(models.map((r) => r.model)),
+          JSON.stringify(tools.map((r) => r.tool_name)),
+          JSON.stringify(files.map((r) => r.commit_sha)),
+          session_id
+        );
+      }
+    });
+    transaction(sessionIds);
+    const rebuilt = this.db.prepare("SELECT COUNT(*) as c FROM session_traces").get();
+    console.log(`[agent-trace] rebuilt ${rebuilt.c} session traces from deduplicated events`);
+  }
   insertEvents(rows) {
     const insert = this.db.prepare(`
-      INSERT INTO agent_events
+      INSERT OR IGNORE INTO agent_events
         (event_id, event_type, event_timestamp, session_id, prompt_id, user_id, source, agent_type,
          tool_name, tool_success, tool_duration_ms, model, cost_usd, input_tokens, output_tokens,
          api_duration_ms, lines_added, lines_removed, files_changed, commit_sha, attributes)
@@ -28368,11 +28542,23 @@ async function close2(server) {
     });
   });
 }
+function enrichEnvelopeWithCost(event) {
+  const payload = event.payload;
+  if (typeof payload["cost_usd"] === "number" && payload["cost_usd"] > 0) {
+    return event;
+  }
+  const cost = computeEventCost(payload);
+  if (cost === void 0 || cost <= 0) {
+    return event;
+  }
+  return { ...event, payload: { ...payload, cost_usd: cost } };
+}
 async function projectAndPersistEvent(event, sessionRepository, persistence) {
   const current = sessionRepository.getBySessionId(event.sessionId);
   const projected = projectEnvelopeToTrace(current, event);
   sessionRepository.upsert(projected);
-  await persistence.persistAcceptedEvent(event, projected);
+  const enriched = enrichEnvelopeWithCost(event);
+  await persistence.persistAcceptedEvent(enriched, projected);
 }
 function createRuntimeOtelSink(runtime) {
   return runtime.collectorService.otelSink;

package/package.json

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