prism-cc 0.1.0__tar.gz

prism_cc-0.1.0/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"fef4c8d5-b00e-4586-a17a-74703c2046fd","pid":12596,"acquiredAt":1776051214766}

prism_cc-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/
+venv/
+env/
+.env
+*.whl
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+*.log

prism_cc-0.1.0/CLAUDE.md

@@ -0,0 +1,23 @@
+# PRISM
+
+Python CLI tool. Session intelligence for Claude Code.
+
+## Commands
+- Run tests: `pytest`
+- Install dev: `pip install -e ".[dev]"` or `uv sync --dev`
+- Run locally: `python -m prism` or `prism` after install
+
+## Structure
+- `prism/parser.py` — all JSONL parsing logic, no analysis here
+- `prism/analyzer.py` — all metrics calculation, no I/O here
+- `prism/advisor.py` — recommendation generation, reads analyzer output
+- `prism/app.py` — Textual TUI, imports widgets from prism/widgets/
+- `prism/cli.py` — Typer CLI, thin layer that calls analyzer/advisor/app
+
+## Rules
+- Never mix parsing and analysis — parser returns raw records, analyzer computes metrics
+- Never hardcode `~/.claude` path — use `Path.home() / ".claude"` and make it configurable
+- Always handle malformed JSONL gracefully — skip bad lines, never crash
+- Use `Path` objects throughout, never string concatenation for paths
+- Textual widgets must not import from cli.py — no circular deps
+- Run `pytest` before marking any task done

prism_cc-0.1.0/LAUNCH.md

