getpatter 0.6.0 → 0.6.1

package/dist/cli.js

@@ -50,6 +50,19 @@ var MetricsStore = class extends import_events.EventEmitter {
   maxCalls;
   calls = [];
   activeCalls = /* @__PURE__ */ new Map();
+  /**
+   * User-driven soft delete: call_ids the operator removed from the
+   * dashboard view. The on-disk artefacts written by ``CallLogger``
+   * (``metadata.json``, ``transcript.jsonl``) are intentionally NOT
+   * touched — they serve as the durable backup. All read paths
+   * (``getCalls`` / ``getCall`` / ``getAggregates`` / ``getCallsInRange``
+   * / ``hydrate``) filter against this set so the call is invisible
+   * to the UI and excluded from rolling metrics. Populated from
+   * ``<logRoot>/.deleted_call_ids.json`` on hydrate so deletions
+   * survive a process restart. Parity with Python.
+   */
+  deletedCallIds = /* @__PURE__ */ new Set();
+  deletedIdsPath = null;
   /**
    * Accepts either a numeric ``maxCalls`` (legacy positional — matches the
    * original TS API) or an options object ``{ maxCalls }`` to align with the
@@ -142,6 +155,8 @@ var MetricsStore = class extends import_events.EventEmitter {
           ended_at: Date.now() / 1e3,
           status,
           metrics: null,
+          ...active.turns && active.turns.length > 0 ? { turns: active.turns } : {},
+          ...active.transcript && active.transcript.length > 0 ? { transcript: active.transcript } : {},
           ...extra
         };
         this.activeCalls.delete(callId);
@@ -170,6 +185,21 @@ var MetricsStore = class extends import_events.EventEmitter {
     if (active) {
       if (!active.turns) active.turns = [];
       active.turns.push(turn);
+      if (!active.transcript) active.transcript = [];
+      const turnRecord = turn;
+      const userText = typeof turnRecord.user_text === "string" ? turnRecord.user_text : "";
+      const agentText = typeof turnRecord.agent_text === "string" ? turnRecord.agent_text : "";
+      const ts = typeof turnRecord.timestamp === "number" ? turnRecord.timestamp : Date.now() / 1e3;
+      if (userText.length > 0) {
+        active.transcript.push({ role: "user", text: userText, timestamp: ts });
+      }
+      if (agentText.length > 0 && agentText !== "[interrupted]") {
+        active.transcript.push({
+          role: "assistant",
+          text: agentText,
+          timestamp: ts
+        });
+      }
     }
     this.publish("turn_complete", { call_id: callId, turn });
   }
@@ -179,40 +209,140 @@ var MetricsStore = class extends import_events.EventEmitter {
     if (!callId) return;
     const active = this.activeCalls.get(callId);
     this.activeCalls.delete(callId);
-    const activeStatus = active?.status;
-    const resolvedStatus = activeStatus && activeStatus !== "in-progress" ? activeStatus : "completed";
+    let existingIdx = -1;
+    if (active === void 0) {
+      for (let i = this.calls.length - 1; i >= 0; i--) {
+        if (this.calls[i].call_id === callId) {
+          existingIdx = i;
+          break;
+        }
+      }
+    }
+    const existing = existingIdx >= 0 ? this.calls[existingIdx] : void 0;
+    const priorStatus = active?.status ?? existing?.status;
+    const resolvedStatus = priorStatus && priorStatus !== "in-progress" ? priorStatus : "completed";
+    const dataTranscript = data.transcript;
+    const resolvedTranscript = dataTranscript && dataTranscript.length > 0 ? dataTranscript : active?.transcript && active.transcript.length > 0 ? active.transcript : existing?.transcript && existing.transcript.length > 0 ? existing.transcript : [];
+    const resolvedTurns = active?.turns && active.turns.length > 0 ? active.turns : existing?.turns && existing.turns.length > 0 ? existing.turns : void 0;
     const entry = {
       call_id: callId,
-      caller: data.caller || active?.caller || "",
-      callee: data.callee || active?.callee || "",
-      direction: active?.direction || data.direction || "inbound",
-      started_at: active?.started_at || 0,
+      caller: data.caller || active?.caller || existing?.caller || "",
+      callee: data.callee || active?.callee || existing?.callee || "",
+      direction: active?.direction || existing?.direction || data.direction || "inbound",
+      started_at: active?.started_at || existing?.started_at || 0,
       ended_at: Date.now() / 1e3,
-      transcript: data.transcript || [],
+      transcript: resolvedTranscript,
+      ...resolvedTurns ? { turns: resolvedTurns } : {},
       status: resolvedStatus,
-      metrics: metrics ?? null
+      metrics: metrics ?? existing?.metrics ?? null
     };
-    this.calls.push(entry);
-    if (this.calls.length > this.maxCalls) {
-      this.calls = this.calls.slice(-this.maxCalls);
+    if (existingIdx >= 0) {
+      this.calls[existingIdx] = entry;
+    } else {
+      this.calls.push(entry);
+      if (this.calls.length > this.maxCalls) {
+        this.calls = this.calls.slice(-this.maxCalls);
+      }
     }
     this.publish("call_end", {
       call_id: callId,
       metrics: entry.metrics ?? null
     });
   }
-  /** Return a window of completed calls in newest-first order. */
+  /**
+   * Return a window of completed calls in newest-first order.
+   *
+   * Soft-deleted call_ids (see ``deleteCalls``) are filtered out so the
+   * dashboard never re-shows a row the user removed. The on-disk
+   * artefacts are intentionally preserved as a backup.
+   */
   getCalls(limit = 50, offset = 0) {
-    const ordered = [...this.calls].reverse();
+    const visible = this.calls.filter((c) => !this.deletedCallIds.has(c.call_id));
+    const ordered = visible.reverse();
     return ordered.slice(offset, offset + limit);
   }
-  /** Look up a completed call by id (newest match wins). */
+  /**
+   * Look up a completed call by id (newest match wins).
+   *
+   * Soft-deleted call_ids resolve to ``null`` so the SPA's detail pane
+   * cannot render a row the user removed.
+   */
   getCall(callId) {
+    if (this.deletedCallIds.has(callId)) return null;
     for (let i = this.calls.length - 1; i >= 0; i--) {
       if (this.calls[i].call_id === callId) return this.calls[i];
     }
     return null;
   }
+  /**
+   * Soft-delete one or more calls from the dashboard view.
+   *
+   * Adds each ``call_id`` to an in-memory set. Subsequent reads via
+   * ``getCalls`` / ``getCall`` / ``getAggregates`` / ``getCallsInRange``
+   * exclude the deleted ids, so rolling metrics (avg latency, total
+   * spend) are recomputed without them. The on-disk
+   * ``metadata.json`` / ``transcript.jsonl`` files written by
+   * ``CallLogger`` are NOT touched — they serve as a durable backup
+   * the operator can audit outside the dashboard.
+   *
+   * Active calls are never deletable. A call_id that is currently
+   * in ``activeCalls`` is silently skipped so a mid-call delete
+   * from the UI cannot orphan the live transcript pane.
+   *
+   * Persisted to ``<logRoot>/.deleted_call_ids.json`` (best-effort)
+   * when ``hydrate()`` has been called with a log root. Parity with
+   * Python ``delete_calls``.
+   *
+   * @returns The list of call_ids actually accepted as deleted.
+   */
+  deleteCalls(callIds) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const cid of callIds || []) {
+      if (typeof cid === "string" && cid && !this.activeCalls.has(cid)) {
+        ids.add(cid);
+      }
+    }
+    if (ids.size === 0) return [];
+    const accepted = [];
+    for (const cid of ids) {
+      if (!this.deletedCallIds.has(cid)) {
+        this.deletedCallIds.add(cid);
+        accepted.push(cid);
+      }
+    }
+    if (accepted.length === 0) return [];
+    accepted.sort();
+    this.persistDeletedIds();
+    this.publish("calls_deleted", { call_ids: accepted });
+    return accepted;
+  }
+  /** Whether ``callId`` was soft-deleted from the dashboard. */
+  isDeleted(callId) {
+    return this.deletedCallIds.has(callId);
+  }
+  /** Snapshot of soft-deleted call_ids (sorted). */
+  getDeletedCallIds() {
+    return Array.from(this.deletedCallIds).sort();
+  }
+  /** Atomically persist the deleted-ids set to disk. Best-effort. */
+  persistDeletedIds() {
+    if (this.deletedIdsPath === null) return;
+    try {
+      const dir = path.dirname(this.deletedIdsPath);
+      fs.mkdirSync(dir, { recursive: true });
+      const tmp = this.deletedIdsPath + ".tmp";
+      const payload = {
+        version: 1,
+        deleted_call_ids: Array.from(this.deletedCallIds).sort()
+      };
+      fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
+      fs.renameSync(tmp, this.deletedIdsPath);
+    } catch (err) {
+      getLogger().debug(
+        `MetricsStore.persistDeletedIds: ${String(err)}`
+      );
+    }
+  }
   /** Look up an active call by id (returns undefined if not active or unknown). */
   getActive(callId) {
     return this.activeCalls.get(callId);
@@ -221,9 +351,17 @@ var MetricsStore = class extends import_events.EventEmitter {
   getActiveCalls() {
     return Array.from(this.activeCalls.values());
   }
-  /** Compute summary statistics across the buffered call history. */
+  /**
+   * Compute summary statistics across the buffered call history.
+   *
+   * Soft-deleted calls are excluded so rolling metrics (avg latency,
+   * total spend) match exactly what the operator sees in the call list.
+   */
   getAggregates() {
-    const totalCalls = this.calls.length;
+    const visible = this.calls.filter(
+      (c) => !this.deletedCallIds.has(c.call_id)
+    );
+    const totalCalls = visible.length;
     if (totalCalls === 0) {
       return {
         total_calls: 0,
@@ -242,7 +380,7 @@ var MetricsStore = class extends import_events.EventEmitter {
     let costTts = 0;
     let costLlm = 0;
     let costTel = 0;
-    for (const call of this.calls) {
+    for (const call of visible) {
       const m = call.metrics;
       if (!m) continue;
       const cost = m.cost || {};
@@ -253,7 +391,7 @@ var MetricsStore = class extends import_events.EventEmitter {
       costTel += cost.telephony || 0;
       totalDuration += m.duration_seconds || 0;
       const avgLat = m.latency_avg || {};
-      const tMs = avgLat.total_ms || 0;
+      const tMs = avgLat.agent_response_ms || avgLat.total_ms || 0;
       if (tMs > 0) {
         totalLatency += tMs;
         latencyCount++;
@@ -273,18 +411,26 @@ var MetricsStore = class extends import_events.EventEmitter {
       active_calls: this.activeCalls.size
     };
   }
-  /** Return calls whose `started_at` falls within `[fromTs, toTs]` (Unix seconds). */
+  /**
+   * Return calls whose `started_at` falls within `[fromTs, toTs]` (Unix
+   * seconds). Soft-deleted calls are filtered out.
+   */
   getCallsInRange(fromTs = 0, toTs = 0) {
     return this.calls.filter((call) => {
+      if (this.deletedCallIds.has(call.call_id)) return false;
       const started = call.started_at || 0;
       if (fromTs && started < fromTs) return false;
       if (toTs && started > toTs) return false;
       return true;
     });
   }
-  /** Number of completed calls currently in the ring buffer. */
+  /** Number of completed (non-deleted) calls currently in the ring buffer. */
   get callCount() {
-    return this.calls.length;
+    let n = 0;
+    for (const c of this.calls) {
+      if (!this.deletedCallIds.has(c.call_id)) n++;
+    }
+    return n;
   }
   /**
    * Rebuild the in-memory call list from `metadata.json` files written by
@@ -298,6 +444,24 @@ var MetricsStore = class extends import_events.EventEmitter {
    */
   hydrate(logRoot) {
     if (!logRoot) return 0;
+    const deletedIdsPath = path.join(logRoot, ".deleted_call_ids.json");
+    this.deletedIdsPath = deletedIdsPath;
+    if (fs.existsSync(deletedIdsPath)) {
+      try {
+        const raw = fs.readFileSync(deletedIdsPath, "utf8");
+        const payload = JSON.parse(raw);
+        const arr = Array.isArray(payload.deleted_call_ids) ? payload.deleted_call_ids : [];
+        for (const cid of arr) {
+          if (typeof cid === "string" && cid.length > 0) {
+            this.deletedCallIds.add(cid);
+          }
+        }
+      } catch (err) {
+        getLogger().debug(
+          `MetricsStore.hydrate: skipping ${deletedIdsPath}: ${String(err)}`
+        );
+      }
+    }
     const callsRoot = path.join(logRoot, "calls");
     if (!fs.existsSync(callsRoot)) return 0;
     const collected = [];
@@ -332,6 +496,12 @@ var MetricsStore = class extends import_events.EventEmitter {
             );
             continue;
           }
+          if (!record.transcript || record.transcript.length === 0) {
+            const fromJsonl = loadTranscriptJsonl(
+              path.join(childPath, "transcript.jsonl")
+            );
+            if (fromJsonl.length > 0) record.transcript = fromJsonl;
+          }
           collected.push(record);
           seen.add(callId);
         } catch (err) {
@@ -353,12 +523,45 @@ var MetricsStore = class extends import_events.EventEmitter {
     return collected.length;
   }
 };
+function metricsFromTopLevel(meta) {
+  const cost = meta.cost && typeof meta.cost === "object" ? meta.cost : null;
+  const latency = meta.latency && typeof meta.latency === "object" ? meta.latency : null;
+  const durationMs = meta.duration_ms;
+  const telephony = meta.telephony_provider;
+  if (cost === null && latency === null && durationMs == null && !telephony) {
+    return null;
+  }
+  const out = {};
+  if (cost !== null) out.cost = cost;
+  if (latency !== null) {
+    const fullAvg = latency.avg && typeof latency.avg === "object" ? latency.avg : null;
+    const fullP50 = latency.p50 && typeof latency.p50 === "object" ? latency.p50 : null;
+    const fullP95 = latency.p95 && typeof latency.p95 === "object" ? latency.p95 : null;
+    const fullP99 = latency.p99 && typeof latency.p99 === "object" ? latency.p99 : null;
+    if (fullAvg) out.latency_avg = fullAvg;
+    if (fullP50) out.latency_p50 = fullP50;
+    if (fullP95) out.latency_p95 = fullP95;
+    if (fullP99) out.latency_p99 = fullP99;
+    if (!fullAvg && !fullP50 && !fullP95) {
+      const totalMs = typeof latency.p95_ms === "number" && latency.p95_ms || typeof latency.p50_ms === "number" && latency.p50_ms || 0;
+      out.latency_avg = { total_ms: totalMs };
+    }
+    out.latency = latency;
+  }
+  if (typeof durationMs === "number" && durationMs > 0) {
+    out.duration_seconds = durationMs / 1e3;
+  }
+  if (typeof telephony === "string" && telephony) {
+    out.telephony_provider = telephony;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
 function metadataToCallRecord(callId, meta) {
   const startedAt = parseTimestamp(meta.started_at);
   if (startedAt === null) return null;
   const endedAt = parseTimestamp(meta.ended_at);
   const status = meta.status || "completed";
-  const metrics = meta.metrics && typeof meta.metrics === "object" ? meta.metrics : null;
+  const metrics = meta.metrics && typeof meta.metrics === "object" ? meta.metrics : metricsFromTopLevel(meta);
   const transcript = Array.isArray(meta.transcript) ? meta.transcript : [];
   return {
     call_id: callId,
@@ -372,6 +575,36 @@ function metadataToCallRecord(callId, meta) {
     transcript
   };
 }
+function loadTranscriptJsonl(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const raw = fs.readFileSync(filePath, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const out = [];
+    for (const line of lines) {
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) : NaN;
+      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp * 1e3 : NaN;
+      const timestamp = Number.isFinite(tsIso) ? tsIso : Number.isFinite(tsNumeric) ? tsNumeric : 0;
+      const userText = typeof row.user_text === "string" ? row.user_text : "";
+      const agentText = typeof row.agent_text === "string" ? row.agent_text : "";
+      if (userText.length > 0) {
+        out.push({ role: "user", text: userText, timestamp });
+      }
+      if (agentText.length > 0 && agentText !== "[interrupted]") {
+        out.push({ role: "assistant", text: agentText, timestamp });
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
 function parseTimestamp(raw) {
   if (typeof raw === "number") {
     return Number.isFinite(raw) ? raw : null;
@@ -512,7 +745,8 @@ function mountDashboard(app, store, token = "") {
     res.json(store.getCalls(limit, offset));
   });
   app.get("/api/dashboard/calls/:callId", auth, (req, res) => {
-    const call = store.getCall(String(req.params.callId));
+    const callId = String(req.params.callId);
+    const call = store.getCall(callId) ?? store.getActive(callId);
     if (!call) {
       res.status(404).json({ error: "Not found" });
       return;
@@ -525,6 +759,24 @@ function mountDashboard(app, store, token = "") {
   app.get("/api/dashboard/aggregates", auth, (_req, res) => {
     res.json(store.getAggregates());
   });
+  app.delete("/api/dashboard/calls/:callId", auth, (req, res) => {
+    const callId = String(req.params.callId);
+    const accepted = store.deleteCalls([callId]);
+    res.json({ deleted: accepted, count: accepted.length });
+  });
+  app.post("/api/dashboard/calls/delete", auth, (req, res) => {
+    const body = req.body ?? {};
+    const raw = body.call_ids;
+    if (!Array.isArray(raw)) {
+      res.status(400).json({ error: "Expected JSON body { 'call_ids': [...] }" });
+      return;
+    }
+    const ids = raw.filter(
+      (cid) => typeof cid === "string" && cid.length > 0
+    );
+    const accepted = store.deleteCalls(ids);
+    res.json({ deleted: accepted, count: accepted.length });
+  });
   app.get("/api/dashboard/events", auth, (req, res) => {
     res.writeHead(200, {
       "Content-Type": "text/event-stream",
@@ -597,7 +849,8 @@ function mountApi(app, store, token = "") {
     res.json({ data: active, count: active.length });
   });
   app.get("/api/v1/calls/:callId", auth, (req, res) => {
-    const call = store.getCall(String(req.params.callId));
+    const callId = String(req.params.callId);
+    const call = store.getCall(callId) ?? store.getActive(callId);
     if (!call) {
       res.status(404).json({ error: "Call not found" });
       return;