claude-finops 0.17.1 → 0.18.1

package/README.md

@@ -135,7 +135,6 @@ rather than guessing:
 - Plan tier, allowance, and remaining credits
 - Message / request allowances
 - Billed invoice amounts
-- Assistant response text (only usage metadata is extracted)
 - Lines changed, commits, pull requests, bugs fixed
 
 Wherever one of these would appear, you get **"Unavailable from connected Claude
@@ -387,7 +386,11 @@ if the Claude desktop app is installed, its Cowork transcripts and
 server binds to `127.0.0.1` only, but treat the database and any export you
 generate as sensitive.
 
-**Hide prompts** (the eye icon in the top bar) hides prompt text and session titles as dots,
+Claude's replies are **not** stored in the database. A prompt's detail panel reads the reply
+straight from that session's transcript in `~/.claude/projects` when you open it, and says so
+if the transcript has been deleted.
+
+**Hide prompts** (the eye icon in the top bar) hides prompt text, Claude's replies and session titles as dots,
 for when you share your screen. Session titles fall back to their short id. The
 setting is remembered in that browser. The side panel has the same button, and using it there
 keeps the panel open. It only changes what the page shows: the

package/finops/analytics.py

@@ -818,6 +818,28 @@ class Analytics:
             p["category_evidence"] = []
         return p
 
+    def prompt_reply(self, pid):
+        """Claude's reply to one prompt, read from the transcript when asked for."""
+        from . import guard as G
+        from .etl import DEFAULT_SOURCE, reply_from_transcript
+        p = self.one("SELECT pr.uuid, pr.session_id, s.source_file FROM prompts pr"
+                     " LEFT JOIN sessions s ON s.id=pr.session_id WHERE pr.id=?", (pid,))
+        if not p:
+            return {"error": "not found"}
+        path = p["source_file"]
+        if not path or not os.path.exists(path):
+            path = G.find_transcript(p["session_id"],
+                                     [os.environ.get("CLAUDE_PROJECTS") or DEFAULT_SOURCE])
+        if not p["uuid"] or not path:
+            return {"ok": False, "reason": "The transcript for this session is no longer on disk."}
+        try:
+            r = reply_from_transcript(path, p["uuid"])
+        except OSError:
+            return {"ok": False, "reason": "The transcript could not be read."}
+        if not r["found"]:
+            return {"ok": False, "reason": "This prompt was not found in its transcript."}
+        return {"ok": True, **r}
+
     def session_detail(self, sid, f=None):
         s = self.one("""SELECT s.*, pr.name project FROM sessions s
                         JOIN projects pr ON pr.id=s.project_id WHERE s.id=?""", (sid,))

package/finops/api.py

@@ -611,6 +611,13 @@ class Handler(BaseHTTPRequestHandler):
                 raise BadRequest("id must be an integer")
             d = a.prompt_detail(pid, f)
             return self.send_json(d, 404 if isinstance(d, dict) and d.get("error") else 200)
+        if route.startswith("prompt_reply/"):
+            try:
+                pid = int(route.split("/")[1])
+            except ValueError:
+                raise BadRequest("id must be an integer")
+            d = a.prompt_reply(pid)
+            return self.send_json(d, 404 if d.get("error") else 200)
         if route.startswith("session/"):
             d = a.session_detail(route.split("/", 1)[1], f)
             return self.send_json(d, 404 if isinstance(d, dict) and d.get("error") else 200)

package/finops/etl.py

@@ -183,6 +183,43 @@ def _text_of(content):
     return "\n".join(x for x in out if x)
 
 
+def _is_human_prompt(r):
+    """A user line that load_file counts as a prompt (not a tool result, meta or injected text)."""
+    if r.get("type") != "user" or r.get("toolUseResult") is not None or r.get("isMeta"):
+        return False
+    text = _text_of((r.get("message") or {}).get("content"))
+    return bool(text.strip()) and not text.lstrip().startswith(INJECTED_PREFIXES)
+
+
+REPLY_MAX_CHARS = 60_000
+
+
+def reply_from_transcript(path, prompt_uuid):
+    """Claude's text replies to one prompt, read from its transcript on demand (never stored).
+    Returns the text blocks in order, from the prompt up to the next human prompt."""
+    parts, found = [], False
+    with open(path, errors="replace") as fh:
+        for line in fh:
+            if not found and prompt_uuid not in line:
+                continue
+            try:
+                r = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not found:
+                found = r.get("uuid") == prompt_uuid
+                continue
+            if _is_human_prompt(r):
+                break
+            if r.get("type") == "assistant" and not r.get("isSidechain"):
+                text = _text_of((r.get("message") or {}).get("content")).strip()
+                if text:
+                    parts.append(text)
+    text = "\n\n".join(parts)
+    return {"found": found, "parts": len(parts), "text": text[:REPLY_MAX_CHARS],
+            "truncated": len(text) > REPLY_MAX_CHARS}
+
+
 IMAGE_CHARS = 1600 * 4   # an image costs ~1.6K tokens, not its base64 length
 
 