@@ -0,0 +1,160 @@
+# PRISM Launch Checklist + Post Copy
+
+---
+
+## Before You Push to GitHub
+
+- [ ] Replace YOUR_USERNAME with `jakeefr` in pyproject.toml
+- [ ] Add MIT LICENSE file
+- [ ] Record demo GIF with vhs (demo.tape) and add to README
+- [ ] Set GitHub repo description: "Session intelligence for Claude Code — find why your sessions fail and fix them"
+- [ ] Add GitHub topics: `claude-code`, `claude`, `developer-tools`, `cli`, `tui`, `python`, `textual`
+- [ ] Publish to PyPI: `uv build && uv publish` (needs PyPI account + token)
+- [ ] Verify `pip install prism-cc` works from a clean environment
+- [ ] Star your own repo (baseline social proof)
+
+---
+
+## GitHub Repo Settings
+
+**Description:**
+```
+Session intelligence for Claude Code — find why your sessions fail and fix them
+```
+
+**Website:** (leave blank for now, or link to PyPI)
+
+**Topics:**
+```
+claude-code  claude  anthropic  developer-tools  cli  tui  python  textual  terminal
+```
+
+---
+
+## Hacker News Post
+
+**Post at 13:00–15:00 UTC for best timing.**
+
+**Title:**
+```
+PRISM – session intelligence for Claude Code (find why your sessions fail)
+```
+
+**Body:**
+```
+I've been using Claude Code heavily and kept hitting my token limits without understanding why. 
+Turns out the session data is all there in JSONL files — Claude Code writes everything to 
+~/.claude/projects/ — but nothing was reading it to surface patterns.
+
+So I built PRISM. It reads those files and does three things:
+
+1. Health scores across 5 dimensions (token efficiency, tool call patterns, context hygiene, 
+   CLAUDE.md adherence, session continuity)
+2. Diagnoses root causes — not just "you used tokens" but "your 237-line CLAUDE.md is being 
+   re-read on every tool call, that's where 6738% of your session tokens went"
+3. Concrete CLAUDE.md diffs — specific lines to add, remove, or move to subdirectory files
+
+Running it against my own projects found things I never expected: migration file edits in a 
+project with a rule saying never to touch them, retry loops from commands that hung waiting 
+for interactive input, rules that stopped being followed after line 80 because the file 
+got too long.
+
+The CLAUDE.md adherence detection is the part I'm most interested in getting feedback on — 
+it extracts imperative statements from your CLAUDE.md and checks whether session tool calls 
+actually comply. It's not perfect but it caught real violations in my data.
+
+GitHub: https://github.com/jakeefr/prism
+Install: pip install prism-cc
+
+Would love feedback on the adherence detection — it's the hardest part to get right and 
+I'd like to know if it works on other people's setups.
+```
+
+---
+
+## Reddit Post — r/ClaudeAI
+
+**Title:**
+```
+I built a tool that reads your Claude Code session files and tells you exactly 
+why you're burning through tokens — found some wild stuff in my own data
+```
+
+**Body:**
+```
+Been frustrated with hitting Claude Code limits and not knowing where the tokens went. 
+The session data is all there in JSONL files on your machine but nothing was surfacing it usefully.
+
+Built PRISM — runs locally, reads ~/.claude/projects/, no API key needed.
+
+What it found on my machine:
+
+- One session where CLAUDE.md re-reads consumed **6738%** of session tokens. 
+  A 237-line file being re-read on every single tool call.
+- A project where Claude was editing migration files despite a rule saying never to — 
+  rule existed in CLAUDE.md, was being ignored
+- 5 consecutive tool failures in one session that I never noticed until PRISM flagged it
+
+The main things it does:
+- Health scores per project (A–F across 5 dimensions)
+- CLAUDE.md adherence check — are your rules actually being followed?
+- Concrete recommendations: which lines to remove, which to move to subdirectory files
+
+Install: `pip install prism-cc` then just run `prism analyze`
+
+Repo: https://github.com/jakeefr/prism
+
+Curious if anyone else runs it and finds surprising stuff in their own data. 
+The 6738% number genuinely shocked me.
+```
+
+---
+
+## Reddit Post — r/programming
+
+**Title:**
+```
+I built a TUI that analyzes Claude Code's session JSONL files and surfaces 
+why your context window is filling up
+```
+
+**Body:**
+```
+Claude Code writes detailed session logs to ~/.claude/projects/ — every tool call, 
+every message, every compaction boundary. Nobody was reading them to surface useful patterns.
+
+PRISM is a Python/Textual TUI that parses those files and computes:
+
+- CLAUDE.md re-read cost (every tool call re-reads your CLAUDE.md from context top — 
+  a 200-line file × 50 tool calls = 10k tokens just on instructions)
+- Retry loop detection (3+ consecutive identical tool calls)
+- Edit-revert cycles (write to file → write to same file within 3 turns)
+- CLAUDE.md adherence — extracts imperative rules and checks whether session 
+  tool calls comply
+- Compaction loss events and what context disappeared
+
+Real finding: one session showed 6738% CLAUDE.md re-read cost ratio. 
+The file had grown to 237 lines including personality instructions that 
+Claude Code's system prompt already handles.
+
+Stack: Python, Textual (TUI framework), Rich, Typer, watchdog for live mode.
+Tests: 70 passing.
+
+pip install prism-cc / https://github.com/jakeefr/prism
+
+Happy to answer questions about the JSONL format or the adherence detection logic.
+```
+
+---
+
+## Timing
+
+Best window: **Tuesday–Thursday, 13:00–15:00 UTC**
+
+Post HN first. If it gets traction in the first 2 hours (10+ upvotes, a few comments), 
+post Reddit the same day. If HN is slow, post Reddit next day independently.
+
+Be online for 4 hours after posting HN. Answer every technical question in depth. 
+Never deflect. If someone criticizes the adherence detection — agree with the limitation 
+first, then explain what it does catch.
+```

prism_cc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PRISM Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prism_cc-0.1.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: prism-cc
+Version: 0.1.0
+Summary: Session intelligence for Claude Code — find why your sessions fail and fix them
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/prism
+Project-URL: Repository, https://github.com/YOUR_USERNAME/prism
+Project-URL: Issues, https://github.com/YOUR_USERNAME/prism/issues
+License: MIT
+License-File: LICENSE
+Keywords: ai,claude,claude-code,developer-tools,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: rich>=14.0.0
+Requires-Dist: textual>=0.80.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: watchdog>=4.0.0
+Description-Content-Type: text/markdown
+
+# PRISM
+
+**Session intelligence for Claude Code. Find out why your sessions are burning tokens — and fix them.**
+
+[![PyPI version](https://img.shields.io/pypi/v/prism-cc.svg)](https://pypi.org/project/prism-cc/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![Tests](https://img.shields.io/github/actions/workflow/status/jakeefr/prism/tests.yml?label=tests)](https://github.com/jakeefr/prism/actions)
+
+![PRISM demo](demo.gif)
+
+```bash
+pip install prism-cc
+```
+
+---
+
+## The problem
+
+Your Claude Code sessions are silently wasting tokens and you don't know why.
+
+Running PRISM against real session data from a single machine found:
+
+- A project with **6738% CLAUDE.md re-read cost** in one session — a 237-line file being re-read on every tool call
+- A project where **CLAUDE.md re-reads consumed 480% of total session tokens** — more tokens on instructions than on actual work
+- **4 migration file edits** in a project that had a rule saying never to touch them — the rule existed, Claude ignored it
+- **5 consecutive tool failures** in a single session with no diagnosis
+
+None of this was visible before PRISM. The token counter just said you hit your limit.
+
+---
+
+## What PRISM does
+
+PRISM reads Claude Code's session files from `~/.claude/projects/` — the same files Claude Code writes automatically — and tells you three things:
+
+1. **Why your tokens are disappearing** — CLAUDE.md re-read costs, retry loops, compaction losses, sidechain waste
+2. **Whether your CLAUDE.md rules are actually being followed** — or silently ignored mid-session
+3. **Exactly what to change** — concrete diff recommendations, not generic advice
+
+You keep using Claude Code exactly as normal. PRISM is the tool you run after.
+
+---
+
+## Quick start
+
+```bash
+# Install
+pip install prism-cc
+
+# Analyze all your Claude Code projects
+prism analyze
+
+# Get specific CLAUDE.md fix recommendations
+prism advise
+
+# Open the full interactive dashboard
+prism
+
+# Watch a session live as it runs
+prism watch
+```
+
+---
+
+## What you'll see
+
+```
+ Project                   Overall   Token Eff.  Tool Health  Ctx Hygiene  MD Adherence  Continuity
+ D//jarvis/space            C+        D           B+           D            C             A
+ D//winaborator/ai          C         F           A            B            B+            A-
+ D//tcgintel/project        C+        C+          D            B            C+            B
+ D//bounty                  C+        D+          B            B+           B             A
+ D//prism                   B+        B+          A-           B+           A             A
+```
+
+Followed by the advisor:
+
+```
+╭──────────────────────────────────────────────────────────╮
+│  PRISM ADVISOR — recommendations for jarvis/space        │
+╰──────────────────────────────────────────────────────────╯
+
+  ✦ TRIM  (High impact — silent token drain every session)
+    Remove lines 120–148: personality/tone instructions
+    Claude Code's system prompt already handles this.
+    These 29 lines cost tokens on every single tool call.
+
+  ✦ RESTRUCTURE  (Reduce root-level re-read cost)
+    Move 3 rules to subdirectory CLAUDE.md files:
+    - "Use functional components only in React"
+    - "Import from @/components, never relative paths"
+    - "Run bun run typecheck after TypeScript changes"
+    These only matter in src/ — loading them globally wastes
+    tokens in every session that doesn't touch that directory.
+```
+
+---
+
+## Features
+
+| Dimension | What PRISM measures |
+|---|---|
+| **Token Efficiency** | CLAUDE.md re-read costs, cache hit patterns, compaction frequency |
+| **Tool Health** | Retry loops, edit-revert cycles, consecutive failures, interactive command hangs |
+| **Context Hygiene** | Compaction loss events, mid-task boundaries, sidechain fragmentation |
+| **CLAUDE.md Adherence** | Whether your rules are actually being followed — or ignored mid-session |
+| **Session Continuity** | Resume success rate, context loss on restart, truncated session files |
+
+---
+
+## How it works
+
+```
+You use Claude Code normally
+         ↓
+Claude Code writes session files to ~/.claude/projects/
+         ↓
+PRISM reads and analyzes those files
+         ↓
+Health scores  +  root cause diagnosis  +  CLAUDE.md diff
+```
+
+PRISM never touches Claude Code. It never modifies your sessions. It reads the JSONL files Claude Code already writes and surfaces what's inside them.
+
+---
+
+## The CLAUDE.md re-read problem
+
+Every tool call Claude Code makes re-reads your CLAUDE.md from the top of the context. A 200-line CLAUDE.md × 50 tool calls = 10,000 tokens spent on instructions, per session. If your CLAUDE.md has grown to include personality instructions, full documentation copies, or rules that only apply to one subdirectory — you're paying for all of it every time.
+
+PRISM measures this exactly and tells you which lines are costing you the most.
+
+The "Mr. Tinkleberry test" (from HN, 748 upvotes): put an absurd instruction in your CLAUDE.md. When Claude stops following it mid-session, your file has grown too long and adherence is degrading. PRISM automates this test across all your real sessions.
+
+---
+
+## Commands
+
+```bash
+prism                          # Full interactive TUI dashboard
+prism analyze                  # Rich-formatted health report, then exit
+prism analyze --project ~/myproject   # One project only
+prism analyze --json           # JSON output for scripting
+prism advise                   # CLAUDE.md recommendations
+prism advise --apply           # Write recommendations (with confirmation)
+prism replay <session-id>      # Scrub through a session timeline
+prism watch                    # Live dashboard for the running session
+prism projects                 # List all projects with session counts
+```
+
+---
+
+## Install
+
+```bash
+# pip
+pip install prism-cc
+
+# pipx (recommended — isolated install)
+pipx install prism-cc
+
+# from source
+git clone https://github.com/jakeefr/prism
+cd prism
+pip install -e .
+```
+
+Requires Python 3.11+. No Claude API key needed — reads local files only. Works on macOS and Linux. Windows support via WSL.
+
+---
+
+## Contributing
+
+Issues and PRs welcome. If you run `prism analyze` and find something interesting in your own session data, open an issue — real-world patterns help improve the detection logic.
+
+```bash
+git clone https://github.com/jakeefr/prism
+cd prism
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## License
+
+MIT — do whatever you want with it.
+
+---
+
+*PRISM doesn't send anything anywhere. All analysis runs locally against files already on your machine.*