@zeluizr/lattice 1.0.0

package/dist/collectors/git.js

@@ -0,0 +1,89 @@
+/**
+ * Active git branches for the repos in a folder (no sudo).
+ *
+ * Scans the immediate subdirectories of `root`, keeps the ones that are git
+ * repositories, and reports each repo's current branch plus its state —
+ * dirty/clean and ahead/behind its upstream — from a single
+ * `git status --porcelain=v2 --branch` per repo.
+ *
+ * Cheap to discover (one readdir + a stat per child) but each repo costs a git
+ * invocation, so we cap the count, bound concurrency, and skip overlapping
+ * reads (returning the previous result while one is still in flight).
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, basename } from "node:path";
+const run = promisify(execFile);
+const MAX_REPOS = 24;
+const CONCURRENCY = 8;
+export class GitCollector {
+    root;
+    inflight = false;
+    last;
+    constructor(root) {
+        this.root = root;
+        this.last = { root, repos: [], truncated: false };
+    }
+    async read() {
+        if (this.inflight)
+            return this.last;
+        this.inflight = true;
+        try {
+            const entries = await readdir(this.root, { withFileTypes: true }).catch(() => []);
+            const dirs = entries
+                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                .map((e) => join(this.root, e.name))
+                .filter((p) => existsSync(join(p, ".git")))
+                .sort();
+            const truncated = dirs.length > MAX_REPOS;
+            const pick = dirs.slice(0, MAX_REPOS);
+            const repos = [];
+            for (let i = 0; i < pick.length; i += CONCURRENCY) {
+                const batch = pick.slice(i, i + CONCURRENCY);
+                const results = await Promise.all(batch.map((d) => readRepo(d).catch(() => null)));
+                for (const r of results)
+                    if (r)
+                        repos.push(r);
+            }
+            repos.sort((a, b) => a.name.localeCompare(b.name));
+            this.last = { root: this.root, repos, truncated };
+            return this.last;
+        }
+        catch {
+            return this.last;
+        }
+        finally {
+            this.inflight = false;
+        }
+    }
+}
+async function readRepo(dir) {
+    const { stdout } = await run("git", ["-C", dir, "status", "--porcelain=v2", "--branch"], {
+        maxBuffer: 1 << 20,
+    });
+    let branch = "?";
+    let ahead = 0;
+    let behind = 0;
+    let detached = false;
+    let dirty = false;
+    for (const ln of stdout.split("\n")) {
+        if (ln.startsWith("# branch.head ")) {
+            branch = ln.slice("# branch.head ".length).trim();
+            if (branch === "(detached)")
+                detached = true;
+        }
+        else if (ln.startsWith("# branch.ab ")) {
+            const m = ln.match(/\+(\d+)\s+-(\d+)/);
+            if (m) {
+                ahead = Number(m[1]);
+                behind = Number(m[2]);
+            }
+        }
+        else if (ln && !ln.startsWith("#")) {
+            dirty = true;
+        }
+    }
+    return { name: basename(dir), branch, ahead, behind, detached, dirty };
+}

package/dist/collectors/gpu.js

@@ -0,0 +1,28 @@
+/**
+ * Apple Silicon GPU via `ioreg` (no sudo). Parses utilization and system
+ * memory in use / allocated from the IOAccelerator registry entry.
+ */
+import { execa } from "execa";
+const EMPTY = { utilPct: null, memUsedBytes: null, memAllocBytes: null };
+export async function readGpu() {
+    try {
+        const { stdout } = await execa("ioreg", ["-r", "-d", "1", "-w", "0", "-c", "IOAccelerator"], {
+            timeout: 2000,
+        });
+        const get = (key) => {
+            const m = stdout.match(new RegExp(`"${escapeRe(key)}"\\s*=\\s*(\\d+)`));
+            return m ? Number(m[1]) : null;
+        };
+        return {
+            utilPct: get("Device Utilization %"),
+            memUsedBytes: get("In use system memory"),
+            memAllocBytes: get("Alloc system memory"),
+        };
+    }
+    catch {
+        return { ...EMPTY };
+    }
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/collectors/power.js

@@ -0,0 +1,105 @@
+/**
+ * Power / frequency via `powermetrics` (REQUIRES sudo).
+ *
+ * powermetrics streams plist samples on stdout separated by a NUL byte (\x00).
+ * We run it as a long-lived subprocess and keep the latest parsed sample. Power
+ * fields arrive in milliwatts; we convert to watts.
+ */
+import { spawn } from "node:child_process";
+import * as plist from "plist";
+import bplist from "bplist-parser";
+function parseSample(raw) {
+    if (raw.length === 0)
+        return null;
+    try {
+        // binary plist?
+        if (raw.length >= 6 && raw.subarray(0, 6).toString("latin1") === "bplist") {
+            const arr = bplist.parseBuffer(raw);
+            return arr?.[0] ?? null;
+        }
+        // XML plist
+        const text = raw.toString("utf8");
+        const start = text.indexOf("<?xml");
+        if (start === -1)
+            return null;
+        return plist.parse(text.slice(start));
+    }
+    catch {
+        return null;
+    }
+}
+function mwToW(d, key) {
+    const v = d?.[key];
+    return typeof v === "number" ? v / 1000 : null;
+}
+export class PowerCollector {
+    intervalMs;
+    latest = null;
+    error = null;
+    proc = null;
+    buf = Buffer.alloc(0);
+    stopped = false;
+    constructor(intervalMs = 1000) {
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        try {
+            this.proc = spawn("sudo", [
+                "powermetrics",
+                "--samplers",
+                "cpu_power,gpu_power,thermal",
+                "-i",
+                String(this.intervalMs),
+                "-f",
+                "plist",
+            ], { stdio: ["ignore", "pipe", "ignore"] });
+        }
+        catch (e) {
+            this.error = `failed to start powermetrics: ${e}`;
+            return;
+        }
+        this.proc.stdout?.on("data", (chunk) => {
+            if (this.stopped)
+                return;
+            this.buf = Buffer.concat([this.buf, chunk]);
+            let nul;
+            while ((nul = this.buf.indexOf(0x00)) !== -1) {
+                const raw = this.buf.subarray(0, nul);
+                this.buf = this.buf.subarray(nul + 1);
+                const sample = parseSample(raw);
+                if (sample)
+                    this.latest = sample;
+            }
+        });
+        this.proc.on("error", (e) => {
+            this.error = String(e);
+        });
+    }
+    read() {
+        const d = this.latest;
+        if (!d)
+            return null;
+        const proc = d.processor ?? {};
+        const gpu = d.gpu ?? {};
+        const freqHz = gpu.freq_hz;
+        return {
+            cpuW: mwToW(proc, "cpu_power"),
+            gpuW: mwToW(proc, "gpu_power"),
+            aneW: mwToW(proc, "ane_power"),
+            packageW: mwToW(proc, "combined_power") ?? mwToW(proc, "package_power"),
+            gpuFreqMhz: typeof freqHz === "number" ? freqHz / 1e6 : null,
+            thermal: d.thermal_pressure ?? null,
+        };
+    }
+    stop() {
+        this.stopped = true;
+        if (this.proc) {
+            try {
+                this.proc.kill("SIGTERM");
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}

package/dist/collectors/sensors.js

@@ -0,0 +1,80 @@
+/**
+ * Temperatures (CPU/GPU) and fans via the native lattice-smc helper (no sudo),
+ * plus battery via systeminformation + ioreg. On any failure the sensors panel
+ * degrades gracefully without taking the app down.
+ */
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { execa } from "execa";
+import si from "systeminformation";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const BIN_NAME = "lattice-smc";
+const PLATFORM_DIR = `${process.platform}-${process.arch}`;
+function locateHelper() {
+    const candidates = [
+        // dist/collectors -> package root
+        join(HERE, "..", "..", "prebuilds", PLATFORM_DIR, BIN_NAME),
+        // running from source layout
+        join(HERE, "..", "..", "..", "prebuilds", PLATFORM_DIR, BIN_NAME),
+        join(process.cwd(), "prebuilds", PLATFORM_DIR, BIN_NAME),
+    ];
+    return candidates.find((p) => existsSync(p)) ?? null;
+}
+const HELPER = locateHelper();
+export function sensorsAvailable() {
+    return HELPER !== null;
+}
+export async function readSensors() {
+    if (!HELPER) {
+        return { ok: false, error: "smc helper not found", cpuTemp: null, gpuTemp: null, fans: [] };
+    }
+    try {
+        const { stdout } = await execa(HELPER, [], { timeout: 1500 });
+        const j = JSON.parse(stdout);
+        if (!j.ok) {
+            return { ok: false, error: j.error, cpuTemp: null, gpuTemp: null, fans: [] };
+        }
+        return {
+            ok: true,
+            cpuTemp: j.cpu_temp ?? null,
+            gpuTemp: j.gpu_temp ?? null,
+            fans: Array.isArray(j.fans) ? j.fans : [],
+        };
+    }
+    catch (e) {
+        return { ok: false, error: String(e), cpuTemp: null, gpuTemp: null, fans: [] };
+    }
+}
+export async function readBattery() {
+    try {
+        const b = await si.battery();
+        if (!b || !b.hasBattery)
+            return { present: false };
+        const health = b.maxCapacity && b.designedCapacity ? (b.maxCapacity / b.designedCapacity) * 100 : null;
+        let tempC = null;
+        try {
+            const { stdout } = await execa("ioreg", ["-rn", "AppleSmartBattery", "-w", "0"], {
+                timeout: 1500,
+            });
+            const m = stdout.match(/"Temperature"\s*=\s*(-?\d+)/);
+            if (m)
+                tempC = Number(m[1]) / 100;
+        }
+        catch {
+            // optional
+        }
+        return {
+            present: true,
+            percent: b.percent,
+            plugged: Boolean(b.acConnected),
+            charging: Boolean(b.isCharging),
+            cycles: b.cycleCount ?? null,
+            health,
+            tempC,
+        };
+    }
+    catch {
+        return { present: false };
+    }
+}

package/dist/collectors/system.js

@@ -0,0 +1,71 @@
+/**
+ * System metrics via `systeminformation` (no sudo): CPU load, memory/swap,
+ * disk & network throughput, '/' usage and the top processes by CPU.
+ *
+ * systeminformation computes per-second rates (network/disk) relative to the
+ * previous call, so the first sample may be approximate; subsequent ones are
+ * accurate at the configured refresh interval.
+ */
+import si from "systeminformation";
+export class SystemCollector {
+    topN;
+    constructor(topN = 8) {
+        this.topN = topN;
+    }
+    async read() {
+        const [load, mem, fs, net, sizes, procs] = await Promise.all([
+            si.currentLoad().catch(() => null),
+            si.mem().catch(() => null),
+            si.fsStats().catch(() => null),
+            si.networkStats().catch(() => null),
+            si.fsSize().catch(() => null),
+            si.processes().catch(() => null),
+        ]);
+        const cpuTotal = load?.currentLoad ?? 0;
+        const cpuPer = (load?.cpus ?? []).map((c) => c.load ?? 0);
+        const memTotal = mem?.total ?? 0;
+        const memAvail = mem?.available ?? mem?.free ?? 0;
+        const memUsed = Math.max(0, memTotal - memAvail);
+        const memPercent = memTotal > 0 ? (memUsed / memTotal) * 100 : 0;
+        const swapTotal = mem?.swaptotal ?? 0;
+        const swapPercent = swapTotal > 0 ? ((mem?.swapused ?? 0) / swapTotal) * 100 : 0;
+        const diskReadBps = nonNeg(fs?.rx_sec);
+        const diskWriteBps = nonNeg(fs?.wx_sec);
+        let netRecvBps = 0;
+        let netSentBps = 0;
+        for (const n of net ?? []) {
+            netRecvBps += nonNeg(n.rx_sec);
+            netSentBps += nonNeg(n.tx_sec);
+        }
+        const root = (sizes ?? []).find((s) => s.mount === "/") ?? (sizes ?? [])[0];
+        const diskUsagePercent = root?.use ?? 0;
+        const list = procs?.list ?? [];
+        const top = list
+            .map((p) => ({
+            cpu: p.cpu ?? 0,
+            pid: p.pid ?? 0,
+            name: p.name ?? "?",
+            // memRss is in KB on most platforms; fall back to mem% of total RAM.
+            rss: p.memRss ? p.memRss * 1024 : Math.round(((p.mem ?? 0) / 100) * memTotal),
+        }))
+            .sort((a, b) => b.cpu - a.cpu)
+            .slice(0, this.topN);
+        return {
+            cpuTotal,
+            cpuPer,
+            memPercent,
+            memUsed,
+            memTotal,
+            swapPercent,
+            diskReadBps,
+            diskWriteBps,
+            netRecvBps,
+            netSentBps,
+            diskUsagePercent,
+            procs: top,
+        };
+    }
+}
+function nonNeg(v) {
+    return typeof v === "number" && v > 0 ? v : 0;
+}

package/dist/collectors/tokens.js

@@ -0,0 +1,185 @@
+/**
+ * Claude Code token usage / cost for TODAY, read from local logs.
+ *
+ * Claude Code writes transcripts to ~/.claude/projects/**\/*.jsonl. Each
+ * assistant line carries message.usage (input/output + cache tokens), the model
+ * and an ISO timestamp. We sum everything from the local day and compute cost.
+ *
+ * Pricing (USD per 1M tokens) — source: Anthropic claude-api skill (Jun 2026):
+ *   Opus 4.8   in $5  out $25  cache-write $6.25  cache-read $0.50
+ *   Sonnet 4.6 in $3  out $15  cache-write $3.75  cache-read $0.30
+ *   Haiku 4.5  in $1  out $5   cache-write $1.25  cache-read $0.10
+ *
+ * Performance: on first read we skip files not modified today; afterwards we
+ * tail only the new bytes of each file.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readdir, stat, open } from "node:fs/promises";
+const PRICING = {
+    opus: { in: 5.0, out: 25.0, cw: 6.25, cr: 0.5 },
+    sonnet: { in: 3.0, out: 15.0, cw: 3.75, cr: 0.3 },
+    haiku: { in: 1.0, out: 5.0, cw: 1.25, cr: 0.1 },
+};
+function family(model) {
+    const m = (model || "").toLowerCase();
+    if (m.includes("opus"))
+        return "opus";
+    if (m.includes("sonnet"))
+        return "sonnet";
+    if (m.includes("haiku"))
+        return "haiku";
+    return "opus"; // conservative default
+}
+function localDateISO(d) {
+    const y = d.getFullYear();
+    const mo = String(d.getMonth() + 1).padStart(2, "0");
+    const da = String(d.getDate()).padStart(2, "0");
+    return `${y}-${mo}-${da}`;
+}
+function zero() {
+    return {
+        input: 0,
+        output: 0,
+        cacheW: 0,
+        cacheR: 0,
+        cost: 0,
+        webSearch: 0,
+        webFetch: 0,
+        messages: 0,
+        byModel: {},
+    };
+}
+export class TokenCollector {
+    root;
+    offsets = new Map();
+    day = null;
+    totals = zero();
+    constructor(root) {
+        this.root = root ?? join(homedir(), ".claude", "projects");
+    }
+    async read() {
+        const now = new Date();
+        const today = localDateISO(now);
+        if (today !== this.day) {
+            this.day = today;
+            this.offsets.clear();
+            this.totals = zero();
+        }
+        const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+        let files = [];
+        try {
+            const entries = await readdir(this.root, { recursive: true, withFileTypes: true });
+            files = entries
+                .filter((e) => e.isFile() && e.name.endsWith(".jsonl"))
+                .map((e) => join(e.parentPath, e.name));
+        }
+        catch {
+            return this.totals;
+        }
+        for (const path of files) {
+            let size;
+            let mtimeMs;
+            try {
+                const st = await stat(path);
+                size = st.size;
+                mtimeMs = st.mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            let off = this.offsets.get(path);
+            if (off === undefined) {
+                if (mtimeMs < midnight) {
+                    this.offsets.set(path, size); // nothing from today here
+                    continue;
+                }
+                off = 0;
+            }
+            if (size < off)
+                off = 0; // rotated / truncated
+            if (size === off)
+                continue;
+            let buf;
+            try {
+                const fh = await open(path, "r");
+                try {
+                    const length = size - off;
+                    const b = Buffer.alloc(length);
+                    await fh.read(b, 0, length, off);
+                    buf = b;
+                }
+                finally {
+                    await fh.close();
+                }
+            }
+            catch {
+                continue;
+            }
+            let data = buf;
+            if (data.length && data[data.length - 1] !== 0x0a) {
+                const cut = data.lastIndexOf(0x0a);
+                if (cut === -1)
+                    continue; // no complete line yet; keep offset
+                this.offsets.set(path, off + cut + 1);
+                data = data.subarray(0, cut + 1);
+            }
+            else {
+                this.offsets.set(path, size);
+            }
+            for (const line of data.toString("utf8").split("\n")) {
+                if (line.trim())
+                    this.consume(line, today);
+            }
+        }
+        return this.totals;
+    }
+    consume(line, today) {
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const ts = o?.timestamp;
+        if (!ts)
+            return;
+        let d;
+        try {
+            d = localDateISO(new Date(ts));
+        }
+        catch {
+            return;
+        }
+        if (d !== today)
+            return;
+        const u = o?.message?.usage;
+        if (!u)
+            return;
+        const fam = family(o?.message?.model);
+        const p = PRICING[fam];
+        const i = u.input_tokens || 0;
+        const out = u.output_tokens || 0;
+        const cw = u.cache_creation_input_tokens || 0;
+        const cr = u.cache_read_input_tokens || 0;
+        const cost = (i * p.in + out * p.out + cw * p.cw + cr * p.cr) / 1_000_000;
+        const t = this.totals;
+        t.input += i;
+        t.output += out;
+        t.cacheW += cw;
+        t.cacheR += cr;
+        t.cost += cost;
+        t.messages += 1;
+        const stu = u.server_tool_use || {};
+        t.webSearch += stu.web_search_requests || 0;
+        t.webFetch += stu.web_fetch_requests || 0;
+        const bm = t.byModel[fam] ?? { in: 0, out: 0, cw: 0, cr: 0, cost: 0 };
+        bm.in += i;
+        bm.out += out;
+        bm.cw += cw;
+        bm.cr += cr;
+        bm.cost += cost;
+        t.byModel[fam] = bm;
+    }
+}

package/dist/collectors/types.js

@@ -0,0 +1,2 @@
+/** Shared data shapes produced by the collectors. */
+export {};

package/dist/collectors/vtex.js

@@ -0,0 +1,37 @@
+/**
+ * VTEX CLI session status, read from its configstore file. No sudo, no network.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { execa } from "execa";
+const CONFIG = join(homedir(), ".config", "configstore", "vtex.json");
+async function whichVtex() {
+    try {
+        const { stdout } = await execa("which", ["vtex"], { timeout: 1500 });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readVtex() {
+    const path = await whichVtex();
+    const installed = path !== null;
+    let account = null;
+    let login = null;
+    let workspace = null;
+    let token = null;
+    try {
+        const raw = JSON.parse(await readFile(CONFIG, "utf8"));
+        account = raw.account ?? null;
+        login = raw.login ?? null;
+        workspace = raw.workspace ?? null;
+        token = raw.token ?? null;
+    }
+    catch {
+        // file missing/unreadable → treated as logged out
+    }
+    const loggedIn = Boolean(account && (token || login));
+    return { installed, path, account, login, workspace, loggedIn };
+}

package/dist/components/LanguageSelect.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { LANGS } from "../i18n/index.js";
+/** First-run language picker. Trilingual prompt so it reads for everyone. */
+export function LanguageSelect({ pal, onSelect, }) {
+    const [index, setIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.upArrow || input === "k")
+            setIndex((i) => (i - 1 + LANGS.length) % LANGS.length);
+        else if (key.downArrow || input === "j")
+            setIndex((i) => (i + 1) % LANGS.length);
+        else if (key.return)
+            onSelect(LANGS[index].code);
+        else {
+            const n = Number(input);
+            if (n >= 1 && n <= LANGS.length)
+                onSelect(LANGS[n - 1].code);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: pal.purple, paddingX: 2, paddingY: 1, children: [_jsx(Text, { color: pal.purple, bold: true, children: "lattice" }), _jsx(Text, { color: pal.comment, children: "Choose your language \u00B7 Elige tu idioma \u00B7 Escolha seu idioma" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: LANGS.map((l, i) => {
+                    const active = i === index;
+                    return (_jsxs(Text, { color: active ? pal.cyan : pal.foreground, children: [active ? "❯ " : "  ", i + 1, ". ", l.label] }, l.code));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: pal.comment, children: "\u2191/\u2193 move \u00B7 Enter select \u00B7 1\u20133 quick pick" }) })] }));
+}

package/dist/components/Panel.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+/** A bordered card with a colored title, matching the original Dracula Pro look. */
+export function Panel({ title, color, children, width, minHeight, }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, paddingX: 1, marginRight: 1, flexGrow: width ? 0 : 1, flexShrink: 0, width: width, minHeight: minHeight, children: [_jsx(Text, { color: color, bold: true, wrap: "truncate", children: title }), children] }));
+}

package/dist/config.js

@@ -0,0 +1,42 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { isLang } from "./i18n/index.js";
+import { isVariant } from "./theme.js";
+const DIR = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "lattice");
+const FILE = join(DIR, "config.json");
+export function configPath() {
+    return FILE;
+}
+export function loadConfig() {
+    try {
+        if (!existsSync(FILE))
+            return {};
+        const raw = JSON.parse(readFileSync(FILE, "utf8"));
+        const cfg = {};
+        if (raw.lang && isLang(raw.lang))
+            cfg.lang = raw.lang;
+        if (raw.theme && isVariant(raw.theme))
+            cfg.theme = raw.theme;
+        if (raw.icons === "nerd" || raw.icons === "emoji" || raw.icons === "none")
+            cfg.icons = raw.icons;
+        return cfg;
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(cfg) {
+    try {
+        mkdirSync(DIR, { recursive: true });
+        const current = loadConfig();
+        writeFileSync(FILE, JSON.stringify({ ...current, ...cfg }, null, 2) + "\n", "utf8");
+    }
+    catch {
+        // best effort — config persistence is non-critical
+    }
+}
+/** True when no language has been chosen yet (drives the first-run picker). */
+export function needsLanguageSetup() {
+    return !loadConfig().lang;
+}