dexterm-cli 0.1.5 → 0.1.7

package/dist/packages/cli/src/screens/autotrade-worker.js

@@ -0,0 +1,89 @@
+// dexterm — AUTOTRADE screen backtests off the render loop (task-1508). A lockstep backtest over two weeks of
+// recorded history is CPU-bound for seconds and a sweep for much longer, so the Q screen runs them in a worker
+// thread: the worker opens the recorder DB read-only, builds the tape once, runs the engine and posts the
+// report back. PAPER, recorded data only: no network, no model, no keys. The same module is the worker entry
+// (it checks workerData) and the main-thread client (workerJobs). Tests use inlineJobs over a fixture tape.
+import { existsSync } from 'node:fs';
+import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { defaultDbPath } from '../../../data/src/index.js';
+import { openHistoryReadOnly } from '../../../recorder/src/index.js';
+import { backtest, sweep, tapeFromDb, tapeFromDoc } from '../../../autotrade/src/index.js';
+const DAY_MS = 86_400_000;
+/** The equity curve is resampled to this many points before it crosses the thread boundary (it feeds a sparkline). */
+const CURVE_POINTS = 240;
+const TAG = 'dexterm-autotrade-job/1';
+function resample(xs, n) {
+    if (xs.length <= n)
+        return xs;
+    return Array.from({ length: n }, (_, i) => xs[Math.round((i * (xs.length - 1)) / (n - 1))]);
+}
+/** The recorder's history as a tape, read-only (the same window rules as `dexterm autotrade backtest --days N`). */
+export function tapeFromRecorder(dbPath, days, until) {
+    const none = `no recorded history in ${dbPath} (run the app with the recorder on first)`;
+    if (!existsSync(dbPath))
+        throw new Error(none);
+    let db;
+    try {
+        db = openHistoryReadOnly(dbPath);
+    }
+    catch {
+        throw new Error(none);
+    }
+    if (!db)
+        throw new Error(none);
+    try {
+        return tapeFromDoc(tapeFromDb(db, { since: until - days * DAY_MS, until, minPeakLiqUsd: 20_000, spanHours: 80 }));
+    }
+    finally {
+        db.close();
+    }
+}
+export async function backtestOn(tape, ss) {
+    const out = [];
+    for (const s of ss) {
+        const { report, run } = await backtest(s, tape);
+        out.push({ report, curve: resample(run.equityCurve.map((p) => p.equity), CURVE_POINTS) });
+    }
+    return out;
+}
+/** Jobs that run on the calling thread over a tape the caller supplies (tests, over a committed fixture tape). */
+export function inlineJobs(tape) {
+    return {
+        backtest: async (ss) => backtestOn(tape(), ss),
+        sweep: async (s, grid) => sweep(s, tape(), grid),
+    };
+}
+/** Jobs in a worker thread over the recorder DB (the app). One worker per job; it exits when done. */
+export function workerJobs(env = process.env) {
+    const dbPath = env.DEXTERM_DB_PATH || defaultDbPath(env);
+    const run = (job) => new Promise((resolve, reject) => {
+        const w = new Worker(new URL(import.meta.url), { workerData: { tag: TAG, job } });
+        w.unref();
+        w.once('message', (m) => { if (m.ok)
+            resolve(m.value);
+        else
+            reject(new Error(m.error)); });
+        w.once('error', reject);
+        w.once('exit', (code) => { if (code !== 0)
+            reject(new Error(`backtest worker exited with code ${code}`)); });
+    });
+    return {
+        backtest: (strategies, o) => run({ kind: 'backtest', strategies, days: o.days, until: o.until, dbPath }),
+        sweep: (strategy, grid, o) => run({ kind: 'sweep', strategy, grid, days: o.days, until: o.until, dbPath }),
+    };
+}
+// ───────────────────────────── worker entry ─────────────────────────────
+if (!isMainThread && parentPort && workerData?.tag === TAG) {
+    const job = workerData.job;
+    const port = parentPort;
+    void (async () => {
+        try {
+            const tape = tapeFromRecorder(job.dbPath, job.days, job.until);
+            const value = job.kind === 'backtest' ? await backtestOn(tape, job.strategies) : await sweep(job.strategy, tape, job.grid);
+            port.postMessage({ ok: true, value });
+        }
+        catch (e) {
+            port.postMessage({ ok: false, error: e.message ?? String(e) });
+        }
+    })();
+}