Meow Operations
merak3i/meow-ops
Analytics e observabilidade local para sessões de IA com Pomodoro e gato 3D
Ver no GitHubDashboard de observabilidade local-first para sessões de Claude Code e ferramentas de coding com IA. Converte arquivos JSONL de sessão em gráficos de custo, uso de tokens, timeline de agentes e um acompanhante gato gamificado. Roda 100% local sem telemetria.
Instalação
npx convez-ai merak3i/meow-ops1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Monitorar custos de tokens em sessões Claude Code
- Analisar padrões de uso de ferramentas e modelos IA
- Rastrear foco e produtividade com timer Pomodoro gamificado
Veredito

Ferramenta niche mas bem executada para desenvolvedores que vivem em ferramentas de coding com IA. O foco em observabilidade local, sem contas ou telemetria, é diferencial legítimo. Interface gamificada com gato 3D é charme sem sacrificar funcionalidade.
README
A tradução para o português deste README ainda está na fila.
🐾 Meow Operations
Local-first AI observability for people who live inside agentic coding tools.
Meow Operations turns local Claude Code, OpenAI Codex Desktop, Aider, Cursor, and Google Antigravity session logs into an installable PWA. It shows token spend, model mix, tool usage, source comparison, session quality, live agent timelines, Loom Ops for loop-based workflows, a Pomodoro focus timer, and a living 3D cat companion. No accounts. No telemetry. MIT-licensed.
Screenshots
Install — 2 minutes, zero accounts
Prerequisites
- Node.js 18+ — check with
node --version - npm (comes with Node) or pnpm
- Claude Code installed and used at least once (your sessions live in
~/.claude/projects/)
Download and run
git clone https://github.com/merak3i/meow-ops.git
cd meow-ops
npm install
node sync/export-local.mjs # parses ~/.claude/projects → public/data/sessions.json
npm run dev # opens http://localhost:5173
That's it. Your real session data loads on first page hit.
First-time setup
- Open
http://localhost:5173in Chrome - The dashboard loads your parsed local sessions immediately
- Codex Desktop sessions are read from
~/.codex/sessions/automatically when present - To add Aider sessions:
AIDER_PROJECTS=/path/to/your/project node sync/export-local.mjs - To add Cursor sessions:
CURSOR_LOGS_DIR=~/.cursor/logs node sync/export-local.mjs - Re-run the sync command any time after new AI sessions to refresh
By default, the export keeps the latest 1000 sessions so the browser stays fast. Raise the cap with:
MEOW_MAX_SESSIONS=2000 node sync/export-local.mjs
Install as a PWA (dock-installable)
Run locally, then in Chrome: address bar → install icon (⊕) → the dashboard installs to your dock or desktop. Works offline via service worker.
For remote access from any device (phone, iPad, second machine), see the Deploy section below.
The Problem Nobody Talks About
Developers using AI tools — Claude, GPT-4o, Gemini, Codex, Cursor, Aider — spend hundreds of dollars a month on tokens with almost no visibility into what they got for it. Not cost-per-model. Not which project burns the most. Not whether a session actually shipped something or just spun its wheels.
As workflows get more layered, it also gets harder to see what is verified, what is assumed, and what still needs review.
The tools that do exist count tokens. None of them:
- Tell you what those tokens produced
- Work across multiple AI models in one view
- Let you watch your agents operate in real time
- Make any of it fun to look at
Meow Operations fixes all four. For free. For everyone.
What It Does
Analytics Dashboard
Tracks sessions from Claude Code, OpenAI Codex Desktop, Aider, Cursor, and Google Antigravity in one unified view. Cost tables for 30+ models.
Google Antigravity note: Antigravity stores session time, tools, and project locally (parsed from
~/.gemini/antigravity/brain/<id>/.system_generated/logs/transcript.jsonl), but it does not expose token counts, the model used, or cost on disk — the conversation store is encrypted and usage lives server-side. Antigravity sessions are therefore tracked for time/tools/project and shown withusage_available: false; tokens and cost are never fabricated or estimated for them.
| Page | What you see |
|---|---|
| Overview | Sessions, tokens, cost, healthy/ghost ratio, daily chart, tool distribution, spend by period |
| Sessions | Sortable table with cat-type classification per session |
| Analytics | AG Grid analytics table powered by typed session, velocity, efficiency, burn-rate, and profile modules |
| Agent Ops | Wall-clock Gantt timeline of parent + subagent runs, efficiency index, drill-down panel |
| Scrying Sanctum | 3D agent pipeline visualizer — unit frames, ley lines, pixel-art sprites |
| The Loom | Read-only control room for loop-based workflows, with workbook import, ownership, verification, and evidence |
| By Project | Horizontal bar breakdown per project |
| By Day | Area chart of token usage and session counts over time |
| By Action | Which tools your agents actually reach for |
| Cost Tracker | Daily cost line, cumulative burn, per-model breakdown |
| Live Sessions | Real-time agent cards with tool-usage bars |
| Capacity & Usage | GitHub Actions capacity, SaaS subscriptions, renewals, and SuperAdmin usage wiring |
Source Breakdown
When you use both Claude Code and OpenAI Codex Desktop, the Overview page shows a full side-by-side comparison and the sidebar shows a compact Source Usage panel:
- Sessions count and percentage share per source
- Total cost and tokens per source
- Average cost per session
- Ghost rate (empty/useless sessions) with a red flag when > 15%
- Weekly and monthly token budget tracking per source
- Filter the whole dashboard to one source via the Claude / Codex source toggle
The Source Usage sidebar panel is hidden automatically when only one source has data.
Codex Desktop Parser
Codex Desktop support is first-class, not a CSV import. sync/parse-codex.mjs walks:
~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl
It extracts rollout ID, project path, model family, token totals, tool calls, first user-message snippet, session title from session_index.jsonl when available, and estimated model cost. Malformed historical rows are skipped instead of blocking the export.
Agent Operations Visualizer
When Claude Code runs with subagents, meow-ops turns the session tree into a Gantt timeline showing exactly what ran in parallel vs. sequentially:
Run: storefront-redesign — 3 agents — $0.84 — 12m ago
⏱ 10:32:14 ───────────────────────────── 10:34:57 IST
├── 📐 Sonnet code-explorer ████████████ 47s $0.12
├── 📐 Sonnet code-architect ███████████████████ 1m42s $0.51
└── 🔍 Haiku code-reviewer ████████ 38s $0.09
⚡ 14,200 tok/$ (efficiency index)
Click any row for a full breakdown: token split, cache hit rate, tool usage, sidechain flag.
Scrying Sanctum
A 3D Dalaran-style multi-agent pipeline visualizer for local session data. Watch agent runs, token flow, latency, and session health traverse the network as animated runestones along glowing ley lines.
Argent Vanguard ──────────── Ebon Blade Scout ──────────── Dalaran Archmage ──── Argent Herald
[active] healthy ley [active] choked ley [active] [idle]
$0.0009 $0.0041 $0.0223 $0.0003
112ms 1480ms 3240ms 58ms
Features:
- Four champion node types with distinct sigils and accent colors
- Ley line health states:
healthy(fast flow),choked(slow flow),severed(flickering) - Animated runestones travel along ley line paths carrying JSON/text/error payloads
- Click any runestone to open a Loot Box modal showing full payload, token count, and latency
- WebGL plaza scene with performance guardrails, minimap, Lich King custodian, and LLM Sun token emitter
- Demo mode and local-session mode with no Supabase account required
- Supabase Realtime schema remains available for external pipelines in
db/migrations/0003_scrying_sanctum.sql
See db/migrations/0003_scrying_sanctum.sql for the full schema and RLS policies.
The Loom (Loom Ops)
The Loom is the read-only control room for loop-based workflows. It imports a workbook or workflow spec, builds the hierarchy on top of it, and renders the result as an interactive React Flow canvas.
Use it when a loop matters more than a single run:
- Check the shape of the loop before execution starts.
- Open any node to see ownership, access, last verified state, and what remains unverified.
- Keep review and refresh local while the source spec changes.
- Compare recorded runs with current cost and evidence.
- Keep unverified items clearly labeled until evidence appears.
Main Coordinator
┌──────────┬──────┴───────┬─────────────┐
Research Dir Build Dir Review Dir Ops Dir
┌──┬──┐ ┌──┬──┐ ┌──┬──┐ ┌──┐
W1 W2 … W3 W4 … W5 W6 … W7 …
[review] [covered] [passed] [blocked]
These screens show the shape of the loop, the expanded waves, the inspector, the timeline, and the mobile fallback.
What it shows:
- Excel workbook importer with fail-loud validation. Unknown groups, duplicate keys, missing columns, or secret-shaped content stop the import with named violations.
- Collapsible wave clusters keep dense lanes readable. Minimap, keyboard access, light and dark theme, and reduced-motion support stay on.
- Every node answers four questions: what owns this, what it can touch, last verified state, and what was not verified.
- Inspector shows workflow-spec knobs, guardrails, eval gates, and copyable validation commands. The Loom never executes anything itself.
- Run timeline joins recorded loop runs against real session costs. An empty evidence list stays suspicious.
- Permanent "production writes disabled" badge. The alarm branch wears red, never the safe green.
- All loop data is local-only, and the hosted demo intentionally shows the instructional empty state.
Local API endpoints (sync/local-api.mjs): GET /loop-ops/spec|status|runs, POST /loop-ops/sync re-runs the importer. Import manually with node sync/loop-ops-import.mjs.
Capacity & Usage
A local-first SuperAdmin cockpit for the operator's software stack: GitHub Actions run volume, cache and artifact footprint, SaaS subscription run rate, renewal pressure, and source wiring for private usage ledgers.
The public build ships a generic demo screen. Real account usage stays local in public/data/superadmin-usage.json, which is gitignored. Refresh it with:
npm run sync:superadmin
Optional environment:
MEOW_SUPERADMIN_GITHUB_REPOS=merak3i/meow-ops,<REPO_OWNER>/<REPO_NAME>
MEOW_SUPERADMIN_USAGE_SNAPSHOT=/absolute/path/to/superadmin-usage.json
MEOW_GITHUB_ACTIONS_MINUTES_LIMIT=3000
MEOW_GITHUB_ACTIONS_STORAGE_GB_LIMIT=10
The exporter accepts a local JSON snapshot shaped as [{...}], { "services": [...] }, { "rows": [...] }, or { "saas": { "services": [...] } }. Service-role keys and provider tokens do not belong in the snapshot.
The Cat Companion
A living 3D companion rendered in WebGL with Kajiya-Kay fur shading, subsurface scattering, and proper procedural anatomy — that evolves based on your actual session data.
Procedural companion rendering (no glTF required, runs in-browser):
- React Three Fiber scene with breed-specific geometry, rooms, accessories, particles, and local-only gameplay state
- Pixel-cat sprite system for lightweight companion presentation and exportable cat cards
- XState emotional state machine driven by session profile, wellness, cursor movement, and focus state
- Post-processing bloom was intentionally removed after WebGL stability testing on Apple GPU paths
Physical evolution — real mesh deformations:
| Morph | Driver | Visual change |
|---|---|---|
| Robustness | Heavy Bash usage | More muscular frame |
| Agility | Heavy Read / Grep | Longer, leaner silhouette |
| Intelligence | Heavy Agent / PlanMode | Larger head |
| Size | Total tokens (lifetime XP) | kitten → elder |
| Fatigue | 4h overload window | Drooping posture |
Tamagotchi gameplay (lives in localStorage, nothing uploaded):
- 5 stats: Hunger, Energy, Happiness, Health, Shine — decay over real time
- Feed, play, groom, sleep — each triggers a particle effect on the 3D cat
- 20+ food items, 15+ accessories, 6 rooms (each changes HDRI lighting)
- Cat runs away after 14 days of neglect → memorial entry
Personality traits — the cat reflects your work pattern:
| 14-day dominant type | Trait | Bonus |
|---|---|---|
| Architect | 📐 Methodical | Happiness decay resistance |
| Builder | 🔨 Prolific | +10% shine from feed |
| Detective | 🔍 Vigilant | +5% health passive |
| Commander | ⚡ Bold | +10% energy from sleep |
Memory markings — permanent 3D marks earned once, never removed:
- 🩹 Scar — survived health < 5%
- ✨ Gold stripe — 7-day coding streak
- ⭐ Star mark — 100+ total sessions
- 🔥 Blaze — single session cost > $1
- 👑 Crown — 30-day streak
Cat card export — 📸 Share button → PNG download with name, breed, stats, trait badge, meow-ops watermark.
Live session detection — page polls every 30s. When new sessions are detected while you're working, the cat reacts with a gold sparkle burst.
macOS Menu Bar And Local Sync API
A native-feeling menu bar widget can auto-sync your sessions in the background:
cp sync/launchd-example.plist ~/Library/LaunchAgents/com.meow-ops.sync.plist
launchctl load ~/Library/LaunchAgents/com.meow-ops.sync.plist
Runs export-local.mjs every hour, keeping your deployed dashboard current without opening a terminal.
For a hosted dashboard that can trigger sync from the browser, run the local API on your machine:
node sync/local-api.mjs # export local data (no git push — that is retired)
It listens on http://localhost:7337, serves fresh local sessions.json and cost-summary.json, and exposes POST /sync plus GET /sync/status. This process reads only local files on your machine and never pushes to git. Requests are restricted to localhost; if you call it from a hosted dashboard URL, allowlist that origin with MEOW_DASHBOARD_ORIGIN (see .env.example).
How Sessions Are Classified
Every session is auto-tagged by tool usage profile:
| Type | Trigger | Meaning |
|---|---|---|
| 🏗️ Builder | >40% Write + Edit | Heavy coding/writing |
| 🔍 Detective | >50% Read + Grep + Glob | Code exploration |
| 💻 Commander | >40% Bash | Shell/system work |
| 📐 Architect | >20% Agent + PlanMode | Planning/orchestration |
| 🛡️ Guardian | Top tool is Grep/Read | Audits and reviews |
| 📝 Storyteller | Top tool is Write | Docs and content |
| 👻 Ghost | <3 messages or no tools | Empty session |
Supported Models
30+ models with accurate pricing:
| Family | Models |
|---|---|
| Claude | Opus 4, Sonnet 4.6, Sonnet 4.5, Haiku 4.5 |
| OpenAI | GPT-4o, GPT-4o-mini, GPT-5, o3, o4-mini |
| DeepSeek | V3, R1, R1-0528 |
| Qwen | Max, Plus, Turbo (Alibaba DashScope) |
| Moonshot | Kimi K2 |
| Zhipu | GLM-4, GLM-4-Flash (free) |
| ByteDance | Doubao-Pro |
| xAI | Grok-3, Grok-3-mini, Grok-2 |
| Cohere | Command R+, Command R |
| Amazon | Nova Pro, Nova Lite, Nova Micro |
| Gemini 2.5 Pro, 2.0 Flash, 1.5 Pro, 1.5 Flash | |
| Mistral | Large, Small |
| Perplexity | Sonar Pro, Sonar |
| Local | Llama 3.3-70B (cost = $0) |
Unknown variants match by family fuzzy search.
Sync Pipeline
sync/export-local.mjs is the source of truth for generated dashboard data.
It currently:
- Reads Claude Code JSONL files from
~/.claude/projects/ - Reads Codex Desktop rollouts from
~/.codex/sessions/ - Reads Google Antigravity transcripts from
~/.gemini/antigravity/(time/tools/project only; usage not exposed by Antigravity) - Optionally reads Cursor logs from
CURSOR_LOGS_DIR - Optionally reads Aider project histories from
AIDER_PROJECTS - Deduplicates and classifies sessions, refines project names from
cwd, calculates model cost, and sorts by latest activity - Writes
public/data/sessions.json - Writes
public/data/cost-summary.jsonfor all-session daily and spend buckets - Supports
--pushfor the operator's own workflow
Useful commands:
node sync/export-local.mjs
node sync/export-local.mjs --push
node sync/full-sync.mjs
node sync/fetch-claude-limits.mjs
Deploy as a PWA (access from any device)
1. Supabase Storage setup (free tier)
# Create a public bucket
curl -X POST "https://<your-project>.supabase.co/storage/v1/bucket" \
-H "Authorization: Bearer <service-role-key>" \
-H "Content-Type: application/json" \
-d '{"id":"meow-ops","name":"meow-ops","public":true}'
2. Configure .env
cp .env.example .env
# Fill in:
# VITE_SUPABASE_URL
# VITE_SUPABASE_ANON_KEY
# VITE_SESSIONS_URL (public bucket URL to sessions.json)
# SUPABASE_SERVICE_KEY (local only — never deployed)
# VITE_ACCESS_PASSWORD (optional demo gate for hosted builds)
3. Sync and deploy
node sync/full-sync.mjs # parse + upload in one shot
npx vercel --prod
4. Auto-sync hourly (macOS)
cp sync/launchd-example.plist ~/Library/LaunchAgents/com.meow-ops.sync.plist
# Edit the paths inside the plist to match your setup, then:
launchctl load ~/Library/LaunchAgents/com.meow-ops.sync.plist
5. Install to dock
- Open your Vercel URL in Chrome
- Address bar → install icon (⊕)
- Right-click dock icon → Options → Keep in Dock
6. Scrying Sanctum (Supabase Realtime, optional)
Run the migration to enable live agent pipeline visualization:
# In Supabase SQL editor:
-- Run db/migrations/0003_scrying_sanctum.sql
This creates ss_pipelines, ss_nodes, ss_edges, ss_runestones with multi-tenant RLS and enables Realtime publication. Without this, the Scrying Sanctum page runs in demo mode automatically.
Architecture
Local machine Cloud (optional)
───────────── ────────────────
~/.claude/projects/ ~/.codex/sessions/
├── <session>.jsonl └── <session>.jsonl
└── subagents/
└── agent-*.jsonl
│
▼
sync/export-local.mjs
(parse · dedupe · classify · cost-calculate)
│
├──── public/data/sessions.json (local dev)
│
└──── sync/upload-to-supabase.mjs ──► Supabase Storage
│
PWA on dock ──► vercel.app ──── fetch sessions.json ─────┘
React 19 + Vite 8 + Recharts + D3 + AG Grid
Three.js companion + Sanctum scene (WebGL)
XState emotional state machine
Supabase Realtime (Scrying Sanctum)
No hosted backend. No server-side rendering. The production build is a static bundle plus generated JSON data. Supabase Storage/Realtime are opt-in, and sync/local-api.mjs is a localhost-only helper for operators who want browser-triggered sync.
Tech Stack
| Layer | Tech |
|---|---|
| Frontend | React 19 + Vite 8 |
| 3D Companion | Three.js + React Three Fiber + custom GLSL shaders |
| State machine | XState 5 (companion emotional states) |
| Charts | Recharts |
| Pipeline visualizer | D3 (zoom/pan/SVG) |
| Styling | Tailwind CSS 4 + OKLCH design tokens |
| Data grid | AG-Grid (session analytics table) |
| Storage | Supabase Storage (opt-in) |
| Realtime | Supabase Realtime (Scrying Sanctum, opt-in) |
| Hosting | Vercel (or any static host) |
| Sync | Node.js ESM scripts |
| Local helper | localhost sync API on port 7337 |
Testing
End-to-end tests run against the production build using Playwright:
npm run build # build dist/
npx playwright test # runs all 15 tests against npm run preview
Tests cover all 12 pages, key interactions, PWA manifest, and data endpoints. The playwright.config.ts uses a single Chromium project against http://localhost:4173 (Vite preview port).
To run a single test file or test by name:
npx playwright test --grep "Scrying Sanctum"
npx playwright test --reporter=list
Privacy
- Local-first by default. Nothing leaves your machine in dev mode.
- Sessions JSON is metrics plus one short label snippet. It stores token counts, tool counts, durations, model names, and project names from
cwd, plus a single first-user-message snippet (~80 chars) and session title used to label rows. It does not store full message content, full prompts, or code. - Want strictly metrics-only? Set
MEOW_NO_SNIPPETS=1before running the export and no snippet or title is captured for any source. - Snippets are intentionally short. The parser stores a first-message/session-title snippet for labeling, not full transcript content. This is the data class that was exposed in a prior public-repo incident, which is why
sessions.jsonis now local-only and gitignored (the hosted demo serves sanitizeddemo-*fixtures). - Supabase upload is opt-in. Your own bucket, your own credentials.
- Service key is local-only. It never appears in the production bundle.
- Hosted demo password gate is optional.
VITE_ACCESS_PASSWORDonly protects demo access; it is not an account system. - No analytics, no telemetry, no tracking. The app has no idea you exist.
Roadmap
Token Value Index (designed, not yet built)
Link sessions to git commits and measure what shipped:
- Lines of code merged per $1 spent
- Successful sessions (committed output) vs. ghost sessions (nothing landed)
- Project ROI: which codebases generate the most value per token
- Model comparison: which model gets you to commit fastest
Gemini CLI + OpenRouter parsers (planned)
Parsers for additional AI tools:
sync/parse-gemini.mjs— Gemini CLI session logssync/parse-openrouter.mjs— unified cost across all OpenRouter modelssync/parse-ollama.mjs— local model sessions (cost = electricity estimate)
Scrying Sanctum enhancements (planned)
- Supabase integration guide for connecting your own multi-agent pipelines
- WebSocket bridge for non-Supabase backends
- Node clustering for large pipelines (10+ agents)
- Replay mode: scrub through a completed pipeline run
Community Cat Registry (planned)
Opt-in. Share your companion's current state (not your session data) to a public registry. See how your cat's physique compares to other developers globally. Leaderboards by growth stage, rarity tier, streak length.
Privacy-first and opt-in by design.
Contributing
Every feature on the roadmap is an open issue. The highest-impact contributions:
New model parsers
sync/parse-gemini.mjs— Gemini CLIsync/parse-openrouter.mjs— OpenRouter unified
Analytics
- Token value index (link sessions to git commits)
- Session quality score (output tokens / ghost ratio / tool diversity)
- Model comparison view (same project, different models, side-by-side cost)
Companion
- New cat types / classifier rules for new tools
- Sound design (purring on focus, chirps on breakthroughs)
- Cat card frame designs (community-submitted overlays)
Agent Visualizer / Scrying Sanctum
- Live replay mode (replay a session's agent operations at 10× speed)
- Cross-run comparison (trend lines: are your runs getting cheaper?)
- Scrying Sanctum zoom/pan canvas (true spatial layout, not horizontal scroll)
PRs welcome. Open an issue first for anything substantial.
Project Structure
meow-ops/
├── public/
│ ├── manifest.json PWA manifest
│ ├── sw.js Service worker (network-first)
│ └── data/ Generated by export-local.mjs
│ ├── sessions.json All parsed sessions (last 1000)
│ └── cost-summary.json Today/week/month/year spend buckets
├── db/
│ └── migrations/
│ ├── 0001_initial_schema.sql Core sessions schema
│ ├── 0002_daily_summaries.sql Daily aggregates table
│ ├── 0003_scrying_sanctum.sql Pipeline viz schema + RLS + Realtime
│ └── 0004_rls_tenant_isolation.sql Strict per-tenant SELECT (no NULL-tenant world read)
├── e2e/
│ └── meow-ops.spec.ts Playwright e2e tests (15 tests, all pages)
├── src/
│ ├── analytics/ Velocity, efficiency, burn-rate, profile modules
│ ├── companion-v2/ WebGL/pixel companion
│ │ ├── CompanionScene.tsx R3F canvas, HDRI rooms, particles, post-processing
│ │ ├── CompanionPageV2.tsx Orchestrator — polling, milestones, marks
│ │ ├── StatsPanel.tsx Stat bars, actions, trait badge, share button
│ │ ├── useCompanionGame.ts Store wrapper, personality trait, memory marks
│ │ ├── PixelCat.tsx Lightweight breed sprite renderer
│ │ ├── ParticleOverlay.tsx Per-action particle effects
│ │ ├── MilestoneOverlay.tsx Celebration overlay (growth, streaks, spend)
│ │ └── CatCardExport.tsx Canvas2D overlay → PNG download
│ ├── components/ Charts, session table, nav, password gate, date filter
│ ├── lib/
│ │ ├── agent-tree.ts Forest builder, efficiency index, cache hit rate
│ │ └── companion-store.js Tamagotchi engine (localStorage)
│ ├── pages/
│ │ ├── AgentVisualizer.tsx Gantt timeline, ghost flagging, drill-down
│ │ ├── AgentDetailPanel.tsx Slide-in session detail panel
│ │ ├── ScryingSanctum.tsx 3D agent pipeline visualizer
│ │ └── ... Overview, Sessions, ByDay, ByProject, etc.
│ ├── scrying-sanctum/ Realtime pipeline components for external feeds
│ │ ├── ScryingSanctum.tsx Main page — D3 zoom canvas, legend, loot box
│ │ ├── ChampionNode.tsx SVG foreignObject node card
│ │ ├── LeyLine.tsx SVG path with flow animation + runestones
│ │ ├── Runestone.tsx Animated token packet (RAF path-following)
│ │ ├── championsConfig.ts Node metadata, colors, Bezier path builder
│ │ ├── useScryingData.ts Supabase/demo data hook with Realtime subscriptions
│ │ ├── types.ts SsNode, SsEdge, SsRunestone, SsPipeline types
│ │ └── scrying-sanctum.css Ley line animations, champion cards, loot box
│ ├── state/
│ │ └── companionMachine.ts XState machine — emotional states, cursor tracking
│ └── types/
│ └── session.ts Single source of truth for all session types
├── sync/
│ ├── parse-session.mjs JSONL parser with agent hierarchy extraction
│ ├── parse-codex.mjs OpenAI Codex Desktop parser
│ ├── parse-cursor.mjs Cursor IDE log parser
│ ├── parse-aider.mjs Aider chat history parser
│ ├── parse-antigravity.mjs Google Antigravity transcript parser (time/tools; usage not exposed)
│ ├── session-utils.mjs Shared snippet/project/default-session helpers
│ ├── cost-calculator.mjs 30+ model pricing with fuzzy matching
│ ├── export-local.mjs All sources → sessions.json + cost-summary.json
│ ├── fetch-claude-limits.mjs Update rate-limits.json from claude.ai/settings/usage
│ ├── upload-to-supabase.mjs Push to Storage bucket
│ ├── full-sync.mjs export + upload in one shot
│ ├── local-api.mjs localhost sync/status/data server
│ └── launchd-example.plist macOS hourly auto-sync template
├── menubar/
│ ├── MeowOpsBar.swift macOS menu bar companion source
│ └── build.sh Build script for MeowOpsBar.app
├── playwright.config.ts Playwright configuration
└── .env.example
License
MIT. Build with it, fork it, ship it. Keeping derivative tools open source is encouraged, but not required by the license.
Credits
3D fur rendering inspired by Kajiya-Kay shading models. Focus timer mechanics inspired by Forest: Stay Focused. Visual design language inspired by ElevenLabs. Built with Claude Code.
Meow Operations is a community tool. It has no business model, no venture funding, and no plans to acquire either. It exists because developers deserve to understand their AI spend — and because the interface for that understanding should feel like something you want to open.