package/finops/procs.py

@@ -71,10 +71,27 @@ def _is_claude(p):
     return base in ("claude", "claude.exe", "claude.cmd") or cmd.endswith("/claude")
 
 
+def _proc_starttime(pid):
+    """Linux: a process's start time in clock ticks since boot (field 22 of /proc/<pid>/stat)."""
+    try:
+        with open(f"/proc/{int(pid)}/stat") as fh:
+            stat = fh.read()
+    except (OSError, TypeError, ValueError):
+        return None
+    fields = stat[stat.rfind(")") + 2:].split()   # the name in (...) may contain spaces
+    return fields[19] if len(fields) > 19 else None
+
+
 def _same_start(reg, p):
     """True unless the registry's procStart names a different start time than ps reports.
-    Whitespace is normalised: the registry pads single-digit days ("Oct  9"), ps output is re-joined ("Oct 9")."""
-    return not reg.get("procStart") or reg["procStart"].split() == p["lstart"].split()
+    Whitespace is normalised: the registry pads single-digit days ("Oct  9"), ps output is re-joined ("Oct 9").
+    On Linux, Claude Code records clock ticks since boot ("119623") instead, read from /proc."""
+    start = reg.get("procStart")
+    if not start:
+        return True
+    if start.strip().isdigit():
+        return _proc_starttime(reg.get("pid")) == start.strip()
+    return start.split() == p["lstart"].split()
 
 
 def _ancestors(pid, procs):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-finops",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "description": "Local FinOps dashboard for Claude Code: what you used, what it cost, why it cost that much, and what to change. Reads your own transcripts, no API key, no data leaves the machine.",
   "bin": {
     "claude-finops": "bin/claude-finops.js"

package/web/app.js

@@ -608,6 +608,8 @@ async function openPrompt(id) {
         <span>${fmtInt(p.char_len)} chars · ${fmtInt(p.word_len)} words</span>
         ${p.source ? `<span class="pill">${esc(p.source)}</span>` : ''}
       </div>`, {badge: BADGE.actual})}
+    ${card('Claude\'s response', '<div id="pr-reply"><div class="note">Reading the transcript…</div></div>',
+      {badge: BADGE.actual, hint: 'read from the transcript when you open this; not stored'})}
     ${card('Requests in this turn', table([
       {h: 'Time', f: r => `<span class="mono">${esc((r.ts||'').slice(11,19))}</span>`},
       {h: 'Model', f: r => `<span class="swatch" style="background:${modelColor(r.model)}"></span>${esc(modelName(r.model))}`},
@@ -638,10 +640,22 @@ async function openPrompt(id) {
       <dt>Models</dt><dd>${esc(p.models || '—')}</dd>
       <dt>Tool calls</dt><dd>${fmtInt(p.tool_calls)}</dd>
       <dt>Avg latency</dt><dd>${p.latency_ms ? (p.latency_ms/1000).toFixed(1)+'s' : NA()}</dd>
-      <dt>Response text</dt><dd>${NA()} — transcripts are parsed for usage metadata, not stored replies</dd>
     </dl>`)}`;
   const link = d.querySelector('[data-sess]');
   if (link) link.onclick = () => openSession(link.dataset.sess);
+  drawReply(d.querySelector('#pr-reply'), id);
+}
+
+async function drawReply(box, id) {
+  let r;
+  try { r = await fetch(`/api/prompt_reply/${id}`).then(x => x.json()); }
+  catch (e) { r = {ok: false, reason: e.message}; }
+  if (!box.isConnected) return;   // drawer closed or replaced while reading
+  if (!r.ok) { box.innerHTML = `<div class="na">${esc(r.reason || r.error || 'Could not read the reply.')}</div>`; return; }
+  box.innerHTML = r.text
+    ? `<div class="prompt-text">${esc(pt(r.text))}</div>${r.truncated
+      ? '<div class="note" style="margin-top:6px">Long reply: only the first part is shown.</div>' : ''}`
+    : '<div class="na">No text reply: Claude only ran tools for this prompt.</div>';
 }
 
 async function openSession(id) {