desic-okx-agent 0.2.1 → 0.3.1

package/dist/strategy/schema.js

@@ -0,0 +1,94 @@
+/**
+ * Storage for queued and completed strategy runs.
+ *
+ * The equity curve is stored as chunked binary float64 blocks rather than JSON rows.
+ * Every value round-trips bit-for-bit, which decimal JSON text does not guarantee, and
+ * a measured 344k-point curve is 2.4 MB here against roughly 40 MB as JSON objects.
+ *
+ * `codec` names the layout of each chunk's payload. It is read rather than inferred so
+ * that chunks written by an earlier build keep decoding correctly — see `series-codec.ts`.
+ */
+export const STRATEGY_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS strategy_runs (
+  id TEXT PRIMARY KEY,
+  kind TEXT NOT NULL,
+  status TEXT NOT NULL,
+  strategy_name TEXT NOT NULL,
+  strategy_hash TEXT NOT NULL,
+  strategy_source TEXT NOT NULL,
+  inst_id TEXT NOT NULL,
+  request_json TEXT NOT NULL,
+  data_snapshot_id TEXT,
+  bar_count INTEGER NOT NULL DEFAULT 0,
+  preload_bars INTEGER NOT NULL DEFAULT 0,
+  progress_pct REAL NOT NULL DEFAULT 0,
+  eta_ms INTEGER,
+  metrics_json TEXT,
+  -- The assumptions the run actually used. Stored per run because settings can
+  -- change between runs, and a report that cannot say what it assumed is not
+  -- comparable to any other report.
+  assumptions_json TEXT,
+  error TEXT,
+  created_at INTEGER NOT NULL,
+  started_at INTEGER,
+  finished_at INTEGER
+);
+
+CREATE INDEX IF NOT EXISTS idx_strategy_runs_created
+  ON strategy_runs(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_strategy_runs_status
+  ON strategy_runs(status, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS strategy_run_series (
+  run_id TEXT NOT NULL,
+  chunk_index INTEGER NOT NULL,
+  from_point INTEGER NOT NULL,
+  to_point INTEGER NOT NULL,
+  start_ms INTEGER NOT NULL,
+  step_ms INTEGER NOT NULL,
+  payload BLOB NOT NULL,
+  codec TEXT NOT NULL DEFAULT 'f64x4',
+  PRIMARY KEY(run_id, chunk_index)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS strategy_run_trades (
+  run_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  trade_json TEXT NOT NULL,
+  PRIMARY KEY(run_id, seq)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS strategy_run_actions (
+  run_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  action_json TEXT NOT NULL,
+  PRIMARY KEY(run_id, seq)
+) WITHOUT ROWID;
+
+-- One row per evaluated parameter combination of an optimize run.
+--
+-- Training and validation metrics are stored separately rather than merged into
+-- one figure. The gap between them is the finding: a candidate that earned its
+-- ranking and one that memorized the training segment are indistinguishable from
+-- a single number.
+CREATE TABLE IF NOT EXISTS strategy_optimization_candidates (
+  run_id TEXT NOT NULL,
+  candidate_index INTEGER NOT NULL,
+  params_json TEXT NOT NULL,
+  status TEXT NOT NULL,
+  train_metrics_json TEXT,
+  validation_metrics_json TEXT,
+  -- Validation-segment score. Null while queued, and for a candidate that failed.
+  rank_score REAL,
+  -- Which formula produced rank_score, because it is not always Calmar.
+  rank_basis TEXT,
+  verdict TEXT,
+  error TEXT,
+  PRIMARY KEY(run_id, candidate_index)
+) WITHOUT ROWID;
+
+-- Ranking reads this in score order, so it is indexed rather than sorted per read.
+CREATE INDEX IF NOT EXISTS idx_optimization_rank
+  ON strategy_optimization_candidates(run_id, rank_score DESC);
+`;
+//# sourceMappingURL=schema.js.map

package/dist/strategy/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/strategy/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFlC,CAAC"}

package/dist/strategy/series-codec.d.ts

@@ -0,0 +1,50 @@
+import type { EquityPoint } from "./types.js";
+/**
+ * How one equity chunk's bytes are laid out.
+ *
+ * The name is stored beside the payload rather than inferred from its length, so a
+ * chunk written by an older build keeps being read the way it was written. A codec is
+ * append-only: once a name has been persisted its decoder stays.
+ */
+export type SeriesCodec = "f64x4" | "f64x3z";
+/** What every codec written before the column existed must be read as. */
+export declare const LEGACY_CODEC: SeriesCodec;
+/** What new chunks are written with. */
+export declare const CURRENT_CODEC: SeriesCodec;
+export interface ChunkPlan {
+    codec: SeriesCodec;
+    /** First point's timestamp, in epoch ms. */
+    startMs: number;
+    /** Spacing between consecutive points, in ms. Zero for a single-point chunk. */
+    stepMs: number;
+    payload: Buffer;
+}
+/**
+ * Encodes one chunk of the equity curve.
+ *
+ * Two things shrink it. The time column is dropped, because a backtest evaluates one
+ * closed bar at a time and those timestamps are an arithmetic sequence — `startMs +
+ * stepMs * i` reproduces them exactly, and this is verified rather than assumed.
+ * The remaining three f64 columns compress well because consecutive equity values
+ * share most of their bytes.
+ *
+ * When the spacing is not uniform the chunk falls back to `f64x4`, which stores every
+ * timestamp. A gap in the curve is a fact about the run, not something to smooth over.
+ */
+export declare function encodeChunk(points: readonly EquityPoint[]): ChunkPlan;
+/**
+ * Reads points `[fromIndex, toIndex)` of a chunk, where the indexes are relative to
+ * the chunk's own first point.
+ *
+ * A compressed chunk has to be inflated whole before any point can be addressed, so
+ * the range only narrows what is materialized, not what is decompressed. That is why
+ * chunks are bounded in size: the cost of reading one point is the cost of one chunk.
+ */
+export declare function decodeChunk(chunk: {
+    codec: SeriesCodec;
+    startMs: number;
+    stepMs: number;
+    payload: Buffer;
+}, fromIndex: number, toIndex: number): EquityPoint[];
+/** Names a stored codec, treating anything written before the column existed as legacy. */
+export declare function codecFrom(value: unknown): SeriesCodec;

package/dist/strategy/series-codec.js

@@ -0,0 +1,103 @@
+import zlib from "node:zlib";
+/** What every codec written before the column existed must be read as. */
+export const LEGACY_CODEC = "f64x4";
+/** What new chunks are written with. */
+export const CURRENT_CODEC = "f64x3z";
+/** Bytes per point in the uncompressed four-column layout. */
+const F64X4_STRIDE = 32;
+/** Bytes per point once the time column is dropped. */
+const F64X3_STRIDE = 24;
+/**
+ * Encodes one chunk of the equity curve.
+ *
+ * Two things shrink it. The time column is dropped, because a backtest evaluates one
+ * closed bar at a time and those timestamps are an arithmetic sequence — `startMs +
+ * stepMs * i` reproduces them exactly, and this is verified rather than assumed.
+ * The remaining three f64 columns compress well because consecutive equity values
+ * share most of their bytes.
+ *
+ * When the spacing is not uniform the chunk falls back to `f64x4`, which stores every
+ * timestamp. A gap in the curve is a fact about the run, not something to smooth over.
+ */
+export function encodeChunk(points) {
+    if (points.length === 0) {
+        throw new Error("An equity chunk needs at least one point");
+    }
+    const first = points[0];
+    const stepMs = points.length > 1 ? points[1].timeMs - first.timeMs : 0;
+    if (!isUniform(points, first.timeMs, stepMs)) {
+        return { codec: "f64x4", startMs: first.timeMs, stepMs, payload: encodeF64x4(points) };
+    }
+    const raw = Buffer.allocUnsafe(points.length * F64X3_STRIDE);
+    points.forEach((point, index) => {
+        const base = index * F64X3_STRIDE;
+        raw.writeDoubleLE(point.equityUsdt, base);
+        raw.writeDoubleLE(point.realizedCashUsdt, base + 8);
+        raw.writeDoubleLE(point.unrealizedPnlUsdt, base + 16);
+    });
+    return {
+        codec: "f64x3z",
+        startMs: first.timeMs,
+        stepMs,
+        payload: zlib.deflateSync(raw)
+    };
+}
+/**
+ * Reads points `[fromIndex, toIndex)` of a chunk, where the indexes are relative to
+ * the chunk's own first point.
+ *
+ * A compressed chunk has to be inflated whole before any point can be addressed, so
+ * the range only narrows what is materialized, not what is decompressed. That is why
+ * chunks are bounded in size: the cost of reading one point is the cost of one chunk.
+ */
+export function decodeChunk(chunk, fromIndex, toIndex) {
+    const rows = [];
+    if (chunk.codec === "f64x4") {
+        for (let index = fromIndex; index < toIndex; index += 1) {
+            const base = index * F64X4_STRIDE;
+            rows.push({
+                timeMs: chunk.payload.readDoubleLE(base),
+                equityUsdt: chunk.payload.readDoubleLE(base + 8),
+                realizedCashUsdt: chunk.payload.readDoubleLE(base + 16),
+                unrealizedPnlUsdt: chunk.payload.readDoubleLE(base + 24)
+            });
+        }
+        return rows;
+    }
+    const raw = zlib.inflateSync(chunk.payload);
+    for (let index = fromIndex; index < toIndex; index += 1) {
+        const base = index * F64X3_STRIDE;
+        rows.push({
+            timeMs: chunk.startMs + chunk.stepMs * index,
+            equityUsdt: raw.readDoubleLE(base),
+            realizedCashUsdt: raw.readDoubleLE(base + 8),
+            unrealizedPnlUsdt: raw.readDoubleLE(base + 16)
+        });
+    }
+    return rows;
+}
+/** Names a stored codec, treating anything written before the column existed as legacy. */
+export function codecFrom(value) {
+    return value === "f64x3z" ? "f64x3z" : LEGACY_CODEC;
+}
+function isUniform(points, startMs, stepMs) {
+    // Checked rather than trusted: the decoder reconstructs every timestamp from this
+    // arithmetic, so one irregular bar would silently move the whole tail of the chunk.
+    for (let index = 0; index < points.length; index += 1) {
+        if (points[index].timeMs !== startMs + stepMs * index)
+            return false;
+    }
+    return true;
+}
+function encodeF64x4(points) {
+    const payload = Buffer.allocUnsafe(points.length * F64X4_STRIDE);
+    points.forEach((point, index) => {
+        const base = index * F64X4_STRIDE;
+        payload.writeDoubleLE(point.timeMs, base);
+        payload.writeDoubleLE(point.equityUsdt, base + 8);
+        payload.writeDoubleLE(point.realizedCashUsdt, base + 16);
+        payload.writeDoubleLE(point.unrealizedPnlUsdt, base + 24);
+    });
+    return payload;
+}
+//# sourceMappingURL=series-codec.js.map

package/dist/strategy/series-codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"series-codec.js","sourceRoot":"","sources":["../../src/strategy/series-codec.ts"],"names":[],"mappings":"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"}

package/dist/strategy/service.d.ts

@@ -0,0 +1,138 @@
+import { type ToolResult } from "../core/types.js";
+import type { BarService } from "../bars/service.js";
+import type { MarketService } from "../market/service.js";
+import { type PythonStatus } from "./environment.js";
+import { type BacktestSettings } from "./settings.js";
+import { StrategyStore } from "./store.js";
+import { type ComparisonReport } from "../report/compare.js";
+import type { BacktestRequest, EquityPoint, OptimizationReport, OptimizeRequest, Page, RunStatus, RunSummary, ValidationResult } from "./types.js";
+export declare class StrategyService {
+    readonly store: StrategyStore;
+    private readonly bars;
+    /**
+     * Source of contract specifications. Optional so a test can construct the
+     * service without a market runtime; a run then fails with a clear message
+     * rather than falling back to a guessed contract size.
+     */
+    private readonly market?;
+    private readonly maxWorkers;
+    private readonly now;
+    /** Test seam: bypasses the settings file so a run is reproducible. */
+    private readonly injectedSettings?;
+    private readonly active;
+    private queue;
+    private running;
+    constructor(store: StrategyStore, bars: BarService, 
+    /**
+     * Source of contract specifications. Optional so a test can construct the
+     * service without a market runtime; a run then fails with a clear message
+     * rather than falling back to a guessed contract size.
+     */
+    market?: MarketService | undefined, maxWorkers?: number, now?: () => number, 
+    /** Test seam: bypasses the settings file so a run is reproducible. */
+    injectedSettings?: BacktestSettings | undefined);
+    /** Reports interpreter availability without changing anything. */
+    environment(): Promise<ToolResult<PythonStatus>>;
+    setupEnvironment(onLog?: (line: string) => void): Promise<ToolResult<Record<string, unknown>>>;
+    /** Saved settings, or the injected ones when a caller supplied them. */
+    settings(): BacktestSettings;
+    readSettings(): ToolResult<BacktestSettings>;
+    /**
+     * Applies saved settings. Unknown keys and out-of-range values are rejected
+     * rather than ignored: a silently dropped change means the next run uses
+     * assumptions the caller believes it changed.
+     */
+    updateSettings(values: Record<string, unknown>, reset?: boolean): ToolResult<BacktestSettings>;
+    /** Static policy check. Fast enough to run on every edit. */
+    validate(source: string): Promise<ToolResult<ValidationResult>>;
+    /**
+     * Queues a backtest and returns immediately.
+     *
+     * A run can take minutes, so the caller polls `getRun` rather than holding a
+     * request open and risking a client-side timeout.
+     */
+    startBacktest(request: BacktestRequest): Promise<ToolResult<{
+        runId: string;
+        status: RunStatus;
+    }>>;
+    /**
+     * Queues a parameter search and returns immediately.
+     *
+     * The space is validated against the strategy's own declared parameters before
+     * anything is queued, so a range naming a parameter the strategy never reads
+     * fails at the prompt rather than after every candidate has run identically.
+     */
+    startOptimize(request: OptimizeRequest): Promise<ToolResult<{
+        runId: string;
+        status: RunStatus;
+    }>>;
+    /**
+     * Ranked candidates for one optimize run.
+     *
+     * Ranking is by the held-back segment, never the searched one. The winner's
+     * ranking basis is reported alongside, because Calmar is unavailable on short
+     * windows and a column that silently changes meaning is worse than a labelled
+     * one.
+     */
+    optimization(id: string, top?: number): ToolResult<OptimizationReport>;
+    /**
+     * Compares completed runs.
+     *
+     * The equity curves are read whole here rather than paged: a comparison is
+     * summary-level, and the curves are downsampled before they leave. The response
+     * carries metrics, the assumptions that differ, and the warnings — not the
+     * curves, which would bury an agent's context for no benefit.
+     */
+    compareRuns(runIds: string[]): ToolResult<Omit<ComparisonReport, "series">>;
+    getRun(id: string): ToolResult<RunSummary>;
+    listRuns(options?: {
+        limit?: number;
+        status?: RunStatus;
+        instId?: string;
+    }): ToolResult<RunSummary[]>;
+    equity(id: string, offset?: number, limit?: number): ToolResult<Page<EquityPoint>>;
+    trades(id: string, offset?: number, limit?: number): ToolResult<Page<unknown>>;
+    actions(id: string, offset?: number, limit?: number): ToolResult<Page<unknown>>;
+    cancel(id: string): ToolResult<{
+        cancelled: boolean;
+    }>;
+    deleteRun(id: string): ToolResult<{
+        deleted: boolean;
+    }>;
+    /**
+     * Resolves the exact bar window a request describes.
+     *
+     * Preloaded history is context only: it warms up indicators and supplies the
+     * first decision point, and is excluded from every reported statistic.
+     */
+    resolveWindow(request: BacktestRequest): {
+        evaluationStart: number;
+        evaluationEnd: number;
+        preloadStart: number;
+        preloadBars: number;
+        totalBars: number;
+    };
+    private execute;
+    /**
+     * Runs one parameter search.
+     *
+     * The bars are loaded once and every candidate is measured against that single
+     * array. Batches go out one per worker rather than one per candidate: the
+     * payload is a small share of a candidate's cost, so nothing is gained by
+     * splitting further, while a process per candidate would hold the same
+     * multi-megabyte array once per candidate.
+     */
+    private executeOptimize;
+    /** Stores one batch's results, keyed by the candidate index the host assigned. */
+    private recordBatch;
+    /**
+     * Reads the instrument's contract specification.
+     *
+     * Refuses rather than defaulting: a backtest sized off a guessed contract value
+     * reports confident numbers for positions that could never have been taken.
+     */
+    private contractSpec;
+    private requireInterpreter;
+    private enqueue;
+    private drain;
+}