dexterm-cli 0.1.1 → 0.1.3

package/dist/packages/cli/src/live/signals.js

@@ -0,0 +1,109 @@
+// dexterm — LIVE holder/rug SIGNALS binding (task-1404). Turns the open token's repeatedly-refreshed holder and
+// safety reads (market/authorities/rugcheck panels + the wallet-intel scan + the fast-lane bonding curve) into
+// SIGNAL events through the pure @dexterm/data LiveSignalsEngine, keeps a small per-mint log for the token screen,
+// and exposes the latest numeric values as RULE FIELDS so every signal is an alert trigger (task-1398 pattern).
+//
+// It owns no timers and does no I/O: the UI loop / LiveContext calls observe() whenever the token, the intel scan
+// or a fast-lane push changed something. The engine dedups (only a threshold-crossing change emits), so calling it
+// on every redraw is cheap. Read-only: nothing here trades or signs.
+import { LiveSignalsEngine, bondingProgress, } from '../../../data/src/index.js';
+/** Max signals kept per mint for the token-screen strip (newest first). */
+export const SIGNALS_LOG_MAX = 40;
+function fromPanel(p, value, fallbackSource) {
+    if (!p || value == null || !Number.isFinite(value) || p.fetchedAt == null)
+        return null;
+    return { value, source: p.via ?? fallbackSource, fetchedAt: p.fetchedAt, stale: p.stale || p.state === 'error' };
+}
+function authFromPanel(p, present) {
+    if (!p || present == null || p.fetchedAt == null)
+        return null;
+    return { present, source: p.via ?? 'authorities', fetchedAt: p.fetchedAt, stale: p.stale || p.state === 'error' };
+}
+function fromIntel(value, intel) {
+    if (value == null || !Number.isFinite(value) || !intel || intel.fetchedAt == null)
+        return null;
+    return { value, source: intel.via ?? 'helius', fetchedAt: intel.fetchedAt, stale: false };
+}
+/**
+ * Build one observation from the token view + intel scan + fast-lane curve. Each field keeps its OWN source and
+ * fetch time so a signal is honest about where it came from and how old the data is. The richer wallet-intel
+ * figures (ex-pool top-10, creator %, bundled, snipers, fresh, cluster) are preferred when the scan has landed;
+ * otherwise the panel reads (Jupiter audit top-10/dev) stand in. Pure + exported for the tests.
+ */
+export function buildObservation(inputs, now) {
+    const v = inputs.view;
+    const I = inputs.intel?.analysis?.insights ?? null;
+    const panels = v.panels ?? {};
+    const obs = { mint: v.mint, at: now };
+    // top-10 concentration (pools excluded): the scan's ex-pool figure first, else the holders panel's top-10.
+    obs.top10 = (I && typeof I.top10.exPool === 'number' ? fromIntel(I.top10.exPool, inputs.intel) : null) ?? fromPanel(panels.holders, v.top10, 'holders');
+    // creator / dev share: the scan's creatorPctNow first, else the market panel's Jupiter audit devPct.
+    obs.dev = (I ? fromIntel(I.dev.creatorPctNow, inputs.intel) : null) ?? fromPanel(panels.market, v.dev, 'jupiter');
+    // bundled / snipers / fresh / cluster only exist once the launch window / funders were read (Helius).
+    if (I && I.coverage.launchTxs > 0) {
+        obs.bundled = fromIntel(I.bundle.bundlePctOfTopSample, inputs.intel);
+        obs.snipers = fromIntel(I.snipers.count, inputs.intel);
+    }
+    if (I && I.coverage.fundingLookups > 0)
+        obs.fresh = fromIntel(I.fresh.freshAtBuyPctOfTopSample, inputs.intel);
+    const cluster = inputs.intel?.analysis?.clusters?.[0]?.pct ?? null;
+    obs.cluster = fromIntel(cluster, inputs.intel);
+    // LP locked (RugCheck), liquidity (market), mint/freeze authority (authorities panel).
+    obs.lpLocked = fromPanel(panels.rugcheck, v.lpLocked, 'rugcheck');
+    obs.liq = fromPanel(panels.market, v.liq, 'market');
+    obs.mintAuth = authFromPanel(panels.authorities, v.mintAuth);
+    obs.freezeAuth = authFromPanel(panels.authorities, v.freezeAuth);
+    // bonding-curve progress + migration from the on-chain fast-lane push (sub-second), when streaming.
+    if (inputs.curve) {
+        const bp = bondingProgress(inputs.curve.curve.vToken);
+        if (bp != null)
+            obs.bonding = { value: bp, source: 'onchain-curve', fetchedAt: inputs.curve.at, stale: false };
+        obs.migrated = { value: inputs.curve.curve.complete, source: 'onchain-curve', fetchedAt: inputs.curve.at, stale: false };
+    }
+    return obs;
+}
+export class LiveSignalsLive {
+    engine;
+    now;
+    onSignal;
+    logByMint = new Map();
+    /** Signals emitted this session (all mints), newest last — a cheap counter/feed for the smoke script + tests. */
+    emitted = [];
+    constructor(opts = {}) {
+        this.engine = new LiveSignalsEngine({ thresholds: opts.thresholds });
+        this.now = opts.now ?? (() => Date.now());
+        this.onSignal = opts.onSignal;
+    }
+    /** Observe one moment of a token's state; records and returns any new signals. */
+    observe(inputs) {
+        const obs = buildObservation(inputs, this.now());
+        const sigs = this.engine.observe(obs);
+        for (const s of sigs) {
+            const arr = this.logByMint.get(s.mint) ?? [];
+            arr.unshift(s);
+            if (arr.length > SIGNALS_LOG_MAX)
+                arr.length = SIGNALS_LOG_MAX;
+            this.logByMint.set(s.mint, arr);
+            this.emitted.push(s);
+            this.onSignal?.(s);
+        }
+        return sigs;
+    }
+    /** Recent signals for a mint, newest first (token-screen LIVE SIGNALS strip). */
+    recent(mint, limit = 8) {
+        return (this.logByMint.get(mint) ?? []).slice(0, limit);
+    }
+    /** Latest numeric fields for the rules engine (merged into the open-token RuleRow in ruleRowsOf). */
+    fields(mint) {
+        return this.engine.fields(mint);
+    }
+    /** Per-field snapshot (value + source + age + stale) for the strip header. */
+    snapshot(mint, now = this.now()) {
+        return this.engine.snapshot(mint, now);
+    }
+    /** Drop a mint the UI no longer tracks. */
+    forget(mint) {
+        this.engine.forget(mint);
+        this.logByMint.delete(mint);
+    }
+}

