@hoox-sh/pynets 0.1.0 → 0.3.0

package/src/runtime/compile/emit_udf.ts

@@ -0,0 +1,326 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * UDF FunctionDef emission for JS compile.
+ * Signature: `function name(__bar_idx, __h, ...formals, ...__st_*)`.
+ * Series formals are full arrays (no default). Series locals persist in
+ * `__st_${safeFunc}_${safeLocal}`. Last Expr (and last Assign/ReAssign)
+ * becomes the Pine return value.
+ */
+import type { Assign, Expr, FunctionDef, Param, ReAssign, expr, stmt } from "../../ast/nodes.ts";
+import type { EmitCtx } from "./types.ts";
+
+/** JS / emit keywords that cannot be used as identifiers. Pine `from` included. */
+const RESERVED = new Set([
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "from",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "of",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "__bar_idx",
+  "__h",
+]);
+
+/** Pine UDF / formal → ordered `__st_*` idents (same order as the def tail). */
+const funcStArrays = new WeakMap<EmitCtx, Map<string, string[]>>();
+
+function safeIdent(name: string): string {
+  if (!name) return "_";
+  let s = /^[A-Za-z_$]/.test(name) ? name : `_${name}`;
+  s = s.replace(/[^A-Za-z0-9_$]/g, "_");
+  return RESERVED.has(s) ? `${s}_` : s;
+}
+
+/** Persistent series-local array: `__st_${safeFunc}_${safeLocal}`. */
+function stIdent(funcSafe: string, localPine: string): string {
+  return `__st_${funcSafe}_${safeIdent(localPine)}`;
+}
+
+function stripSemi(code: string): string {
+  return code.trim().replace(/;+\s*$/, "");
+}
+
+function indentBody(code: string): string {
+  return code
+    .split("\n")
+    .map((ln) => (ln.length ? `  ${ln}` : ln))
+    .join("\n");
+}
+
+function ensureSemi(code: string): string {
+  const t = code.trimEnd();
+  if (!t) return t;
+  if (/[;{}]$/.test(t)) return t;
+  return `${t};`;
+}
+
+const CTRL_KINDS = new Set(["If", "ForTo", "ForIn", "While", "Switch"]);
+
+function isCtrlExpr(node: stmt): boolean {
+  return node.kind === "Expr" && CTRL_KINDS.has(node.value.kind);
+}
+
+function isVarMode(mode: Assign["mode"]): boolean {
+  if (mode == null) return false;
+  const k = typeof mode === "object" && mode != null && "kind" in mode ? mode.kind : String(mode);
+  return k === "Var" || k === "VarIp";
+}
+
+function emitDefault(param: Param, visitStmt: (s: stmt) => string): string {
+  if (param.default == null) return "null";
+  return visitExpr(param.default, visitStmt);
+}
+
+function visitExpr(value: expr, visitStmt: (s: stmt) => string): string {
+  const dummy: Expr = { kind: "Expr", value };
+  const visited = stripSemi(visitStmt(dummy));
+  return visited || "null";
+}
+
+function lastAssignReturn(node: Assign | ReAssign, localSt: Map<string, string>): string {
+  const target = node.target;
+  if (target.kind === "Name") {
+    const st = localSt.get(target.id);
+    if (st != null) return `  return ${st}[__bar_idx];`;
+    return `  return ${safeIdent(target.id)};`;
+  }
+  return "  return null;";
+}
+
+function asReturn(code: string): string {
+  const t = stripSemi(code);
+  if (!t) return "  return null;";
+  if (/^return\b/.test(t)) return indentBody(ensureSemi(t));
+  return `  return ${t};`;
+}
+
+function walkFnBody(node: unknown, visit: (n: { kind?: string; [k: string]: unknown }) => void): void {
+  if (node == null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) walkFnBody(item, visit);
+    return;
+  }
+  const n = node as { kind?: string; [k: string]: unknown };
+  if (n.kind === "FunctionDef" || n.kind === "TypeDef" || n.kind === "EnumDef") {
+    visit(n);
+    return;
+  }
+  if (typeof n.kind === "string") visit(n);
+  for (const v of Object.values(n)) walkFnBody(v, visit);
+}
+
+function addTargetNames(target: unknown, into: Set<string>): void {
+  if (target == null || typeof target !== "object") return;
+  const t = target as { kind?: string; id?: string; elts?: unknown[] };
+  if (t.kind === "Name" && typeof t.id === "string") {
+    into.add(t.id);
+    return;
+  }
+  if (t.kind === "Tuple") {
+    for (const el of t.elts ?? []) addTargetNames(el, into);
+  }
+}
+
+function rememberSt(ctx: EmitCtx, pine: string, safe: string, st: string[]): void {
+  let m = funcStArrays.get(ctx);
+  if (m == null) {
+    m = new Map();
+    funcStArrays.set(ctx, m);
+  }
+  m.set(pine, st);
+  if (safe !== pine) m.set(safe, st);
+}
+
+function stForFunc(ctx: EmitCtx, pine: string, safe: string): string[] {
+  const mapped = funcStArrays.get(ctx)?.get(pine) ?? funcStArrays.get(ctx)?.get(safe);
+  if (mapped != null) return mapped;
+  const prefix = `__st_${safe}_`;
+  return [...ctx.stArrays].filter((a) => a.startsWith(prefix)).sort();
+}
+
+function formalPineNames(node: FunctionDef): string[] {
+  const params = Array.isArray(node.args) ? node.args : [];
+  const names: string[] = [];
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i]!;
+    names.push(node.method && i === 0 && !p.name ? "this" : p.name);
+  }
+  return names;
+}
+
+export function emitFunctionDef(ctx: EmitCtx, node: FunctionDef, visitStmt: (s: stmt) => string): void {
+  const pineName = node.name;
+  ctx.userFuncs.add(pineName);
+  const safe = safeIdent(pineName);
+  if (safe !== pineName) ctx.userFuncs.add(safe);
+
+  const params = Array.isArray(node.args) ? node.args : [];
+  const pineParams = formalPineNames(node);
+  ctx.funcParamNames.set(pineName, pineParams);
+  if (safe !== pineName) ctx.funcParamNames.set(safe, pineParams);
+
+  const paramSet = new Set(pineParams);
+  const body = Array.isArray(node.body) ? node.body : [];
+
+  const seriesSet = new Set<string>();
+  const assigned = new Set<string>();
+  const varLocals = new Set<string>();
+  const historyNames = new Set<string>();
+  const varDefaults = new Map<string, expr | null>();
+
+  walkFnBody(body, (n) => {
+    if (n.kind === "Subscript") {
+      const value = n.value as { kind?: string; id?: string } | undefined;
+      if (value?.kind === "Name" && typeof value.id === "string") {
+        historyNames.add(value.id);
+        if (paramSet.has(value.id)) seriesSet.add(value.id);
+      }
+    }
+    if (n.kind === "Assign" || n.kind === "ReAssign") {
+      addTargetNames(n.target, assigned);
+      if (n.kind === "Assign" && isVarMode(n.mode as Assign["mode"])) {
+        const names = new Set<string>();
+        addTargetNames(n.target, names);
+        for (const id of names) {
+          if (paramSet.has(id)) continue;
+          varLocals.add(id);
+          if (!varDefaults.has(id)) varDefaults.set(id, (n.value as expr | null) ?? null);
+        }
+      }
+    }
+  });
+
+  ctx.funcSeriesParams.set(pineName, seriesSet);
+  if (safe !== pineName) ctx.funcSeriesParams.set(safe, seriesSet);
+
+  const seriesLocals = [...new Set([...varLocals, ...historyNames])]
+    .filter((id) => assigned.has(id) && !paramSet.has(id))
+    .sort();
+
+  const localSt = new Map<string, string>();
+  const stNames: string[] = [];
+  for (const s of seriesLocals) {
+    const st = stIdent(safe, s);
+    ctx.stArrays.add(st);
+    localSt.set(s, st);
+    stNames.push(st);
+  }
+  rememberSt(ctx, pineName, safe, stNames);
+
+  const prevFunc = ctx.currentFunc;
+  const prevParams = ctx.currentParamNames;
+  const prevSeries = ctx.currentSeriesParams;
+  ctx.currentFunc = pineName;
+  ctx.currentParamNames = new Set(pineParams);
+  ctx.currentSeriesParams = seriesSet;
+
+  try {
+    const formals: string[] = [];
+    for (let i = 0; i < params.length; i++) {
+      const pine = pineParams[i]!;
+      const ident = safeIdent(pine);
+      if (seriesSet.has(pine)) formals.push(ident);
+      else formals.push(`${ident} = ${emitDefault(params[i]!, visitStmt)}`);
+    }
+
+    const lines: string[] = [];
+    for (const s of seriesLocals) {
+      const st = localSt.get(s)!;
+      const init = varDefaults.get(s);
+      const def = init != null ? visitExpr(init, visitStmt) : "null";
+      lines.push(`  if (__bar_idx === 0) ${st}[0] = ${def};`);
+      lines.push(`  else ${st}[__bar_idx] = ${st}[__bar_idx - 1];`);
+    }
+
+    const visitBody = (s: stmt): string => {
+      if (s.kind !== "Assign" && s.kind !== "ReAssign") return visitStmt(s);
+      if (s.target.kind !== "Name" || !localSt.has(s.target.id)) return visitStmt(s);
+      const st = localSt.get(s.target.id)!;
+      if (s.kind === "Assign" && isVarMode(s.mode)) return "";
+      const rhs = s.value != null ? visitExpr(s.value, visitStmt) : "null";
+      return `${st}[__bar_idx] = __h.naNum(${rhs});`;
+    };
+
+    let emittedReturn = false;
+    for (let i = 0; i < body.length; i++) {
+      const s = body[i]!;
+      const raw = visitBody(s);
+      if (!raw || !raw.trim()) continue;
+      const isLast = i === body.length - 1;
+      if (isLast && s.kind === "Expr" && !isCtrlExpr(s)) {
+        lines.push(asReturn(raw));
+        emittedReturn = true;
+        continue;
+      }
+      lines.push(indentBody(ensureSemi(raw)));
+      if (isLast && (s.kind === "Assign" || s.kind === "ReAssign")) {
+        lines.push(lastAssignReturn(s, localSt));
+        emittedReturn = true;
+      }
+    }
+    if (!emittedReturn) lines.push("  return null;");
+
+    const argList = ["__bar_idx", "__h", ...formals, ...stNames].join(", ");
+    ctx.functions.push(`function ${safe}(${argList}) {\n${lines.join("\n")}\n}`);
+  } finally {
+    ctx.currentFunc = prevFunc;
+    ctx.currentParamNames = prevParams;
+    ctx.currentSeriesParams = prevSeries;
+  }
+}
+
+export function emitUserFuncCall(ctx: EmitCtx, name: string, args: string[]): string {
+  const pine = ctx.userFuncs.has(name)
+    ? name
+    : ([...ctx.userFuncs].find((n) => safeIdent(n) === name) ?? name);
+  const safe = safeIdent(pine);
+  const st = stForFunc(ctx, pine, safe);
+  const parts = ["__bar_idx", "__h", ...args, ...st];
+  return `${safe}(${parts.join(", ")})`;
+}

