@zeluizr/lattice 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project adheres
+to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] — 2026-06-24
+
+First open-source release as **lattice** — a full rewrite of the project
+previously known as `commente.me`.
+
+### Added
+- **Node.js / TypeScript + Ink rewrite.** The dashboard is now a proper CLI,
+  distributed on npm and runnable with `npx @zeluizr/lattice` or
+  `npm i -g @zeluizr/lattice` (command: `lattice`).
+- **Per-disk panel.** One row per real mount — `/` and every volume under
+  `/Volumes` — with live read/write throughput (from IOKit block-storage byte
+  counters via `ioreg`, no sudo) and space used.
+- **Git panel.** Scans a folder of repos (default: the parent of the current
+  directory, or `--repos <dir>`) and shows each repo's current branch with its
+  state — clean/dirty and commits ahead/behind upstream. Hidden when empty.
+- **Internationalization** — English, Español and Português (Brasil). Chosen on
+  first run, persisted in `~/.config/lattice/config.json`, switchable with
+  `--lang`.
+- **Native SMC helper** (`lattice-smc`, IOKit in C, shipped prebuilt) for CPU/GPU
+  temperatures and fan speeds without sudo, with graceful fallback.
+- **Six Dracula Pro themes** selectable with `--theme`.
+- Live panels: CPU, memory/swap, GPU, temperature/fans, network, per-disk I/O &
+  usage, AI token cost (today), git branches per repo, VTEX status, and top
+  processes.
+- Flags: `--no-power`, `--no-vtex`, `--repos`, `--interval`, `--procs`,
+  `--icons`, `--lang`, `--theme`.
+- Hotkeys: `q` quit, `p` pause, `+`/`-` refresh speed.
+
+### Changed
+- Documentation and UI are now in English (plus es / pt-BR at runtime); the
+  project was previously Portuguese-only.
+- Power collection uses a streaming `powermetrics` subprocess parsed in Node.
+- lattice is a focused, local-only monitor: there is no embedded chat and no
+  network calls — every metric is read from the machine.
+
+### Migration
+- The previous Python/Textual implementation is preserved in git under the
+  `v0-python` tag.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jose Luiz Rodrigues
+
+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.

package/MANIFESTO.md

@@ -0,0 +1,37 @@
+# The lattice manifesto
+
+Every machine hums with signals — cores spiking, watts flowing, silicon warming
+and cooling in a rhythm you rarely see. **lattice makes that rhythm visible.**
+
+### 1. Your machine, your data.
+Every metric is read locally and stays local. No telemetry, no accounts, no
+cloud — nothing ever leaves your Mac.
+
+### 2. Built for the metal it runs on.
+lattice is not a generic monitor with a Mac coat of paint. It speaks IOKit, SMC,
+`ioreg` and `powermetrics` natively — tuned for Apple Silicon, from the M1 to
+whatever comes next.
+
+### 3. The terminal deserves beauty.
+A dashboard you stare at all day should be a pleasure to look at. Real colors,
+live sparklines, considered typography. Function and form are not opposites.
+
+### 4. Every disk, every volume.
+Storage isn't one number. lattice shows each disk on its own — `/` and every
+external volume under `/Volumes` — with live read/write and space used, so you
+see exactly which one is working.
+
+### 5. Fast, small, out of the way.
+A monitor that hogs the resources it measures has failed. lattice stays light.
+
+### 6. Open and yours to bend.
+MIT-licensed, readable, hackable. Fork it, theme it, extend it.
+
+### 7. In your language.
+English, Español, Português — because good tools shouldn't assume where you're
+from.
+
+---
+
+*lattice is the ordered structure beneath the chip, made legible.*
+**Watch your machine think.**

package/README.md