package/dist/packages/cli/src/live/trade.js

@@ -680,6 +680,8 @@ export class PositionsLive {
     now;
     /** mint → current price in SOL per whole token. */
     marks = new Map();
+    /** task-1407: when each mark was taken (ms), so a PnL card can print the mark's age. */
+    markTimes = new Map();
     solPriceUsd = null;
     loading = false;
     heldMemo = new Map();
@@ -703,6 +705,10 @@ export class PositionsLive {
     markOf(mint) {
         return this.marks.get(mint) ?? null;
     }
+    /** task-1407: when the mark for a mint was taken (ms), or null when there is none. */
+    markAt(mint) {
+        return this.marks.has(mint) ? this.markTimes.get(mint) ?? null : null;
+    }
     /**
      * PositionSource: the open paper position for a mint, or null. One indexed SQLite read, reused for
      * HELD_MEMO_MS so a 30 fps render loop does not hit the ledger every frame. A closed wallet reads as flat.
@@ -758,8 +764,10 @@ export class PositionsLive {
                         continue;
                     }
                     const usd = byMint.get(m)?.pair.priceUsd ?? null;
-                    if (usd && usd > 0)
+                    if (usd && usd > 0) {
                         this.marks.set(m, usd / this.solPriceUsd);
+                        this.markTimes.set(m, this.now());
+                    }
                 }
             }
         }
@@ -865,6 +873,21 @@ export class LivePositions {
         this.rowsMemo = { at: now, rows };
         return rows;
     }
+    /** task-1407: the raw ledger rows (newest first, swaps only) with network + signature, for the LIVE PnL card. */
+    fills(mint, limit = 500) {
+        try {
+            const l = new LiveLedger({ path: this.path, readOnly: true });
+            try {
+                return l.trades(limit * 2).filter((r) => r.kind === 'swap' && r.mint === mint).slice(0, limit);
+            }
+            finally {
+                l.close();
+            }
+        }
+        catch {
+            return [];
+        }
+    }
     /** Confirmed live fills (newest first) for the popup markers / history; probes excluded. */
     records(limit = 100, mint) {
         try {