package/src/runtime/compile/engine.ts

@@ -0,0 +1,265 @@
+/**
+ * Copyright (C) 2024-2026 jango_blockchained
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Compile engine: eligibility, transpile, sha256 LRU (max 128), load, run.
+ */
+import { createHash } from "node:crypto";
+import type {
+  CompileCacheStats,
+  CompileEligibility,
+  CompiledScript,
+  CompilePlotMeta,
+} from "./types.ts";
+import { CompileEmitError, CompileIneligibleError, CompileLoadError } from "./types.ts";
+import { transpileSource } from "./emit.ts";
+import { defaultTime, defaultVolume, naNum, toFloatArr } from "./helpers.ts";
+import { createCompileHelpers } from "./runtime.ts";
+import type { CompileHelperInputs } from "./runtime.ts";
+import type { DrawingEvent } from "../drawings.ts";
+import type { LogRecord } from "../log.ts";
+import type { Fill, StrategyEvent, StrategySummary } from "../strategy.ts";
+
+export type CompileRunExtras = {
+  inputs?: CompileHelperInputs;
+};
+
+const CACHE_MAX = 128;
+const cache = new Map<string, CompiledScript>();
+
+export type OhlcvBar = {
+  open?: number | null;
+  high?: number | null;
+  low?: number | null;
+  close?: number | null;
+  volume?: number | null;
+  time?: number | null;
+};
+
+export type CompileHostResult = {
+  series: Record<string, Array<number | null>>;
+  plots: Array<number | null>;
+  plot_meta: Array<{ title: string }>;
+  count: number;
+  script_name: null;
+  script_type: "indicator" | "strategy";
+  mode: "compile";
+  events?: StrategyEvent[];
+  fills?: Fill[];
+  strategy?: StrategySummary;
+  drawings?: DrawingEvent[];
+  logs?: LogRecord[];
+};
+
+/** Generated `execute_script_compiled` — helpers are injected per `run()`, not cached. */
+type CompiledExecuteFn = (
+  o: Array<number | null>,
+  h: Array<number | null>,
+  l: Array<number | null>,
+  c: Array<number | null>,
+  v: Array<number | null>,
+  t: Array<number | null>,
+  helpers: unknown,
+) => Record<string, unknown>;
+
+export function compileEligible(source: string): CompileEligibility {
+  // Python compile_script accepts `import` (library stubs in object mode).
+  // Only the auto-mode host prefilter rejects import — not this gate.
+  // request.security is also eligible (same-symbol passthrough / else na).
+  // Empty source is still ok; emit/load report later failures.
+  void source;
+  return { ok: true };
+}
+
+export type CompileScriptExtras = {
+  getLibrary?: (namespace: string, name: string, version: number) => string | null;
+};
+
+export function transpile(source: string, extras?: CompileScriptExtras): string {
+  return transpileSource(source, extras).code;
+}
+
+export function clearCompileCache(): void {
+  cache.clear();
+}
+
+export function compileCacheStats(): CompileCacheStats {
+  return { source_entries: cache.size, source_max: CACHE_MAX };
+}
+
+function sha256(s: string): string {
+  return createHash("sha256").update(s).digest("hex");
+}
+
+function loadExecute(code: string): CompiledExecuteFn {
+  let factory: () => CompiledExecuteFn;
+  try {
+    factory = new Function(`${code}\nreturn execute_script_compiled;`) as typeof factory;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new CompileLoadError(msg);
+  }
+  const fn = factory();
+  if (typeof fn !== "function") throw new CompileLoadError("execute_script_compiled missing");
+  return fn;
+}
+
+function assertSameLength(n: number, ...lens: number[]): void {
+  for (const len of lens) {
+    if (len !== n) throw new Error("OHLCV arrays must have the same length");
+  }
+}
+
+function extractOhlcv(bars: Array<OhlcvBar>): {
+  open: Array<number | null>;
+  high: Array<number | null>;
+  low: Array<number | null>;
+  close: Array<number | null>;
+  volume: Array<number | null>;
+  time: Array<number | null>;
+} {
+  const n = bars.length;
+  const open: Array<number | null> = new Array(n);
+  const high: Array<number | null> = new Array(n);
+  const low: Array<number | null> = new Array(n);
+  const close: Array<number | null> = new Array(n);
+  const volume: Array<number | null> = new Array(n);
+  const time: Array<number | null> = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const b = bars[i] ?? {};
+    open[i] = b.open ?? null;
+    high[i] = b.high ?? null;
+    low[i] = b.low ?? null;
+    close[i] = b.close ?? null;
+    volume[i] = b.volume ?? 1;
+    time[i] = b.time ?? i * 60_000;
+  }
+  assertSameLength(n, open.length, high.length, low.length, close.length, volume.length, time.length);
+  return { open, high, low, close, volume, time };
+}
+
+class JsCompiledScript implements CompiledScript {
+  readonly backend = "js" as const;
+
+  constructor(
+    readonly source: string,
+    readonly plots: CompilePlotMeta[],
+    private readonly fn: CompiledExecuteFn,
+  ) {}
+
+  run(
+    open: ArrayLike<number | null | undefined>,
+    high: ArrayLike<number | null | undefined>,
+    low: ArrayLike<number | null | undefined>,
+    close: ArrayLike<number | null | undefined>,
+    volume?: ArrayLike<number | null | undefined> | null,
+    time?: ArrayLike<number | null | undefined> | null,
+    extras?: CompileRunExtras,
+  ): Record<string, Array<number | null>> {
+    const n = close.length;
+    assertSameLength(n, open.length, high.length, low.length);
+    if (volume != null) assertSameLength(n, volume.length);
+    if (time != null) assertSameLength(n, time.length);
+    const o = toFloatArr(open, n, null);
+    const h = toFloatArr(high, n, null);
+    const l = toFloatArr(low, n, null);
+    const c = toFloatArr(close, n, null);
+    const v = volume != null ? toFloatArr(volume, n, 1) : defaultVolume(n);
+    const t = time != null ? toFloatArr(time, n, null) : defaultTime(n);
+    for (let i = 0; i < n; i++) {
+      if (v[i] == null) v[i] = 1;
+      if (t[i] == null) t[i] = i * 60_000;
+    }
+    return this.fn(o, h, l, c, v, t, createCompileHelpers({ inputs: extras?.inputs })) as Record<
+      string,
+      Array<number | null>
+    >;
+  }
+}
+
+function libraryCacheTail(
+  source: string,
+  getLibrary?: CompileScriptExtras["getLibrary"],
+): string {
+  if (getLibrary == null) return "";
+  const parts: string[] = [];
+  for (const m of source.matchAll(/import\s+(\S+)\/(\S+)\/(\d+)/g)) {
+    parts.push(getLibrary(m[1]!, m[2]!, Number(m[3])) ?? "");
+  }
+  return `\0${parts.join("\0")}`;
+}
+
+export function compileScript(source: string, extras?: CompileScriptExtras): CompiledScript {
+  const elig = compileEligible(source);
+  if (!elig.ok) throw new CompileIneligibleError(elig.reason ?? "ineligible");
+  const key = sha256(source + libraryCacheTail(source, extras?.getLibrary));
+  const hit = cache.get(key);
+  if (hit) {
+    cache.delete(key);
+    cache.set(key, hit);
+    return hit;
+  }
+  let code: string;
+  let ctx: { errors: string[]; plots: CompilePlotMeta[] };
+  try {
+    ({ code, ctx } = transpileSource(source, extras));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new CompileEmitError(msg);
+  }
+  if (ctx.errors.length) throw new CompileEmitError(ctx.errors.join("; "));
+  if (!code.includes("execute_script_compiled")) {
+    throw new CompileEmitError("empty emit");
+  }
+  const exec = loadExecute(code);
+  const compiled = new JsCompiledScript(code, ctx.plots, exec);
+  cache.set(key, compiled);
+  if (cache.size > CACHE_MAX) {
+    const first = cache.keys().next().value;
+    if (first != null) cache.delete(first);
+  }
+  return compiled;
+}
+
+export function runScript(
+  source: string,
+  ohlcvBars: Array<OhlcvBar>,
+): Record<string, Array<number | null>> {
+  const cols = extractOhlcv(ohlcvBars);
+  return compileScript(source).run(cols.open, cols.high, cols.low, cols.close, cols.volume, cols.time);
+}
+
+export function compileToResult(
+  source: string,
+  ohlcvBars: Array<OhlcvBar>,
+  extras?: CompileRunExtras,
+): CompileHostResult {
+  const compiled = compileScript(source);
+  const cols = extractOhlcv(ohlcvBars);
+  const raw = compiled.run(cols.open, cols.high, cols.low, cols.close, cols.volume, cols.time, extras);
+  const series: Record<string, Array<number | null>> = {};
+  const blob: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key.startsWith("__")) blob[key] = value;
+    else if (Array.isArray(value)) series[key] = value;
+  }
+  const plot_meta = compiled.plots;
+  const firstTitle = plot_meta.find((p) => !p.title.startsWith("__"))?.title;
+  const result: CompileHostResult = {
+    series,
+    plots: firstTitle != null ? (series[firstTitle] ?? []) : [],
+    plot_meta,
+    count: ohlcvBars.length,
+    script_name: null,
+    script_type: "__events" in blob ? "strategy" : "indicator",
+    mode: "compile",
+  };
+  if ("__events" in blob) result.events = blob.__events as StrategyEvent[];
+  if ("__fills" in blob) result.fills = blob.__fills as Fill[];
+  if ("__strategy" in blob) result.strategy = blob.__strategy as StrategySummary;
+  if ("__drawings" in blob) result.drawings = blob.__drawings as DrawingEvent[];
+  if ("__logs" in blob) result.logs = blob.__logs as LogRecord[];
+  return result;
+}
+
+export { naNum };