dexterm-cli 0.1.3 → 0.1.5

package/dist/packages/recorder/src/dev-history.js

@@ -0,0 +1,129 @@
+// DEV HISTORY (0.1.5, task-1425): "has this deployer rugged before?" from dexterm's OWN recorded history, keyless.
+// The creator links come from the `creators` table (a keyless source naming the dev when dexterm saw the coin), the
+// outcomes from the recorder's code-only labeler (labels.ts: keyless-proxy tier), the dev-exit timing from the
+// recorded `dev_pct` series. Every number carries its source, sample size and age; no recorded prior launch is
+// `unknown`, never "clean". It is a risk flag from observed history, never a certificate.
+//
+// Point in time: with `asOf`, only links recorded before it and labels already known by then count (a label is known
+// once its observation t1, or t0 + horizon, has passed). The backtest uses this so a coin is never judged on the
+// future (the same leakage rule as export.ts).
+/** Label horizons in preference order: the 72 h label when known, else the longest one known. */
+const PREF_HORIZONS = [259200, 86400, 21600, 7200, 3600];
+/** Dev-exit rule: the dev held more than this % of supply, then this little. */
+export const DEV_EXIT = { heldPct: 0.5, exitPct: 0.1 };
+/** Prior rugs at/over this many = the `serial_rugger` flag (same threshold as the token-dossier pack). */
+export const SERIAL_RUGGER_MIN = 2;
+export const DEV_HISTORY_SOURCE = 'dexterm recorder (keyless creator links + code-only outcome labels)';
+const median = (xs) => {
+    if (!xs.length)
+        return null;
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+/** The creator dexterm recorded for `mint`, or null. */
+export function creatorOf(db, mint) {
+    try {
+        const r = db.prepare('SELECT mint, creator, source, first_t, created_at FROM creators WHERE mint = ?').get(mint);
+        return r ? { mint: r.mint, creator: r.creator, source: r.source, firstT: Number(r.first_t), createdAt: r.created_at === null ? null : Number(r.created_at) } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The creator's recorded track record. Never throws: a DB without the tables reads as `unknown`. */
+export function queryDevHistory(db, q) {
+    const asOf = q.asOf ?? Date.now();
+    const empty = {
+        creator: q.creator, status: 'unknown', asOf, source: DEV_HISTORY_SOURCE,
+        launches: { n: 0, newestT: null, ageSec: null },
+        labelled: { n: 0, rug: 0, dead: 0, fade: 0, flat: 0, runner: 0, horizon: '72h preferred', tier: 'keyless-proxy', newestT: null, ageSec: null },
+        rugRate: null, badRate: null, devExit: { n: 0, medianMin: null, within60m: 0 }, serialRugger: false, recent: [],
+    };
+    let links;
+    try {
+        links = db.prepare('SELECT mint, first_t, created_at FROM creators WHERE creator = ? AND first_t <= ? AND mint != ? ORDER BY first_t DESC LIMIT ?')
+            .all(q.creator, asOf, q.mint ?? '', q.limit ?? 300);
+    }
+    catch {
+        return empty;
+    }
+    if (!links.length)
+        return empty;
+    const outStmt = db.prepare("SELECT t0, horizon_sec, t1, label FROM outcomes WHERE mint = ? AND label != 'unobserved' ORDER BY t0 ASC");
+    const symStmt = db.prepare('SELECT symbol FROM token_snapshots WHERE mint = ? AND symbol IS NOT NULL ORDER BY t ASC LIMIT 1');
+    const devStmt = db.prepare('SELECT t, dev_pct FROM token_snapshots WHERE mint = ? AND dev_pct IS NOT NULL AND t <= ? ORDER BY t ASC LIMIT 400');
+    const counts = { rug: 0, dead: 0, fade: 0, flat: 0, runner: 0 };
+    let labelledN = 0, labelledNewest = null;
+    const exits = [];
+    const launches = [];
+    for (const l of links) {
+        const firstT = Number(l.first_t);
+        const createdAt = l.created_at === null ? null : Number(l.created_at);
+        const rows = outStmt.all(l.mint);
+        // the label of the EARLIEST anchor (closest to launch) at the longest horizon already known as of asOf
+        const known = rows.filter((r) => (r.t1 !== null ? Number(r.t1) : Number(r.t0) + Number(r.horizon_sec) * 1000) <= asOf);
+        let label = null, horizonSec = null, knownAt = null;
+        if (known.length) {
+            const t0 = Math.min(...known.map((r) => Number(r.t0)));
+            const at = known.filter((r) => Number(r.t0) === t0);
+            for (const h of PREF_HORIZONS) {
+                const hit = at.find((r) => Number(r.horizon_sec) === h);
+                if (hit) {
+                    label = hit.label;
+                    horizonSec = h;
+                    knownAt = hit.t1 !== null ? Number(hit.t1) : t0 + h * 1000;
+                    break;
+                }
+            }
+        }
+        if (label) {
+            labelledN++;
+            counts[label]++;
+            if (knownAt !== null)
+                labelledNewest = Math.max(labelledNewest ?? 0, knownAt);
+        }
+        let devExitMin = null;
+        if (q.devExit !== false) {
+            const series = devStmt.all(l.mint, asOf);
+            const held = series.findIndex((r) => r.dev_pct > DEV_EXIT.heldPct);
+            if (held >= 0) {
+                const out = series.slice(held + 1).find((r) => r.dev_pct <= DEV_EXIT.exitPct);
+                if (out) {
+                    const from = createdAt ?? Number(series[held].t);
+                    devExitMin = Math.max(0, (Number(out.t) - from) / 60_000);
+                    exits.push(devExitMin);
+                }
+            }
+        }
+        if (launches.length < 10) {
+            const sym = symStmt.get(l.mint)?.symbol ?? null;
+            launches.push({ mint: l.mint, symbol: sym, firstT, createdAt, label, horizonSec, devExitMin });
+        }
+    }
+    const newestT = Number(links[0].first_t);
+    return {
+        ...empty,
+        status: 'ok',
+        launches: { n: links.length, newestT, ageSec: Math.max(0, Math.round((asOf - newestT) / 1000)) },
+        labelled: { ...empty.labelled, n: labelledN, ...counts, newestT: labelledNewest, ageSec: labelledNewest === null ? null : Math.max(0, Math.round((asOf - labelledNewest) / 1000)) },
+        rugRate: labelledN ? counts.rug / labelledN : null,
+        badRate: labelledN ? (counts.rug + counts.dead) / labelledN : null,
+        devExit: { n: exits.length, medianMin: median(exits), within60m: exits.filter((m) => m <= 60).length },
+        serialRugger: counts.rug >= SERIAL_RUGGER_MIN,
+        recent: launches,
+    };
+}
+const ago = (sec) => sec === null ? 'age unknown' : sec < 3600 ? `${Math.max(1, Math.round(sec / 60))}m ago` : sec < 172800 ? `${Math.round(sec / 3600)}h ago` : `${Math.round(sec / 86400)}d ago`;
+/**
+ * The one-line summary every surface shows (DEV panel, rug-signal row, MCP note): counts with the sample size and
+ * the age, or `unknown` with why. Plain wording: a risk flag from observed history, never "rug confirmed" or "safe".
+ */
+export function devHistoryLine(r) {
+    if (r.status === 'unknown')
+        return 'unknown: no prior launch by this wallet in dexterm\'s record';
+    const L = r.labelled;
+    if (!L.n)
+        return `${r.launches.n} prior launch${r.launches.n === 1 ? '' : 'es'} recorded, none labelled yet (newest ${ago(r.launches.ageSec)})`;
+    return `rugged ${L.rug} of ${L.n} labelled prior launches${L.dead ? ` (+${L.dead} dead)` : ''} · ${r.launches.n} recorded · labels ${ago(L.ageSec)}`;
+}

package/dist/packages/recorder/src/index.js

@@ -8,6 +8,7 @@ export * from "./export.js";
 export * from "./open.js";
 export * from "./verdicts.js";
 export * from "./schedule.js";
+export * from "./dev-history.js";
 export { recorderCli, RECORDER_HELP } from "./cli.js";
 /** `--no-recorder` / `DEXTERM_RECORDER=0` resolution: the recorder is on in live mode unless either says no. */
 export function recorderEnabled(env, flagOff) {

package/dist/packages/recorder/src/recorder.js

@@ -30,6 +30,7 @@ export const LABEL_RETRY_MS = 300_000;
 export const LABEL_BATCH = 300;
 /** In-memory last-row cache: entries not observed for this long are dropped (re-read from the DB on return). */
 export const SEEN_EVICT_MS = 2 * 3_600_000;
+const BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 export class Recorder {
     enabled;
     path;
@@ -58,6 +59,8 @@ export class Recorder {
     /** Counters for the handoff / --verbose. */
     counters = { observed: 0, written: 0, heartbeat: 0, members: 0, sweepCalls: 0, labelled: 0 };
     stmts;
+    /** Mints whose creator link is already stored (this run), so a refresh costs no write. */
+    creatorKnown = new Set();
     constructor(opts = {}) {
         this.enabled = opts.enabled ?? true;
         this.path = opts.path ?? ':memory:';
@@ -87,6 +90,7 @@ export class Recorder {
             insertMember: this.db.prepare('INSERT OR IGNORE INTO feed_members (t, feed, rank, mint) VALUES (?, ?, ?, ?)'),
             lastIdentity: this.db.prepare('SELECT symbol, name, launchpad, created_at FROM token_snapshots WHERE mint = ? ORDER BY t DESC LIMIT 1'),
             lastLive: this.db.prepare(`SELECT t, hash, sources, ${cols} FROM token_snapshots WHERE mint = ? AND kind = 'live' ORDER BY t DESC LIMIT 1`),
+            insertCreator: this.db.prepare('INSERT OR IGNORE INTO creators (mint, creator, source, first_t, created_at) VALUES (?, ?, ?, ?, ?)'),
         };
     }
     /** Attach as the data layer's store listener (and detach any previous one). */
@@ -120,6 +124,10 @@ export class Recorder {
         const pending = [];
         for (const r of rows) {
             this.counters.observed++;
+            // 0.1.5 dev history: the creator the row's source names (Jupiter `dev`), stored once per mint.
+            const dev = r.audit?.devAddress;
+            if (r.mint && dev)
+                this.recordCreator(r.mint, dev, r.audit?.source ?? 'jupiter-tokens', now, r.token?.createdAt ?? null);
             if (!r.mint || !r.pair) {
                 res.skipped++;
                 continue;
@@ -173,6 +181,21 @@ export class Recorder {
         this.counters.heartbeat += res.heartbeat;
         return res;
     }
+    /**
+     * Record which wallet created `mint`, as `source` named it (0.1.5 dev history). First writer wins; a mint or
+     * creator that is not a base58 address is ignored. Returns true when a new link was stored.
+     */
+    recordCreator(mint, creator, source, now = this.clock.now(), createdAt = null) {
+        if (!this.enabled || this.closed || this.creatorKnown.has(mint))
+            return false;
+        if (!BASE58.test(mint) || !BASE58.test(creator) || mint === creator)
+            return false;
+        this.creatorKnown.add(mint);
+        if (this.creatorKnown.size > 200_000)
+            this.creatorKnown.clear();
+        const r = this.stmts.insertCreator.run(mint, creator, String(source).slice(0, 24), now, createdAt !== null && Number.isFinite(createdAt) ? Math.round(createdAt) : null);
+        return Number(r.changes) > 0;
+    }
     /** The mint's last stored live row (one indexed read; only paid the first time a mint is seen this run). */
     lastStored(mint) {
         const row = this.stmts.lastLive.get(mint);

package/dist/packages/recorder/src/schema.js

@@ -132,4 +132,15 @@ CREATE TABLE IF NOT EXISTS verdicts (
   run_file     TEXT
 );
 CREATE INDEX IF NOT EXISTS verdicts_mint_t ON verdicts (mint, t);
+
+-- 0.1.5 dev history: which wallet created a coin, as a keyless source named it when dexterm saw the coin
+-- (Jupiter tokens v2 \`dev\`, a PumpPortal create, RugCheck new_tokens). First writer wins; never a guess.
+CREATE TABLE IF NOT EXISTS creators (
+  mint        TEXT PRIMARY KEY,
+  creator     TEXT NOT NULL,
+  source      TEXT NOT NULL,             -- 'jupiter-tokens' | 'pumpportal' | 'rugcheck' | 'goplus'
+  first_t     INTEGER NOT NULL,          -- unix ms dexterm first recorded the link
+  created_at  INTEGER                    -- the coin's creation time when the source gave one
+) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS creators_creator ON creators (creator, first_t);
 `;

package/dist/packages/voice/src/stt/whisper.js

@@ -39,9 +39,11 @@ export function pickRecorder() {
 }
 /** Synchronous PATH check without spawning (cheap; used by available() and pickRecorder). */
 function which(bin) {
-    const paths = (process.env.PATH ?? '').split(':');
+    // Windows (task-1423): `;`-separated PATH and `.exe` binaries, same rule as piper.ts's which()
+    const win = process.platform === 'win32';
+    const paths = (process.env.PATH ?? '').split(win ? ';' : ':');
     for (const p of paths) {
-        if (p && existsSync(join(p, bin)))
+        if (p && (existsSync(join(p, bin)) || (win && existsSync(join(p, `${bin}.exe`)))))
             return true;
     }
     return false;

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "dexterm-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
+  "mcpName": "io.github.dexterm-xyz/dexterm",
   "description": "dexterm: terminal DEX screener with a local Claude CLI analyst",
   "author": "The dexterm authors",
   "license": "AGPL-3.0-only",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dexterm-xyz/dexterm.git"
-  },
   "type": "module",
   "bin": {
     "dexterm": "./dist/packages/cli/bin/dexterm.mjs"
@@ -36,5 +33,9 @@
     "@dexterm/recorder": "0.0.1",
     "@dexterm/tui": "0.0.1",
     "@dexterm/voice": "0.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dexterm-xyz/dexterm.git"
   }
 }