@@ -0,0 +1,139 @@
+<div align="center">
+
+# ◇ lattice
+
+**A real-time terminal dashboard for macOS Apple Silicon.**
+
+GPU · power · temps & fans · per-disk I/O · network · memory · processes ·
+AI token cost. A focused monitor — every metric read locally, nothing leaves
+your Mac.
+
+[![npm](https://img.shields.io/npm/v/%40zeluizr%2Flattice?color=9580FF)](https://www.npmjs.com/package/@zeluizr/lattice)
+[![license](https://img.shields.io/badge/license-MIT-FF80BF)](./LICENSE)
+[![node](https://img.shields.io/badge/node-%E2%89%A518-80FFEA)](https://nodejs.org)
+[![platform](https://img.shields.io/badge/macOS-Apple%20Silicon-8AFF80)](#requirements)
+
+*Watch your machine think.* — [read the manifesto](./MANIFESTO.md)
+
+</div>
+
+---
+
+## Install & run
+
+No install needed — run it straight from npm:
+
+```bash
+npx @zeluizr/lattice
+```
+
+Or install it globally so you can just type `lattice`:
+
+```bash
+npm i -g @zeluizr/lattice
+lattice
+```
+
+On first run, lattice asks for your language (English · Español · Português) and
+remembers it. Watts need `sudo` (see below); everything else works without it.
+
+## Usage
+
+```bash
+lattice                      # full dashboard (asks for sudo once, for watts)
+lattice --no-power           # skip sudo; CPU/GPU/RAM/disk/net/temps only
+lattice --no-vtex            # hide the VTEX panel (for non-VTEX users)
+lattice --repos ~/code       # git branches for the repos in ~/code
+lattice --interval 2         # refresh every 2s
+lattice --procs 12           # show 12 top processes
+lattice --icons emoji        # nerd | emoji | none
+lattice --lang es            # en | es | pt-BR (persists)
+lattice --theme blade        # pro | blade | buffy | lincoln | morbius | van-helsing
+```
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--no-power` | off | Skip `powermetrics`/sudo (no watts) |
+| `--no-vtex` | off | Hide the VTEX panel (for non-VTEX users) |
+| `--repos` | *(parent of cwd)* | Folder of git repos to show branches for |
+| `--interval`, `-i` | `1` | Refresh interval in seconds |
+| `--procs`, `-n` | `8` | Number of top processes |
+| `--icons` | `nerd` | Icon style: `nerd`, `emoji`, `none` |
+| `--lang` | *(asked)* | `en`, `es`, `pt-BR` |
+| `--theme` | `pro` | Dracula Pro variant |
+
+### Hotkeys
+
+| Key | Action |
+|-----|--------|
+| `q` | quit |
+| `p` | pause / resume |
+| `+` / `-` | faster / slower refresh |
+
+## What it shows
+
+| Panel | Source | Needs sudo |
+|-------|--------|:----------:|
+| GPU usage & memory | `ioreg` (IOAccelerator) | — |
+| CPU, RAM, swap, network, processes | system APIs | — |
+| Per-disk I/O & usage — `/` and every `/Volumes/*` | `ioreg` + system APIs | — |
+| Temperatures & fans | SMC via IOKit (native helper) | — |
+| Power (watts), GPU freq, thermal pressure | `powermetrics` | **yes** |
+| AI tokens & cost (today) | Claude Code logs (`~/.claude`) | — |
+| Git branches — current branch + dirty/ahead·behind per repo | `git status` | — |
+| VTEX status | VTEX CLI configstore | — |
+
+Temperatures and fans read straight from the SMC, so they work **without sudo**.
+Desktops (Mac mini / Studio) simply report no battery.
+
+The **disks** panel breaks activity out per mount — one row each for `/` and
+every volume under `/Volumes` — with live read/write throughput and space used,
+so you can see exactly which disk is busy.
+
+The **git** panel scans a folder of repositories (by default the parent of the
+current directory, or pass `--repos <dir>`) and shows each repo's current branch
+with its state — clean/dirty and commits ahead/behind upstream. It hides itself
+when the folder has no repos.
+
+## Languages
+
+lattice ships in **English**, **Español** and **Português (Brasil)**. It asks on
+first run, stores your choice in `~/.config/lattice/config.json`, and you can
+switch any time with `--lang`.
+
+## Themes
+
+Six Dracula Pro variants — `pro` (default), `blade`, `buffy`, `lincoln`,
+`morbius`, `van-helsing`. Switch with `--theme <name>` (persisted). Best in a
+truecolor terminal (Warp, iTerm2, Ghostty, kitty). For Nerd Font icons, use a
+patched font like MesloLGS NF — or pass `--icons emoji` / `--icons none`.
+
+## Passwordless watts (optional)
+
+To skip the sudo prompt for `powermetrics`:
+
+```bash
+sudo bash scripts/setup-sudoers.sh
+```
+
+This adds `/etc/sudoers.d/lattice-powermetrics` allowing passwordless
+`powermetrics` for your user.
+
+## Requirements
+
+- **macOS on Apple Silicon** (M1/M2/M3/M4…). Intel Macs and other OSes are not
+  supported.
+- **Node.js ≥ 18.**
+- A truecolor terminal; optionally a Nerd Font for icons.
+
+## Contributing
+
+Issues and PRs welcome — see [CONTRIBUTING.md](./CONTRIBUTING.md). Adding a new
+language is just one file in `src/i18n/`.
+
+## License
+
+MIT © Jose Luiz Rodrigues. See [LICENSE](./LICENSE).
+
+> Previously released as **commente.me** (Python / Textual). The Node/TypeScript
+> rewrite is tagged from `v0-python` onward — see [CHANGELOG](./CHANGELOG.md).

package/dist/app.js

@@ -0,0 +1,196 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { Panel } from "./components/Panel.js";
+import { SystemCollector } from "./collectors/system.js";
+import { DisksCollector } from "./collectors/disks.js";
+import { GitCollector } from "./collectors/git.js";
+import { readGpu } from "./collectors/gpu.js";
+import { readSensors } from "./collectors/sensors.js";
+import { PowerCollector } from "./collectors/power.js";
+import { TokenCollector } from "./collectors/tokens.js";
+import { readVtex } from "./collectors/vtex.js";
+import { coreCell, fmtTok, humanBytes, humanRate, sparkline, statusLevel } from "./format.js";
+const MAX_HIST = 60;
+const push = (h, v) => [...h, v].slice(-MAX_HIST);
+function timeStr() {
+    const d = new Date();
+    return d.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+export function App(props) {
+    const { t, pal, icon, usePower, useVtex, gitDir, topN } = props;
+    const { exit } = useApp();
+    const [sys, setSys] = useState(null);
+    const [disks, setDisks] = useState(null);
+    const [git, setGit] = useState(null);
+    const [gpu, setGpu] = useState(null);
+    const [sensors, setSensors] = useState(null);
+    const [power, setPower] = useState(null);
+    const [tokens, setTokens] = useState(null);
+    const [vtex, setVtex] = useState(null);
+    const [hCpu, setHCpu] = useState([]);
+    const [hMem, setHMem] = useState([]);
+    const [hNet, setHNet] = useState([]);
+    const [hGpu, setHGpu] = useState([]);
+    const [hTemp, setHTemp] = useState([]);
+    const [paused, setPaused] = useState(false);
+    const [interval, setIntervalState] = useState(props.interval);
+    const [now, setNow] = useState(timeStr());
+    const [cols, setCols] = useState(process.stdout.columns || 100);
+    const sysRef = useRef(null);
+    const disksRef = useRef(null);
+    const gitRef = useRef(null);
+    const tokRef = useRef(null);
+    const powerRef = useRef(null);
+    const pausedRef = useRef(false);
+    const mounted = useRef(true);
+    useEffect(() => {
+        pausedRef.current = paused;
+    }, [paused]);
+    // ----- init collectors + power subprocess + clock -------------------------
+    useEffect(() => {
+        mounted.current = true;
+        sysRef.current = new SystemCollector(topN);
+        disksRef.current = new DisksCollector();
+        gitRef.current = new GitCollector(gitDir);
+        tokRef.current = new TokenCollector();
+        if (usePower) {
+            powerRef.current = new PowerCollector(Math.round(props.interval * 1000));
+            powerRef.current.start();
+        }
+        const clock = setInterval(() => mounted.current && setNow(timeStr()), 1000);
+        const onResize = () => setCols(process.stdout.columns || 100);
+        process.stdout.on("resize", onResize);
+        return () => {
+            mounted.current = false;
+            clearInterval(clock);
+            process.stdout.off("resize", onResize);
+            powerRef.current?.stop();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // ----- main refresh loop --------------------------------------------------
+    const refreshData = useCallback(async () => {
+        if (pausedRef.current || !sysRef.current || !disksRef.current)
+            return;
+        const [s, d, g, st] = await Promise.all([
+            sysRef.current.read(),
+            disksRef.current.read(),
+            readGpu(),
+            readSensors(),
+        ]);
+        const p = powerRef.current ? powerRef.current.read() : null;
+        if (!mounted.current)
+            return;
+        setSys(s);
+        setDisks(d);
+        setGpu(g);
+        setSensors(st);
+        setPower(p);
+        setHCpu((h) => push(h, s.cpuTotal));
+        setHMem((h) => push(h, s.memPercent));
+        setHNet((h) => push(h, (s.netRecvBps + s.netSentBps) / 1024 / 1024));
+        setHGpu((h) => push(h, g.utilPct ?? 0));
+        const tv = st.cpuTemp ?? st.gpuTemp;
+        if (tv != null)
+            setHTemp((h) => push(h, tv));
+    }, []);
+    const refreshAux = useCallback(async () => {
+        if (pausedRef.current || !tokRef.current)
+            return;
+        const [tk, vx, gt] = await Promise.all([
+            tokRef.current.read(),
+            useVtex ? readVtex() : Promise.resolve(null),
+            gitRef.current ? gitRef.current.read() : Promise.resolve(null),
+        ]);
+        if (!mounted.current)
+            return;
+        setTokens(tk);
+        setVtex(vx);
+        setGit(gt);
+    }, [useVtex]);
+    useEffect(() => {
+        refreshData();
+        const id = setInterval(refreshData, Math.max(250, interval * 1000));
+        return () => clearInterval(id);
+    }, [interval, refreshData]);
+    useEffect(() => {
+        refreshAux();
+        const id = setInterval(refreshAux, 3000);
+        return () => clearInterval(id);
+    }, [refreshAux]);
+    useInput((input) => {
+        if (input === "q") {
+            powerRef.current?.stop();
+            exit();
+        }
+        else if (input === "p") {
+            setPaused((p) => !p);
+        }
+        else if (input === "+" || input === "=") {
+            setIntervalState((i) => Math.max(0.25, i / 2));
+        }
+        else if (input === "-" || input === "_") {
+            setIntervalState((i) => Math.min(10, i * 2));
+        }
+    });
+    // ----- derived helpers ----------------------------------------------------
+    const m = 1; // marginRight per panel
+    const col2 = Math.max(24, Math.floor((cols - 2 * m) / 2));
+    const col3 = Math.max(18, Math.floor((cols - 3 * m) / 3));
+    const fullW = Math.max(40, cols - m);
+    const inner = (w) => Math.max(6, w - 4); // minus border (2) + padding (2)
+    const w2 = inner(col2);
+    const w3 = inner(col3);
+    const statColor = (lvl) => lvl === "ok" ? pal.green : lvl === "warn" ? pal.yellow : pal.red;
+    const Stat = ({ value, warn, crit, metric }) => {
+        const lvl = statusLevel(value, warn, crit);
+        return (_jsxs(Text, { color: statColor(lvl), children: ["\u25CF ", t(`status.${metric}.${lvl}`)] }));
+    };
+    const caption = (h, fmt) => {
+        if (!h.length)
+            return t("spark.collecting");
+        const lo = Math.min(...h);
+        const hi = Math.max(...h);
+        const body = lo === hi ? fmt(lo) : `${fmt(lo)}–${fmt(hi)}`;
+        return t("spark.lastMin", { range: body });
+    };
+    // ----- values -------------------------------------------------------------
+    const cpu = sys?.cpuTotal ?? 0;
+    const cores = sys?.cpuPer ?? [];
+    const memPct = sys?.memPercent ?? 0;
+    const ct = sensors?.cpuTemp ?? null;
+    const gt = sensors?.gpuTemp ?? null;
+    const util = gpu?.utilPct ?? 0;
+    const diskRows = disks?.disks ?? [];
+    const gitRepos = git?.repos ?? [];
+    const tokTotal = tokens ? tokens.input + tokens.output + tokens.cacheW + tokens.cacheR : 0;
+    const modelItems = Object.entries(tokens?.byModel ?? {}).sort((a, b) => b[1].cost - a[1].cost);
+    const modelParts = modelItems.slice(0, 2).map(([k, v]) => `${k} $${v.cost.toFixed(2)}`);
+    const modelExtra = modelItems.length > 2 ? ` +${modelItems.length - 2}` : "";
+    const web = tokens && (tokens.webSearch || tokens.webFetch) ? ` · web ${tokens.webSearch}/${tokens.webFetch}` : "";
+    const models = modelParts.length ? modelParts.join(" · ") + modelExtra + web : t("tokens.none");
+    const powerParts = [];
+    if (power && (power.cpuW != null || power.gpuW != null))
+        powerParts.push(`${icon("power")} ${(power.cpuW ?? 0).toFixed(1)}+${(power.gpuW ?? 0).toFixed(1)}W`);
+    else if (usePower)
+        powerParts.push(`${icon("power")} ${t("temp.waitingSudo")}`);
+    if (sensors?.fans?.length)
+        powerParts.push(`${icon("fan")} ${sensors.fans[0].rpm.toFixed(0)} rpm`);
+    const tempLine2 = powerParts.length ? powerParts.join("  ·  ") : t("temp.needsSudo");
+    return (_jsxs(Box, { flexDirection: "column", width: cols, children: [_jsxs(Box, { justifyContent: "space-between", paddingX: 1, children: [_jsx(Text, { color: pal.purple, bold: true, children: "\u25C7 lattice" }), _jsx(Text, { color: pal.comment, children: paused ? t("paused") : t("subtitle") }), _jsxs(Text, { color: pal.comment, children: [icon("clock"), " ", now] })] }), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Panel, { title: `${icon("cpu")} ${t("panel.cpu")}`, color: pal.cyan, width: col2, children: [_jsxs(Text, { wrap: "truncate", children: [t("cpu.usage"), ": ", _jsxs(Text, { bold: true, children: [cpu.toFixed(0), "%"] }), "   ", _jsx(Stat, { value: cpu, warn: 60, crit: 85, metric: "cpu" })] }), _jsxs(Text, { wrap: "truncate", children: [t("cpu.cores"), ": ", cores.length, "   ", t("cpu.perCore"), ": ", cores.map(coreCell).join("")] }), _jsx(Text, { color: pal.cyan, wrap: "truncate", children: sparkline(hCpu, w2) }), _jsx(Text, { color: pal.comment, wrap: "truncate", children: caption(hCpu, (v) => `${v.toFixed(0)}%`) })] }), _jsxs(Panel, { title: `${icon("mem")} ${t("panel.mem")}`, color: pal.green, width: col2, children: [_jsxs(Text, { wrap: "truncate", children: [t("mem.ram"), ": ", _jsxs(Text, { bold: true, children: [memPct.toFixed(0), "%"] }), "   ", _jsx(Stat, { value: memPct, warn: 75, crit: 90, metric: "mem" })] }), _jsx(Text, { wrap: "truncate", children: t("mem.used", {
+                                    used: humanBytes(sys?.memUsed),
+                                    total: humanBytes(sys?.memTotal),
+                                    swap: (sys?.swapPercent ?? 0).toFixed(0),
+                                }) }), _jsx(Text, { color: pal.green, wrap: "truncate", children: sparkline(hMem, w2) }), _jsx(Text, { color: pal.comment, wrap: "truncate", children: caption(hMem, (v) => `${v.toFixed(0)}%`) })] })] }), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Panel, { title: `${icon("temp")} ${t("panel.temp")}`, color: pal.orange, width: col3, children: [_jsx(Text, { wrap: "truncate", children: ct != null && gt != null ? (_jsxs(_Fragment, { children: [ct.toFixed(0), "\u00B0 / ", gt.toFixed(0), "\u00B0", "   ", _jsx(Stat, { value: Math.max(ct, gt), warn: 65, crit: 80, metric: "temp" })] })) : ct != null || gt != null ? (_jsxs(_Fragment, { children: [(ct ?? gt ?? 0).toFixed(0), "\u00B0C", "   ", _jsx(Stat, { value: ct ?? gt ?? 0, warn: 65, crit: 80, metric: "temp" })] })) : (_jsx(Text, { color: pal.comment, children: t("temp.unavailable") })) }), _jsx(Text, { wrap: "truncate", children: tempLine2 }), _jsx(Text, { color: pal.orange, wrap: "truncate", children: sparkline(hTemp, w3) }), _jsx(Text, { color: pal.comment, wrap: "truncate", children: caption(hTemp, (v) => `${v.toFixed(0)}°`) })] }), _jsxs(Panel, { title: `${icon("net")} ${t("panel.net")}`, color: pal.cyan, width: col3, children: [_jsxs(Text, { wrap: "truncate", children: ["\u2193 ", humanRate(sys?.netRecvBps)] }), _jsxs(Text, { wrap: "truncate", children: ["\u2191 ", humanRate(sys?.netSentBps)] }), _jsx(Text, { color: pal.cyan, wrap: "truncate", children: sparkline(hNet, w3) }), _jsx(Text, { color: pal.comment, wrap: "truncate", children: caption(hNet, (v) => humanRate(v * 1024 * 1024)) })] }), _jsxs(Panel, { title: `${icon("gpu")} ${t("panel.gpu")}`, color: pal.purple, width: col3, children: [_jsxs(Text, { wrap: "truncate", children: [t("gpu.usage"), ": ", _jsxs(Text, { bold: true, children: [util, "%"] }), "   ", _jsx(Stat, { value: util, warn: 60, crit: 85, metric: "gpu" })] }), _jsx(Text, { wrap: "truncate", children: t("gpu.mem", { used: humanBytes(gpu?.memUsedBytes), alloc: humanBytes(gpu?.memAllocBytes) }) }), _jsx(Text, { color: pal.purple, wrap: "truncate", children: sparkline(hGpu, w3) }), _jsx(Text, { color: pal.comment, wrap: "truncate", children: caption(hGpu, (v) => `${v.toFixed(0)}%`) })] })] }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.cyan, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.cyan, bold: true, children: [icon("disk"), " ", t("panel.disks")] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("disks.mount").padEnd(22), t("disks.read").padEnd(12), t("disks.write").padEnd(12), t("disks.usage")] }), diskRows.length === 0 ? (_jsx(Text, { color: pal.comment, children: t("spark.collecting") })) : (diskRows.map((d) => {
+                        const lvl = statusLevel(d.usePercent, 80, 92);
+                        return (_jsxs(Text, { wrap: "truncate", children: [d.mount.slice(0, 21).padEnd(22), humanRate(d.readBps).padEnd(12), humanRate(d.writeBps).padEnd(12), _jsxs(Text, { color: statColor(lvl), children: ["\u25CF ", d.usePercent.toFixed(0), "%"] }), "  ", _jsxs(Text, { color: pal.comment, children: ["(", humanBytes(d.usedBytes), "/", humanBytes(d.sizeBytes), ")"] })] }, d.mount));
+                    }))] }), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Panel, { title: `${icon("tokens")} ${t("panel.tokens")}`, color: pal.pink, width: useVtex ? col2 : fullW, children: [_jsx(Text, { wrap: "truncate", children: t("tokens.spent", { cost: (tokens?.cost ?? 0).toFixed(2), messages: tokens?.messages ?? 0 }) }), _jsx(Text, { wrap: "truncate", children: t("tokens.tokens", {
+                                    total: fmtTok(tokTotal),
+                                    input: fmtTok(tokens?.input),
+                                    output: fmtTok(tokens?.output),
+                                }) }), _jsx(Text, { wrap: "truncate", children: t("tokens.cache", { cw: fmtTok(tokens?.cacheW), cr: fmtTok(tokens?.cacheR) }) }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("tokens.byModel", { models }) })] }), useVtex && (_jsx(Panel, { title: `${icon("vtex")} ${t("panel.vtex")}`, color: pal.purple, width: col2, children: !vtex ? (_jsx(Text, { color: pal.comment, children: t("spark.collecting") })) : !vtex.installed ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.red, children: t("vtex.notInstalled") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.install") })] })) : vtex.loggedIn ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.green, children: t("vtex.connected") })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.account"), ": ", _jsx(Text, { bold: true, children: vtex.account })] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.user"), ": ", vtex.login || "—"] }), _jsxs(Text, { wrap: "truncate", children: [t("vtex.workspace"), ": ", vtex.workspace || "master"] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [t("vtex.status"), ": ", _jsx(Text, { color: pal.yellow, children: t("vtex.notConnected") })] }), _jsx(Text, { wrap: "truncate", color: pal.comment, children: t("vtex.signin") })] })) }))] }), gitRepos.length > 0 && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.green, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.green, bold: true, wrap: "truncate", children: [icon("git"), " ", t("panel.git"), git?.truncated ? _jsx(Text, { color: pal.comment, children: " (+)" }) : null] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("git.repo").padEnd(20), t("git.branch").padEnd(22), t("git.state")] }), gitRepos.map((r) => {
+                        const label = r.detached ? "(detached)" : r.branch;
+                        return (_jsxs(Text, { wrap: "truncate", children: [r.name.slice(0, 19).padEnd(20), label.slice(0, 21).padEnd(22), _jsxs(Text, { color: r.dirty ? pal.yellow : pal.green, children: ["\u25CF ", r.dirty ? t("git.dirty") : t("git.clean")] }), r.ahead > 0 ? _jsxs(Text, { color: pal.comment, children: ["  ", "\u2191", r.ahead] }) : null, r.behind > 0 ? _jsxs(Text, { color: pal.comment, children: ["  ", "\u2193", r.behind] }) : null] }, r.name));
+                    })] })), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.comment, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.comment, bold: true, children: [icon("proc"), " ", t("panel.procs")] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("proc.cpu").padEnd(6), t("proc.mem").padEnd(9), t("proc.pid").padEnd(8), t("proc.name")] }), (sys?.procs ?? []).map((p) => (_jsxs(Text, { wrap: "truncate", children: [`${p.cpu.toFixed(0)}%`.padEnd(6), humanBytes(p.rss).padEnd(9), String(p.pid).padEnd(8), p.name.slice(0, 30)] }, p.pid)))] }), _jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: pal.comment, children: [_jsx(Text, { color: pal.pink, children: "q" }), " ", t("key.quit"), " \u00B7 ", _jsx(Text, { color: pal.pink, children: "p" }), " ", t("key.pause"), " \u00B7", " ", _jsx(Text, { color: pal.pink, children: "+/-" }), " ", t("key.faster"), "/", t("key.slower"), " \u00B7 ", interval.toFixed(2), "s"] }) })] }));
+}

package/dist/cli.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { dirname } from "node:path";
+import { render } from "ink";
+import meow from "meow";
+import { execa } from "execa";
+import { App } from "./app.js";
+import { LanguageSelect } from "./components/LanguageSelect.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { detectLang, isLang, makeT } from "./i18n/index.js";
+import { isVariant, palette } from "./theme.js";
+import { isIconMode, makeIcons } from "./icons.js";
+const cli = meow(`
+  ${"lattice"} — real-time terminal dashboard for macOS Apple Silicon
+
+  Usage
+    $ lattice [options]
+
+  Options
+    --no-power        skip powermetrics/sudo (CPU/GPU/RAM/disk/net only)
+    --no-vtex         hide the VTEX panel (for non-VTEX users)
+    --repos           folder of git repos to show branches for
+                      (default: the parent of the current directory)
+    --interval, -i    refresh interval in seconds (default 1)
+    --procs, -n       number of top processes to show (default 8)
+    --icons           icon style: nerd | emoji | none (default nerd)
+    --lang            language: en | es | pt-BR (asked on first run)
+    --theme           pro | blade | buffy | lincoln | morbius | van-helsing
+    --version, -v
+    --help
+
+  Examples
+    $ lattice
+    $ lattice --no-power --icons emoji
+    $ lattice --lang es --theme blade
+`, {
+    importMeta: import.meta,
+    description: false,
+    flags: {
+        power: { type: "boolean", default: true },
+        vtex: { type: "boolean", default: true },
+        repos: { type: "string", default: "" },
+        interval: { type: "number", shortFlag: "i", default: 1 },
+        procs: { type: "number", shortFlag: "n", default: 8 },
+        icons: { type: "string", default: "" },
+        lang: { type: "string", default: "" },
+        theme: { type: "string", default: "" },
+    },
+});
+async function resolveLang() {
+    const cfg = loadConfig();
+    const flag = cli.flags.lang;
+    if (flag && isLang(flag)) {
+        saveConfig({ lang: flag });
+        return flag;
+    }
+    if (cfg.lang)
+        return cfg.lang;
+    // First run: ask, unless stdin isn't interactive.
+    if (!process.stdin.isTTY) {
+        const detected = detectLang();
+        saveConfig({ lang: detected });
+        return detected;
+    }
+    const variant = resolveTheme();
+    const chosen = await new Promise((resolve) => {
+        const app = render(_jsx(LanguageSelect, { pal: palette(variant), onSelect: (l) => {
+                app.unmount();
+                resolve(l);
+            } }));
+    });
+    saveConfig({ lang: chosen });
+    return chosen;
+}
+function resolveTheme() {
+    const flag = cli.flags.theme;
+    if (flag && isVariant(flag)) {
+        saveConfig({ theme: flag });
+        return flag;
+    }
+    return loadConfig().theme ?? "pro";
+}
+function resolveIcons() {
+    const flag = cli.flags.icons;
+    if (flag && isIconMode(flag)) {
+        saveConfig({ icons: flag });
+        return flag;
+    }
+    return loadConfig().icons ?? "nerd";
+}
+async function main() {
+    const lang = await resolveLang();
+    const variant = resolveTheme();
+    const iconMode = resolveIcons();
+    const t = makeT(lang);
+    const pal = palette(variant);
+    const icon = makeIcons(iconMode);
+    let usePower = cli.flags.power;
+    // Pre-authenticate sudo BEFORE the TUI takes over the terminal.
+    if (usePower) {
+        process.stdout.write(t("cli.sudoNeed") + "\n");
+        try {
+            await execa("sudo", ["-v"], { stdio: "inherit" });
+        }
+        catch {
+            process.stdout.write(t("cli.sudoFail") + "\n");
+            usePower = false;
+        }
+    }
+    const { waitUntilExit } = render(_jsx(App, { t: t, pal: pal, icon: icon, lang: lang, usePower: usePower, useVtex: cli.flags.vtex, gitDir: cli.flags.repos || dirname(process.cwd()), interval: cli.flags.interval, topN: cli.flags.procs }));
+    await waitUntilExit();
+}
+main().catch((e) => {
+    process.stderr.write(String(e) + "\n");
+    process.exit(1);
+});

package/dist/collectors/disks.js

@@ -0,0 +1,96 @@
+/**
+ * Per-disk activity & usage (no sudo).
+ *
+ * Lists each "real" mount — `/` and everything under `/Volumes/*` — with its
+ * space usage (from `systeminformation`) and live read/write throughput.
+ *
+ * Throughput comes from IOKit's cumulative byte counters, read via `ioreg`
+ * (same approach as gpu.ts — no sudo, non-blocking). Each APFS volume's mount
+ * device (e.g. `/dev/disk7s1`) maps to a whole disk (`disk7`); IOKit reports a
+ * `Bytes (Read)`/`Bytes (Write)` counter for that whole disk, including the
+ * synthesized APFS container disks. We diff successive samples to get bytes/sec,
+ * so the first sample reads as zero and later ones are accurate at the refresh
+ * interval.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import si from "systeminformation";
+const run = promisify(execFile);
+export class DisksCollector {
+    /** Previous cumulative counters per whole disk, for rate computation. */
+    prev = new Map();
+    async read() {
+        try {
+            const [sizes, counters] = await Promise.all([
+                si.fsSize().catch(() => []),
+                readDiskCounters().catch(() => ({})),
+            ]);
+            const now = Date.now();
+            const mounts = (sizes ?? []).filter((s) => s.fs?.startsWith("/dev/disk") && (s.mount === "/" || s.mount.startsWith("/Volumes/")));
+            const disks = mounts.map((s) => {
+                const device = wholeDisk(s.fs);
+                const cur = counters[device];
+                const prev = this.prev.get(device);
+                let readBps = 0;
+                let writeBps = 0;
+                if (cur && prev) {
+                    const dt = (now - prev.t) / 1000;
+                    if (dt > 0) {
+                        readBps = Math.max(0, (cur.r - prev.r) / dt);
+                        writeBps = Math.max(0, (cur.w - prev.w) / dt);
+                    }
+                }
+                return {
+                    mount: s.mount,
+                    device: device || s.fs,
+                    readBps,
+                    writeBps,
+                    usedBytes: s.used ?? 0,
+                    sizeBytes: s.size ?? 0,
+                    usePercent: s.use ?? 0,
+                };
+            });
+            // Remember the latest counters for the next delta.
+            for (const [dev, c] of Object.entries(counters))
+                this.prev.set(dev, { r: c.r, w: c.w, t: now });
+            // Root first, then /Volumes alphabetically.
+            disks.sort((a, b) => a.mount === "/" ? -1 : b.mount === "/" ? 1 : a.mount.localeCompare(b.mount));
+            return { disks };
+        }
+        catch {
+            return { disks: [] };
+        }
+    }
+}
+/** `/dev/disk7s1` → `disk7` (the whole disk IOKit reports counters for). */
+function wholeDisk(fs) {
+    const m = (fs ?? "").replace("/dev/", "").match(/^disk\d+/);
+    return m ? m[0] : "";
+}
+/**
+ * Cumulative read/write bytes per whole disk, from IOKit's
+ * IOBlockStorageDriver "Statistics". The block-driver counter uses the keys
+ * `Bytes (Read)`/`Bytes (Write)`; APFS filesystem-level stats use different
+ * keys and are ignored. The whole-disk BSD name follows its driver's stats.
+ */
+async function readDiskCounters() {
+    const { stdout } = await run("ioreg", ["-r", "-c", "IOBlockStorageDriver", "-w", "0", "-l"], {
+        maxBuffer: 1 << 24,
+    });
+    const out = {};
+    let pending = null;
+    for (const ln of stdout.split("\n")) {
+        const sm = ln.match(/"Statistics" = \{[^}]*"Bytes \(Read\)"=(\d+)/);
+        if (sm) {
+            const wm = ln.match(/"Bytes \(Write\)"=(\d+)/);
+            pending = { r: Number(sm[1]), w: wm ? Number(wm[1]) : 0 };
+            continue;
+        }
+        const bm = ln.match(/"BSD Name" = "(disk\d+)"\s*$/);
+        if (bm && pending) {
+            out[bm[1]] = pending;
+            pending = null;
+        }
+    }
+    return out;
+}