@zeluizr/lattice 2.0.0 → 2.1.0

package/dist/app.js

@@ -6,11 +6,12 @@ import { SystemCollector } from "./collectors/system.js";
 import { DisksCollector } from "./collectors/disks.js";
 import { GitCollector } from "./collectors/git.js";
 import { ZgitCollector } from "./collectors/zgit.js";
+import { HFCollector } from "./collectors/huggingface.js";
 import { readGpu } from "./collectors/gpu.js";
 import { readSensors } from "./collectors/sensors.js";
 import { TokenCollector } from "./collectors/tokens.js";
 import { readVtex } from "./collectors/vtex.js";
-import { coreCell, fmtTok, humanBytes, humanRate, sparkline, statusLevel } from "./format.js";
+import { agoShort, coreCell, fmtTok, humanBytes, humanRate, sparkline, statusLevel } from "./format.js";
 const MAX_HIST = 60;
 const push = (h, v) => [...h, v].slice(-MAX_HIST);
 const DEFAULT_INTERVAL = 1; // seconds between refreshes (adjust at runtime with +/-)
@@ -20,7 +21,7 @@ function timeStr() {
     return d.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit", second: "2-digit" });
 }
 export function App(props) {
-    const { t, pal, icon, repoRoots, zgitContainer } = props;
+    const { t, pal, icon, repoRoots, zgitContainer, hfCachePath } = props;
     const { exit } = useApp();
     const [sys, setSys] = useState(null);
     const [disks, setDisks] = useState(null);
@@ -30,6 +31,7 @@ export function App(props) {
     const [sensors, setSensors] = useState(null);
     const [tokens, setTokens] = useState(null);
     const [vtex, setVtex] = useState(null);
+    const [hf, setHf] = useState(null);
     const [hCpu, setHCpu] = useState([]);
     const [hMem, setHMem] = useState([]);
     const [hNet, setHNet] = useState([]);
@@ -44,6 +46,7 @@ export function App(props) {
     const gitRef = useRef(null);
     const zgitRef = useRef(null);
     const tokRef = useRef(null);
+    const hfRef = useRef(null);
     const pausedRef = useRef(false);
     const mounted = useRef(true);
     useEffect(() => {
@@ -57,6 +60,7 @@ export function App(props) {
         gitRef.current = new GitCollector(repoRoots);
         zgitRef.current = new ZgitCollector(zgitContainer);
         tokRef.current = new TokenCollector();
+        hfRef.current = new HFCollector(hfCachePath);
         const clock = setInterval(() => mounted.current && setNow(timeStr()), 1000);
         const onResize = () => setCols(process.stdout.columns || 100);
         process.stdout.on("resize", onResize);
@@ -94,11 +98,12 @@ export function App(props) {
     const refreshAux = useCallback(async () => {
         if (pausedRef.current || !tokRef.current)
             return;
-        const [tk, vx, gt, zg] = await Promise.all([
+        const [tk, vx, gt, zg, hfd] = await Promise.all([
             tokRef.current.read(),
             readVtex(),
             gitRef.current ? gitRef.current.read() : Promise.resolve(null),
             zgitRef.current ? zgitRef.current.read() : Promise.resolve(null),
+            hfRef.current ? hfRef.current.read() : Promise.resolve(null),
         ]);
         if (!mounted.current)
             return;
@@ -106,6 +111,7 @@ export function App(props) {
         setVtex(vx);
         setGit(gt);
         setZgit(zg);
+        setHf(hfd);
     }, []);
     useEffect(() => {
         refreshData();
@@ -170,6 +176,9 @@ export function App(props) {
     const gitTotal = git?.total ?? 0;
     const zgitServer = zgit?.available ? zgit : null;
     const showGit = gitTotal > 0 || !!zgitServer;
+    const hfModels = hf?.models ?? [];
+    const showHf = !!hf?.available;
+    const nowSec = Math.floor(Date.now() / 1000);
     const hostLabel = (r) => r.hostKind === "github"
         ? "GitHub"
         : r.hostKind === "zgit"
@@ -200,7 +209,12 @@ export function App(props) {
                                 }) }), _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: col2, 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", {
+                    }))] }), showHf && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.yellow, paddingX: 1, marginRight: 1, width: fullW, children: [_jsxs(Text, { color: pal.yellow, bold: true, children: [icon("hf"), " ", t("panel.hf")] }), _jsxs(Text, { color: pal.purple, bold: true, wrap: "truncate", children: [t("hf.model").padEnd(30), t("hf.size").padEnd(9), t("hf.type").padEnd(16), t("hf.state")] }), hfModels.map((mdl) => (_jsxs(Text, { wrap: "truncate", children: [mdl.id.slice(0, 29).padEnd(30), humanBytes(mdl.sizeBytes).padEnd(9), (mdl.modelType || "—").slice(0, 15).padEnd(16), mdl.active ? (_jsxs(Text, { color: pal.green, children: ["\u25CF ", t("hf.active"), " ", mdl.procName.slice(0, 14), " ", mdl.pid] })) : mdl.lastUsed > 0 ? (_jsx(Text, { color: pal.comment, children: t("hf.usedAgo", { ago: agoShort(mdl.lastUsed, nowSec) }) })) : (_jsx(Text, { color: pal.comment, children: t("hf.idle") }))] }, mdl.id))), _jsx(Text, { color: pal.comment, wrap: "truncate", children: t("hf.summary", {
+                            path: hf?.cachePath ?? "",
+                            size: humanBytes(hf?.totalBytes),
+                            n: hfModels.length,
+                            active: hf?.activeCount ?? 0,
+                        }) })] })), _jsxs(Box, { flexDirection: "row", children: [_jsxs(Panel, { title: `${icon("tokens")} ${t("panel.tokens")}`, color: pal.pink, width: col2, 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),

package/dist/cli.js

@@ -49,7 +49,7 @@ async function main() {
     const icon = makeIcons(cfg.icons ?? "nerd");
     const repoRoots = cfg.repoRoots?.length ? cfg.repoRoots : [dirname(process.cwd())];
     const zgitContainer = cfg.zgitContainer ?? "zgit";
-    const { waitUntilExit } = render(_jsx(App, { t: t, pal: pal, icon: icon, repoRoots: repoRoots, zgitContainer: zgitContainer }));
+    const { waitUntilExit } = render(_jsx(App, { t: t, pal: pal, icon: icon, repoRoots: repoRoots, zgitContainer: zgitContainer, hfCachePath: cfg.hfCachePath }));
     await waitUntilExit();
 }
 main().catch((e) => {

package/dist/collectors/huggingface.js

@@ -0,0 +1,170 @@
+/**
+ * Local HuggingFace hub cache — which models are installed, and which are live.
+ *
+ * The hub cache is the standard layout `<cache>/models--<org>--<name>/` with
+ * `refs/main` (the checked-out revision), `snapshots/<rev>/` (symlinks) and
+ * `blobs/<sha>` (the real file content). Enumerating models is pure filesystem
+ * work — no dependency on the `hf` CLI, so it keeps working under `npx`.
+ *
+ * Two usage signals are layered on top:
+ *   - "active" — a process currently holds one of the model's files open (a
+ *     single `lsof` pass; the file's path always contains the model's
+ *     `models--org--name` segment because each repo has its own `blobs/`).
+ *   - "lastUsed" — the atime of the model's largest blob (the weights), which
+ *     reflects the last real read. `statSync` reads metadata only, so polling it
+ *     never updates atime; the weights blob is used (never config.json) so our
+ *     own one-time config read can't pollute the signal.
+ *
+ * Fail-soft like every collector: any error returns the previous snapshot.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+const run = promisify(execFile);
+/** Resolve the hub cache dir: config → HF_HUB_CACHE → HF_HOME/hub → ~/.cache. */
+function resolveCachePath(override) {
+    if (override)
+        return override;
+    if (process.env.HF_HUB_CACHE)
+        return process.env.HF_HUB_CACHE;
+    if (process.env.HF_HOME)
+        return join(process.env.HF_HOME, "hub");
+    return join(homedir(), ".cache", "huggingface", "hub");
+}
+export class HFCollector {
+    inflight = false;
+    last;
+    cachePath;
+    // model_type is static per revision and reading config.json bumps its atime,
+    // so we read it once and cache it keyed by "<dirName>@<revision>".
+    typeCache = new Map();
+    constructor(override) {
+        this.cachePath = resolveCachePath(override);
+        this.last = { available: false, cachePath: this.cachePath, totalBytes: 0, activeCount: 0, models: [] };
+    }
+    async read() {
+        if (this.inflight)
+            return this.last;
+        this.inflight = true;
+        try {
+            if (!existsSync(this.cachePath)) {
+                this.last = { available: false, cachePath: this.cachePath, totalBytes: 0, activeCount: 0, models: [] };
+                return this.last;
+            }
+            const dirs = readdirSync(this.cachePath, { withFileTypes: true })
+                .filter((e) => e.isDirectory() && e.name.startsWith("models--"))
+                .map((e) => e.name);
+            const byDir = new Map();
+            const models = [];
+            for (const dirName of dirs) {
+                const m = this.readModel(dirName);
+                if (m) {
+                    models.push(m.model);
+                    byDir.set(dirName, m.model);
+                }
+            }
+            // One lsof pass marks the models whose files a process currently holds.
+            await this.markActive(byDir);
+            const totalBytes = models.reduce((a, m) => a + m.sizeBytes, 0);
+            const activeCount = models.filter((m) => m.active).length;
+            models.sort((a, b) => Number(b.active) - Number(a.active) || b.lastUsed - a.lastUsed || b.sizeBytes - a.sizeBytes);
+            this.last = { available: models.length > 0, cachePath: this.cachePath, totalBytes, activeCount, models };
+            return this.last;
+        }
+        catch {
+            return this.last;
+        }
+        finally {
+            this.inflight = false;
+        }
+    }
+    /** Size (sum of blobs), weights atime, model_type and revision for one repo. */
+    readModel(dirName) {
+        try {
+            const id = dirName.replace(/^models--/, "").replace(/--/g, "/");
+            const name = id.slice(id.lastIndexOf("/") + 1);
+            const base = join(this.cachePath, dirName);
+            // Full hash locates the snapshot dir; a short prefix is what we display.
+            const revFull = readFileSync(join(base, "refs", "main"), "utf8").trim();
+            const revision = revFull.slice(0, 12);
+            // One pass over blobs: total size + atime of the largest blob (weights).
+            let sizeBytes = 0;
+            let biggest = -1;
+            let lastUsed = 0;
+            const blobsDir = join(base, "blobs");
+            if (existsSync(blobsDir)) {
+                for (const f of readdirSync(blobsDir)) {
+                    try {
+                        const st = statSync(join(blobsDir, f));
+                        if (!st.isFile())
+                            continue;
+                        sizeBytes += st.size;
+                        if (st.size > biggest) {
+                            biggest = st.size;
+                            lastUsed = Math.floor(st.atimeMs / 1000);
+                        }
+                    }
+                    catch {
+                        // skip unreadable blob
+                    }
+                }
+            }
+            const modelType = this.readType(dirName, revFull, base);
+            return {
+                model: { id, name, sizeBytes, modelType, revision, active: false, procName: "", pid: 0, lastUsed },
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** config.json `model_type`, cached per revision (its read would bump atime). */
+    readType(dirName, revision, base) {
+        const key = `${dirName}@${revision}`;
+        const hit = this.typeCache.get(key);
+        if (hit !== undefined)
+            return hit;
+        let modelType = "";
+        try {
+            const cfg = JSON.parse(readFileSync(join(base, "snapshots", revision, "config.json"), "utf8"));
+            if (typeof cfg.model_type === "string")
+                modelType = cfg.model_type;
+        }
+        catch {
+            // no config.json (e.g. some MLX repos) — leave type blank
+        }
+        this.typeCache.set(key, modelType);
+        return modelType;
+    }
+    /** Single `lsof` pass; tag each model a process is holding files open for. */
+    async markActive(byDir) {
+        if (byDir.size === 0)
+            return;
+        // `lsof -nP` often exits non-zero with warnings about other users' procs
+        // while still printing useful stdout — keep the partial output from the error.
+        const { stdout } = await run("lsof", ["-nP", "-F", "pcn"], { maxBuffer: 1 << 24 }).catch((e) => ({ stdout: e?.stdout ?? "" }));
+        let pid = 0;
+        let cmd = "";
+        for (const line of stdout.split("\n")) {
+            const tag = line[0];
+            const val = line.slice(1);
+            if (tag === "p")
+                pid = Number(val) || 0;
+            else if (tag === "c")
+                cmd = val;
+            else if (tag === "n") {
+                const seg = val.match(/\/(models--[^/]+)\//);
+                if (!seg)
+                    continue;
+                const model = byDir.get(seg[1]);
+                if (model && !model.active) {
+                    model.active = true;
+                    model.pid = pid;
+                    model.procName = cmd;
+                }
+            }
+        }
+    }
+}

package/dist/config.js

@@ -27,6 +27,8 @@ export function loadConfig() {
         }
         if (typeof raw.zgitContainer === "string" && raw.zgitContainer)
             cfg.zgitContainer = raw.zgitContainer;
+        if (typeof raw.hfCachePath === "string" && raw.hfCachePath)
+            cfg.hfCachePath = raw.hfCachePath;
         return cfg;
     }
     catch {

package/dist/format.js

@@ -45,6 +45,20 @@ export function sparkline(history, width = 0) {
     })
         .join("");
 }
+/** Short relative time ("now" / "3m" / "2h" / "5d") from a unix-seconds stamp. */
+export function agoShort(unixSeconds, nowSeconds) {
+    const ts = Number(unixSeconds || 0);
+    if (!ts)
+        return "—";
+    const s = Math.max(0, Math.floor(nowSeconds - ts));
+    if (s < 60)
+        return "now";
+    if (s < 3600)
+        return `${Math.floor(s / 60)}m`;
+    if (s < 86400)
+        return `${Math.floor(s / 3600)}h`;
+    return `${Math.floor(s / 86400)}d`;
+}
 /** Pick a status level by thresholds (mirrors the Python status() helper). */
 export function statusLevel(value, warn, crit) {
     const v = Number(value || 0);

package/dist/i18n/en.js

@@ -11,6 +11,7 @@ export const en = {
     "panel.gpu": "GPU",
     "panel.tokens": "AI · TOKENS TODAY",
     "panel.vtex": "VTEX",
+    "panel.hf": "HUGGINGFACE",
     "panel.procs": "PROCESSES",
     "status.cpu.ok": "calm",
     "status.cpu.warn": "busy",
@@ -64,6 +65,15 @@ export const en = {
     "vtex.workspace": "Workspace",
     "vtex.notConnected": "not connected",
     "vtex.signin": "Sign in with: vtex login <account>",
+    "hf.model": "MODEL",
+    "hf.size": "SIZE",
+    "hf.type": "TYPE",
+    "hf.state": "STATE",
+    "hf.active": "active",
+    "hf.idle": "idle",
+    "hf.usedAgo": "used {ago} ago",
+    "hf.empty": "no models cached",
+    "hf.summary": "{path} · {size} · {n} models · {active} active",
     "proc.cpu": "CPU%",
     "proc.mem": "MEM",
     "proc.pid": "PID",

package/dist/i18n/es.js

@@ -10,6 +10,7 @@ export const es = {
     "panel.gpu": "GPU",
     "panel.tokens": "IA · TOKENS HOY",
     "panel.vtex": "VTEX",
+    "panel.hf": "HUGGINGFACE",
     "panel.procs": "PROCESOS",
     "status.cpu.ok": "tranquilo",
     "status.cpu.warn": "ocupado",
@@ -63,6 +64,15 @@ export const es = {
     "vtex.workspace": "Workspace",
     "vtex.notConnected": "no conectado",
     "vtex.signin": "Entra con: vtex login <cuenta>",
+    "hf.model": "MODELO",
+    "hf.size": "TAMAÑO",
+    "hf.type": "TIPO",
+    "hf.state": "ESTADO",
+    "hf.active": "activo",
+    "hf.idle": "inactivo",
+    "hf.usedAgo": "usado hace {ago}",
+    "hf.empty": "sin modelos en caché",
+    "hf.summary": "{path} · {size} · {n} modelos · {active} activos",
     "proc.cpu": "CPU%",
     "proc.mem": "MEM",
     "proc.pid": "PID",

package/dist/i18n/pt-BR.js

@@ -10,6 +10,7 @@ export const ptBR = {
     "panel.gpu": "GPU",
     "panel.tokens": "IA · TOKENS HOJE",
     "panel.vtex": "VTEX",
+    "panel.hf": "HUGGINGFACE",
     "panel.procs": "PROCESSOS",
     "status.cpu.ok": "tranquilo",
     "status.cpu.warn": "ocupado",
@@ -63,6 +64,15 @@ export const ptBR = {
     "vtex.workspace": "Workspace",
     "vtex.notConnected": "não conectado",
     "vtex.signin": "Entre com: vtex login <conta>",
+    "hf.model": "MODELO",
+    "hf.size": "TAMANHO",
+    "hf.type": "TIPO",
+    "hf.state": "ESTADO",
+    "hf.active": "ativo",
+    "hf.idle": "ocioso",
+    "hf.usedAgo": "usado há {ago}",
+    "hf.empty": "nenhum modelo em cache",
+    "hf.summary": "{path} · {size} · {n} modelos · {active} ativos",
     "proc.cpu": "CPU%",
     "proc.mem": "MEM",
     "proc.pid": "PID",

package/dist/icons.js

@@ -19,6 +19,7 @@ const NERD = {
     tokens: "", // money
     vtex: "", // shopping-cart
     git: "\uF126", // code-fork
+    hf: "\uF1B3", // cubes (model artifacts)
     proc: "", // tasks
     clock: "", // clock
 };
@@ -36,6 +37,7 @@ const EMOJI = {
     tokens: "🪙",
     vtex: "🛒",
     git: "🌿",
+    hf: "🤗",
     proc: "📋",
     clock: "🕐",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeluizr/lattice",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Real-time terminal dashboard for macOS Apple Silicon — GPU, power, temperatures/fans, per-disk I/O (incl. /Volumes), network, memory, processes, and AI token cost.",
   "type": "module",
   "bin": {