convez.ai
PluginDados & AnalyticsIntermediário
merak3i

Meow Operations

merak3i/meow-ops

Analytics e observabilidade local para sessões de IA com Pomodoro e gato 3D

Ver no GitHub
InicialPluginScore · de 0 a 100

Dashboard 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-ops

1 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

Estrelas
2
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 2 semanas
Versão
—
Issues abertas
5
Contribuidores
4

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

  1. Open http://localhost:5173 in Chrome
  2. The dashboard loads your parsed local sessions immediately
  3. Codex Desktop sessions are read from ~/.codex/sessions/ automatically when present
  4. To add Aider sessions: AIDER_PROJECTS=/path/to/your/project node sync/export-local.mjs
  5. To add Cursor sessions: CURSOR_LOGS_DIR=~/.cursor/logs node sync/export-local.mjs
  6. 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 with usage_available: false; tokens and cost are never fabricated or estimated for them.

PageWhat you see
OverviewSessions, tokens, cost, healthy/ghost ratio, daily chart, tool distribution, spend by period
SessionsSortable table with cat-type classification per session
AnalyticsAG Grid analytics table powered by typed session, velocity, efficiency, burn-rate, and profile modules
Agent OpsWall-clock Gantt timeline of parent + subagent runs, efficiency index, drill-down panel
Scrying Sanctum3D agent pipeline visualizer — unit frames, ley lines, pixel-art sprites
The LoomRead-only control room for loop-based workflows, with workbook import, ownership, verification, and evidence
By ProjectHorizontal bar breakdown per project
By DayArea chart of token usage and session counts over time
By ActionWhich tools your agents actually reach for
Cost TrackerDaily cost line, cumulative burn, per-model breakdown
Live SessionsReal-time agent cards with tool-usage bars
Capacity & UsageGitHub 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:

MorphDriverVisual change
RobustnessHeavy Bash usageMore muscular frame
AgilityHeavy Read / GrepLonger, leaner silhouette
IntelligenceHeavy Agent / PlanModeLarger head
SizeTotal tokens (lifetime XP)kitten → elder
Fatigue4h overload windowDrooping 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 typeTraitBonus
Architect📐 MethodicalHappiness 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:

TypeTriggerMeaning
🏗️ Builder>40% Write + EditHeavy coding/writing
🔍 Detective>50% Read + Grep + GlobCode exploration
💻 Commander>40% BashShell/system work
📐 Architect>20% Agent + PlanModePlanning/orchestration
🛡️ GuardianTop tool is Grep/ReadAudits and reviews
📝 StorytellerTop tool is WriteDocs and content
👻 Ghost<3 messages or no toolsEmpty session

Supported Models

30+ models with accurate pricing:

FamilyModels
ClaudeOpus 4, Sonnet 4.6, Sonnet 4.5, Haiku 4.5
OpenAIGPT-4o, GPT-4o-mini, GPT-5, o3, o4-mini
DeepSeekV3, R1, R1-0528
QwenMax, Plus, Turbo (Alibaba DashScope)
MoonshotKimi K2
ZhipuGLM-4, GLM-4-Flash (free)
ByteDanceDoubao-Pro
xAIGrok-3, Grok-3-mini, Grok-2
CohereCommand R+, Command R
AmazonNova Pro, Nova Lite, Nova Micro
GoogleGemini 2.5 Pro, 2.0 Flash, 1.5 Pro, 1.5 Flash
MistralLarge, Small
PerplexitySonar Pro, Sonar
LocalLlama 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.json for all-session daily and spend buckets
  • Supports --push for 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

  1. Open your Vercel URL in Chrome
  2. Address bar → install icon (⊕)
  3. 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

LayerTech
FrontendReact 19 + Vite 8
3D CompanionThree.js + React Three Fiber + custom GLSL shaders
State machineXState 5 (companion emotional states)
ChartsRecharts
Pipeline visualizerD3 (zoom/pan/SVG)
StylingTailwind CSS 4 + OKLCH design tokens
Data gridAG-Grid (session analytics table)
StorageSupabase Storage (opt-in)
RealtimeSupabase Realtime (Scrying Sanctum, opt-in)
HostingVercel (or any static host)
SyncNode.js ESM scripts
Local helperlocalhost 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=1 before 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.json is now local-only and gitignored (the hosted demo serves sanitized demo-* 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_PASSWORD only 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 logs
  • sync/parse-openrouter.mjs — unified cost across all OpenRouter models
  • sync/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 CLI
  • sync/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.

Ver o original no GitHub

Bom para

Relacionados