neuroalpha 0.0.0-stage → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +164 -3
- package/bin/cli.js +69 -0
- package/config/strategy.json +33 -0
- package/docs//320/230/320/235/320/241/320/242/320/240/320/243/320/232/320/246/320/230/320/257.md +156 -0
- package/package.json +43 -6
- package/public/app.js +2410 -0
- package/public/index.html +337 -0
- package/public/landing.html +870 -0
- package/public/legal.html +90 -0
- package/public/styles.css +343 -0
- package/server/api/routes.js +333 -0
- package/server/auth/index.js +340 -0
- package/server/billing/yookassa.js +132 -0
- package/server/brokers/index.js +645 -0
- package/server/config.js +44 -0
- package/server/data/moex.js +165 -0
- package/server/db.js +420 -0
- package/server/hub.js +14 -0
- package/server/index.js +92 -0
- package/server/llm/client.js +187 -0
- package/server/llm/providers.js +355 -0
- package/server/model/dataset.js +352 -0
- package/server/model/forecast.js +121 -0
- package/server/model/gpu-worker.html +11 -0
- package/server/model/gpu-worker.js +60 -0
- package/server/model/linalg.js +142 -0
- package/server/model/live.js +486 -0
- package/server/model/metrics.js +134 -0
- package/server/model/models.js +459 -0
- package/server/model/profiles.js +166 -0
- package/server/model/research.js +880 -0
- package/server/model/tf-node.js +26 -0
- package/server/model/transformer-core.js +330 -0
- package/server/model/transformer-gpu.js +221 -0
- package/server/model/transformer-pool.js +200 -0
- package/server/model/transformer-worker.js +28 -0
- package/server/model/transformer.js +57 -0
- package/server/model/vocab.js +28 -0
- package/server/news/index.js +309 -0
- package/server/notify/index.js +168 -0
- package/server/params-meta.js +63 -0
- package/server/settings.js +79 -0
- package/server/strategist/analytics.js +150 -0
- package/server/strategist/index.js +484 -0
- package/server/strategist/tools.js +302 -0
- package/server/util.js +9 -0
|
@@ -0,0 +1,200 @@
|
|
|
1
|
+
// Обучение трансформера вне главного потока сервера.
|
|
2
|
+
// • CpuPool — пул рабочих потоков (worker_threads): окна обучаются одновременно, каждый поток — по очереди своё окно.
|
|
3
|
+
// • Видеокарта — через безголовый браузер (transformer-gpu.js), окна по очереди.
|
|
4
|
+
// • fitPredictIsolated — одно окно (прогноз «сейчас», живая проверка): в отдельном потоке или на видеокарте.
|
|
5
|
+
// Если потоки или видеокарта недоступны — тихий откат: на процессор / в главный поток.
|
|
6
|
+
import os from 'node:os';
|
|
7
|
+
import { Worker } from 'node:worker_threads';
|
|
8
|
+
import { TF_CFG, fitPredictCore } from './transformer-core.js';
|
|
9
|
+
import { loadTf } from './tf-node.js';
|
|
10
|
+
|
|
11
|
+
const WORKER_URL = new URL('./transformer-worker.js', import.meta.url);
|
|
12
|
+
// память одного потока сверх данных окна: TensorFlow.js + WASM, с запасом
|
|
13
|
+
const BASE_MEM = 250 * 1024 * 1024;
|
|
14
|
+
|
|
15
|
+
// Сколько потоков: ядер − 1 (одно — главному потоку), не больше числа окон и не больше, чем помещается
|
|
16
|
+
// в половину свободной памяти. TRANSFORMER_THREADS — ручное переопределение.
|
|
17
|
+
export function planThreads(jobs, bytes) {
|
|
18
|
+
const env = Math.floor(Number(process.env.TRANSFORMER_THREADS));
|
|
19
|
+
if (env >= 1) return { n: Math.max(1, Math.min(env, jobs)), source: 'TRANSFORMER_THREADS' };
|
|
20
|
+
const cpu = Math.max(1, (os.availableParallelism?.() ?? os.cpus().length) - 1);
|
|
21
|
+
const mem = Math.max(1, Math.floor((os.freemem() * 0.5) / (BASE_MEM + 3 * bytes)));
|
|
22
|
+
return { n: Math.max(1, Math.min(cpu, jobs, mem)), cpu, mem, source: 'auto' };
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
const cancelError = () => new Error('Отменено');
|
|
26
|
+
|
|
27
|
+
// Все уникальные буферы массивов объекта — для передачи в поток без копирования
|
|
28
|
+
function buffersOf(x, out = new Set()) {
|
|
29
|
+
if (ArrayBuffer.isView(x)) out.add(x.buffer);
|
|
30
|
+
else if (Array.isArray(x)) x.forEach((v) => buffersOf(v, out));
|
|
31
|
+
else if (x && typeof x === 'object') Object.values(x).forEach((v) => buffersOf(v, out));
|
|
32
|
+
return out;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
const toPreds = (us, flat, N) => {
|
|
36
|
+
const preds = new Map();
|
|
37
|
+
us.forEach((u, k) => preds.set(u, flat.subarray(k * N, (k + 1) * N)));
|
|
38
|
+
return preds;
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
let seq = 0;
|
|
42
|
+
|
|
43
|
+
export class CpuPool {
|
|
44
|
+
constructor(n) {
|
|
45
|
+
this.threads = n;
|
|
46
|
+
this.where = 'процессор';
|
|
47
|
+
this.slots = [];
|
|
48
|
+
this.queue = [];
|
|
49
|
+
this.closed = false;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
// Запуск первого потока и ожидание его готовности: если потоки не запускаются — ошибка сразу
|
|
53
|
+
async start(timeoutMs = 15000) {
|
|
54
|
+
const slot = this.#spawn();
|
|
55
|
+
await new Promise((resolve, reject) => {
|
|
56
|
+
const t = setTimeout(() => reject(new Error('поток не запустился')), timeoutMs);
|
|
57
|
+
slot.w.once('online', () => { clearTimeout(t); resolve(); });
|
|
58
|
+
slot.w.once('error', (e) => { clearTimeout(t); reject(e); });
|
|
59
|
+
});
|
|
60
|
+
return this;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
#spawn() {
|
|
64
|
+
const w = new Worker(WORKER_URL);
|
|
65
|
+
const slot = { w, job: null };
|
|
66
|
+
w.on('message', (m) => this.#onMessage(slot, m));
|
|
67
|
+
w.on('error', (e) => this.#onFail(slot, e));
|
|
68
|
+
w.on('exit', (code) => this.#onFail(slot, new Error(`поток трансформера завершился (код ${code})`)));
|
|
69
|
+
this.slots.push(slot);
|
|
70
|
+
return slot;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
// Окно в очередь. transfer — передать массивы окна в поток без копирования (у вызывающего они станут пустыми)
|
|
74
|
+
submit(input, us, cfg, { onProgress, transfer = false } = {}) {
|
|
75
|
+
if (this.closed) return Promise.reject(cancelError());
|
|
76
|
+
return new Promise((resolve, reject) => {
|
|
77
|
+
this.queue.push({ input, us: Int32Array.from(us), cfg, onProgress, transfer, resolve, reject, N: input.N });
|
|
78
|
+
this.#pump();
|
|
79
|
+
});
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
// Сколько окон ещё не готово (в очереди и в работе)
|
|
83
|
+
get backlog() {
|
|
84
|
+
return this.queue.length + this.slots.filter((s) => s.job).length;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
#pump() {
|
|
88
|
+
while (!this.closed && this.queue.length) {
|
|
89
|
+
let slot = this.slots.find((s) => !s.job);
|
|
90
|
+
if (!slot && this.slots.length < this.threads) slot = this.#spawn();
|
|
91
|
+
if (!slot) break;
|
|
92
|
+
const job = this.queue.shift();
|
|
93
|
+
job.id = ++seq;
|
|
94
|
+
slot.job = job;
|
|
95
|
+
const msg = { type: 'fit', id: job.id, input: job.input, us: job.us, cfg: job.cfg };
|
|
96
|
+
slot.w.postMessage(msg, job.transfer ? [...buffersOf(msg)] : []);
|
|
97
|
+
// копия (или сами массивы) ушла в поток — у себя не держим
|
|
98
|
+
job.input = null;
|
|
99
|
+
job.us = null;
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
#onMessage(slot, m) {
|
|
104
|
+
const job = slot.job;
|
|
105
|
+
if (!job || m.id !== job.id) return;
|
|
106
|
+
if (m.type === 'progress') { job.onProgress?.(m); return; }
|
|
107
|
+
slot.job = null;
|
|
108
|
+
if (m.type === 'done') job.resolve({ preds: toPreds(m.us, m.flat, job.N), info: m.info });
|
|
109
|
+
else job.reject(m.cancelled || this.closed ? cancelError() : new Error(m.error));
|
|
110
|
+
this.#pump();
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
#onFail(slot, e) {
|
|
114
|
+
const k = this.slots.indexOf(slot);
|
|
115
|
+
if (k < 0) return;
|
|
116
|
+
this.slots.splice(k, 1);
|
|
117
|
+
if (slot.job) {
|
|
118
|
+
const err = this.closed ? cancelError() : Object.assign(new Error(`Трансформер: ${e.message}`), { workerFailed: true });
|
|
119
|
+
slot.job.reject(err);
|
|
120
|
+
slot.job = null;
|
|
121
|
+
}
|
|
122
|
+
if (!this.closed) this.#pump();
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
// Отмена: просим потоки остановиться между батчами; через 3 с — принудительно
|
|
126
|
+
cancel() {
|
|
127
|
+
if (this.closed) return;
|
|
128
|
+
for (const s of this.slots) s.w.postMessage({ type: 'cancel' });
|
|
129
|
+
for (const j of this.queue.splice(0)) j.reject(cancelError());
|
|
130
|
+
setTimeout(() => this.close(), 3000).unref();
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
async close() {
|
|
134
|
+
if (this.closed && !this.slots.length) return;
|
|
135
|
+
this.closed = true;
|
|
136
|
+
for (const j of this.queue.splice(0)) j.reject(cancelError());
|
|
137
|
+
const slots = this.slots.splice(0);
|
|
138
|
+
for (const s of slots) if (s.job) { s.job.reject(cancelError()); s.job = null; }
|
|
139
|
+
await Promise.all(slots.map((s) => s.w.terminate().catch(() => {})));
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
const gpuModule = () => import('./transformer-gpu.js');
|
|
144
|
+
|
|
145
|
+
// Исполнитель для исследования: видеокарта (если включена и доступна) → пул потоков (если включены) → null (последовательно).
|
|
146
|
+
// note — почему пришлось откатиться (для прогресса и журнала)
|
|
147
|
+
export async function openTransformerRunner({ gpu = false, parallel = true, jobs = 1, bytes = 0 } = {}) {
|
|
148
|
+
let note = '';
|
|
149
|
+
if (gpu) {
|
|
150
|
+
try {
|
|
151
|
+
const { GpuRunner } = await gpuModule();
|
|
152
|
+
return { runner: await new GpuRunner().start(), note };
|
|
153
|
+
} catch (e) {
|
|
154
|
+
note = `видеокарта недоступна (${e.message}) — обучаем на процессоре`;
|
|
155
|
+
console.warn(`Трансформер: ${note}`);
|
|
156
|
+
}
|
|
157
|
+
}
|
|
158
|
+
if (!parallel) return { runner: null, note };
|
|
159
|
+
const plan = planThreads(jobs, bytes);
|
|
160
|
+
const pool = new CpuPool(plan.n);
|
|
161
|
+
try {
|
|
162
|
+
await pool.start();
|
|
163
|
+
pool.plan = plan;
|
|
164
|
+
return { runner: pool, note };
|
|
165
|
+
} catch (e) {
|
|
166
|
+
await pool.close();
|
|
167
|
+
const msg = `потоки не запустились (${e.message}) — обучаем последовательно`;
|
|
168
|
+
console.warn(`Трансформер: ${msg}`);
|
|
169
|
+
return { runner: null, note: note ? `${note}; ${msg}` : msg };
|
|
170
|
+
}
|
|
171
|
+
}
|
|
172
|
+
|
|
173
|
+
// Одно окно: { preds, info, where }. Видеокарта (общий браузер с таймаутом простоя) → отдельный поток → главный поток
|
|
174
|
+
export async function fitPredictIsolated(input, us, cfg = {}, { gpu = false } = {}) {
|
|
175
|
+
if (gpu) {
|
|
176
|
+
try {
|
|
177
|
+
const { sharedGpu } = await gpuModule();
|
|
178
|
+
const g = await sharedGpu();
|
|
179
|
+
return { ...(await g.submit(input, us, cfg)), where: g.where };
|
|
180
|
+
} catch (e) {
|
|
181
|
+
if (e.message === 'Отменено') throw e;
|
|
182
|
+
console.warn(`Трансформер: видеокарта недоступна (${e.message}) — обучаем на процессоре`);
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
const pool = new CpuPool(1);
|
|
186
|
+
let started = false;
|
|
187
|
+
try {
|
|
188
|
+
await pool.start();
|
|
189
|
+
started = true;
|
|
190
|
+
return { ...(await pool.submit(input, us, cfg)), where: 'процессор' };
|
|
191
|
+
} catch (e) {
|
|
192
|
+
if (started && !e.workerFailed) throw e;
|
|
193
|
+
// потоки недоступны — обучаем прямо здесь (сервер на это время занят)
|
|
194
|
+
console.warn(`Трансформер: отдельный поток недоступен (${e.message}) — обучаем в главном потоке`);
|
|
195
|
+
const tf = await loadTf();
|
|
196
|
+
return { ...(await fitPredictCore(tf, input, us, { cfg: { ...TF_CFG, ...cfg } })), where: 'процессор' };
|
|
197
|
+
} finally {
|
|
198
|
+
await pool.close();
|
|
199
|
+
}
|
|
200
|
+
}
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
// Рабочий поток: грузит TensorFlow.js один раз и обучает трансформер по окнам по очереди.
|
|
2
|
+
// Сообщения: { type: 'fit', id, input, us, cfg } → { type: 'progress' | 'done' | 'error', id, ... }; { type: 'cancel' }.
|
|
3
|
+
import { parentPort } from 'node:worker_threads';
|
|
4
|
+
import { loadTf } from './tf-node.js';
|
|
5
|
+
import { fitPredictCore } from './transformer-core.js';
|
|
6
|
+
|
|
7
|
+
let cancelled = false;
|
|
8
|
+
|
|
9
|
+
parentPort.on('message', async (m) => {
|
|
10
|
+
if (m.type === 'cancel') { cancelled = true; return; }
|
|
11
|
+
if (m.type !== 'fit') return;
|
|
12
|
+
const { id } = m;
|
|
13
|
+
try {
|
|
14
|
+
const tf = await loadTf();
|
|
15
|
+
const r = await fitPredictCore(tf, m.input, m.us, {
|
|
16
|
+
cfg: m.cfg,
|
|
17
|
+
isCancelled: () => cancelled,
|
|
18
|
+
onProgress: (x) => parentPort.postMessage({ type: 'progress', id, ...x }),
|
|
19
|
+
});
|
|
20
|
+
// прогнозы одним плоским массивом — передаём без копирования
|
|
21
|
+
const N = m.input.N, us = Int32Array.from(r.preds.keys());
|
|
22
|
+
const flat = new Float64Array(us.length * N);
|
|
23
|
+
us.forEach((u, k) => flat.set(r.preds.get(u), k * N));
|
|
24
|
+
parentPort.postMessage({ type: 'done', id, us, flat, info: { ...r.info, tensors: tf.memory().numTensors, backend: tf.getBackend() } }, [us.buffer, flat.buffer]);
|
|
25
|
+
} catch (e) {
|
|
26
|
+
parentPort.postMessage({ type: 'error', id, error: e.message, cancelled });
|
|
27
|
+
}
|
|
28
|
+
});
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
// Ступень 3: небольшой трансформер с вниманием МЕЖДУ АКЦИЯМИ.
|
|
2
|
+
// Само обучение — в transformer-core.js (общий код для Node и браузера); здесь — обёртка для главного потока:
|
|
3
|
+
// подготовка «облегчённого окна» и настройки из параметров.
|
|
4
|
+
// Обучается в каждом окне с нуля, только на данных окна обучения (как остальные модели).
|
|
5
|
+
import { LIQ_MIN, trainUs } from './models.js';
|
|
6
|
+
import { TF_CFG, fitCore, predictCore } from './transformer-core.js';
|
|
7
|
+
import { loadTf } from './tf-node.js';
|
|
8
|
+
|
|
9
|
+
export { TF_CFG, loadTf };
|
|
10
|
+
|
|
11
|
+
// Настройки обучения из параметров стратегии (эпохи и шаг свечей); остальное — TF_CFG
|
|
12
|
+
export const transformerCfg = (p) => ({
|
|
13
|
+
epochs: Math.round(p.transformerEpochs ?? TF_CFG.epochs),
|
|
14
|
+
stride: Math.round(p.transformerStride ?? TF_CFG.stride),
|
|
15
|
+
});
|
|
16
|
+
|
|
17
|
+
// Из полного окна — только то, что нужно трансформеру (без карты рынка, сырых доходностей и т.п.)
|
|
18
|
+
export function transformerInput(f) {
|
|
19
|
+
return {
|
|
20
|
+
N: f.N, W: f.W, H: f.H, liqMin: LIQ_MIN,
|
|
21
|
+
X: f.X, liq: f.liq, has: f.has, yz: f.yz,
|
|
22
|
+
macro: f.macro ? { list: f.macro.list.map((m) => ({ b: m.b, zs: m.zs })) } : null,
|
|
23
|
+
tr: Int32Array.from(trainUs(f)),
|
|
24
|
+
};
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
// Объём массивов окна в байтах (для оценки памяти потоков)
|
|
28
|
+
export function inputBytes(x) {
|
|
29
|
+
let s = 0;
|
|
30
|
+
const walk = (v) => {
|
|
31
|
+
if (ArrayBuffer.isView(v)) s += v.byteLength;
|
|
32
|
+
else if (Array.isArray(v)) v.forEach(walk);
|
|
33
|
+
else if (v && typeof v === 'object') Object.values(v).forEach(walk);
|
|
34
|
+
};
|
|
35
|
+
walk(x);
|
|
36
|
+
return s;
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
// Обучение в окне в главном потоке. onProgress({ epoch, epochs }) — в начале каждой эпохи; isCancelled() → прерывание между батчами
|
|
40
|
+
export async function fitTransformer(f, { onProgress = () => {}, isCancelled = () => false, cfg = {} } = {}) {
|
|
41
|
+
const tf = await loadTf();
|
|
42
|
+
const x = transformerInput(f);
|
|
43
|
+
const model = await fitCore(tf, x, { onProgress, isCancelled, cfg });
|
|
44
|
+
model.tf = tf;
|
|
45
|
+
model.input = x;
|
|
46
|
+
model.predictOne = predictTransformer;
|
|
47
|
+
model.predictMany = predictManyTransformer;
|
|
48
|
+
return model;
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
// Прогноз сразу по многим моментам: Map(u → Float64Array(N)) в единицах yz
|
|
52
|
+
export function predictManyTransformer(model, f, us) {
|
|
53
|
+
return predictCore(model.tf, model, model.input, us);
|
|
54
|
+
}
|
|
55
|
+
export function predictTransformer(model, f, u) {
|
|
56
|
+
return predictCore(model.tf, model, model.input, [u]).get(u);
|
|
57
|
+
}
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { kvGet, kvSet } from '../db.js';
|
|
2
|
+
|
|
3
|
+
// «Словарь» модели: акции индекса широкого рынка МосБиржи (MOEXBMI, ~100 бумаг)
|
|
4
|
+
const URL = 'https://iss.moex.com/iss/statistics/engines/stock/markets/index/analytics/MOEXBMI.json?iss.meta=off&limit=100';
|
|
5
|
+
const MAX_AGE = 30 * 86400000;
|
|
6
|
+
|
|
7
|
+
export async function ensureVocab({ refresh = false } = {}) {
|
|
8
|
+
const cached = kvGet('vocab');
|
|
9
|
+
if (cached && !refresh && Date.now() - cached.ts < MAX_AGE) return cached.list;
|
|
10
|
+
try {
|
|
11
|
+
const list = [];
|
|
12
|
+
for (let start = 0; start < 500; start += 100) {
|
|
13
|
+
const res = await fetch(`${URL}&start=${start}`, { signal: AbortSignal.timeout(30000) });
|
|
14
|
+
if (!res.ok) throw new Error(`HTTP ${res.status}`);
|
|
15
|
+
const j = await res.json();
|
|
16
|
+
const cols = j.analytics.columns;
|
|
17
|
+
const ix = (c) => cols.indexOf(c);
|
|
18
|
+
for (const r of j.analytics.data) list.push({ symbol: r[ix('ticker')], name: r[ix('shortnames')], weight: r[ix('weight')] });
|
|
19
|
+
if (j.analytics.data.length < 100) break;
|
|
20
|
+
}
|
|
21
|
+
if (list.length < 20) throw new Error('слишком короткий список');
|
|
22
|
+
kvSet('vocab', { ts: Date.now(), list });
|
|
23
|
+
return list;
|
|
24
|
+
} catch (e) {
|
|
25
|
+
if (cached) return cached.list;
|
|
26
|
+
throw new Error(`Не удалось получить состав индекса MOEXBMI: ${e.message}`);
|
|
27
|
+
}
|
|
28
|
+
}
|
|
@@ -0,0 +1,309 @@
|
|
|
1
|
+
import { db } from '../db.js';
|
|
2
|
+
import { hub } from '../hub.js';
|
|
3
|
+
import { getSettings } from '../settings.js';
|
|
4
|
+
import { ensureVocab } from '../model/vocab.js';
|
|
5
|
+
import { chatStream, extractJson, isLlmEnabled } from '../llm/client.js';
|
|
6
|
+
import { round, DAY, MSK } from '../util.js';
|
|
7
|
+
|
|
8
|
+
// Новости и раскрытия эмитентов — ТОЛЬКО для прогноза «сейчас» и живой проверки.
|
|
9
|
+
// В исторической проверке не используются: истории новостей нет, и ИИ, знающий будущее,
|
|
10
|
+
// исказил бы проверку (как и в профилях компаний — см. model/profiles.js).
|
|
11
|
+
|
|
12
|
+
// Бесплатные источники без ключей (проверены: остальные, например e-disclosure, отдают 403)
|
|
13
|
+
const SOURCES = [
|
|
14
|
+
{ id: 'Интерфакс', url: 'https://www.interfax.ru/rss.asp', kind: 'rss' },
|
|
15
|
+
{ id: 'РБК', url: 'https://rssexport.rbc.ru/rbcnews/news/30/full.rss', kind: 'rss' },
|
|
16
|
+
{ id: 'Прайм', url: 'https://1prime.ru/export/rss2/archive/index.xml', kind: 'rss' },
|
|
17
|
+
{ id: 'ТАСС', url: 'https://tass.ru/rss/v2.xml', kind: 'rss' },
|
|
18
|
+
{ id: 'Мосбиржа', url: 'https://iss.moex.com/iss/sitenews.json?iss.meta=off&limit=100', kind: 'moex' },
|
|
19
|
+
];
|
|
20
|
+
|
|
21
|
+
const KEEP_DAYS = 14; // сколько дней хранить новости
|
|
22
|
+
const BATCH = 20; // сколько заголовков за один вопрос ИИ
|
|
23
|
+
const MAX_PER_CYCLE = 100; // не больше стольких заголовков уходит в ИИ за цикл (экономия токенов)
|
|
24
|
+
const FETCH_TIMEOUT = 20000;
|
|
25
|
+
|
|
26
|
+
// ---------- дешёвый фильтр: какие заголовки вообще отправлять в ИИ ----------
|
|
27
|
+
// Короткие названия Мосбиржи — аббревиатуры («Татнфт 3ао», «ГМКНорНик»), поэтому сравниваем
|
|
28
|
+
// первые 4 буквы слов названия и короткие слова целиком, плюс список полных названий (ALIASES).
|
|
29
|
+
// Заголовки без упоминания компаний и без экономических слов (спорт, политика) в базу
|
|
30
|
+
// и в ИИ не попадают совсем — это главная экономия токенов.
|
|
31
|
+
const NAME_STOP = new Set(['ао', 'ап', 'др', 'п', 'преф', 'мкпао', 'пао', 'оао', '2ао', '3ао', '3ап', '4ао']); // классы акций
|
|
32
|
+
const WORD_STOP = new Set(['спб', 'дом', 'рф', 'ру', 'ви', 'т', 'эн', 'икс', 'кц', '2', '5']); // слишком общие короткие слова
|
|
33
|
+
const PREFIX_STOP = new Set(['сист', 'лент', 'арен', 'позит', 'займ', 'нова', 'инте', 'росс', 'рост', 'техн', 'тран', 'пром']); // слишком общие начала слов
|
|
34
|
+
// Названия, которые в новостях не выводятся из короткого имени — для них точная подстрока
|
|
35
|
+
const ALIASES = [
|
|
36
|
+
['афк', 'AFKS'], ['норник', 'GMKN'], ['норильск', 'GMKN'], ['ависма', 'VSMO'], ['whoosh', 'WUSH'],
|
|
37
|
+
['fesco', 'FESH'], ['headhunter', 'HEAD'], ['hh.ru', 'HEAD'], ['x5', 'X5'], ['икс5', 'X5'],
|
|
38
|
+
['дом.рф', 'DOMRF'], ['новатэк', 'NVTK'], ['новатек', 'NVTK'], ['интерао', 'IRAO'], ['интер рао', 'IRAO'],
|
|
39
|
+
['ростел', 'RTKM'], ['ростелек', 'RTKM'], ['россет', 'FEES'], ['транснеф', 'TRNFP'],
|
|
40
|
+
['т-банк', 'T'], ['тбанк', 'T'], ['т-техн', 'T'], ['positive technologies', 'POSI'], ['позитив тек', 'POSI'],
|
|
41
|
+
['аренадат', 'DATA'], ['aredata', 'DATA'], ['beluga', 'BELU'], ['новабев', 'BELU'],
|
|
42
|
+
['южуралзолот', 'GEMC'], ['фикс прайс', 'FIXR'], ['fix price', 'FIXR'], ['эн+', 'ENPG'],
|
|
43
|
+
['вконтакте', 'VKCO'], ['займер', 'ZAYM'], ['северстал', 'CHMF'], ['промомед', 'PRMD'], ['md medical', 'MDMG'],
|
|
44
|
+
];
|
|
45
|
+
// Общие экономические слова: новость с ними идёт в ИИ, даже если компания не названа
|
|
46
|
+
// (ставка ЦБ, нефть, рубль, санкции, дивиденды и т.п.)
|
|
47
|
+
const MACRO = ['ставк', 'центробанк', 'банк россии', 'ключев', 'нефть', 'нефтян', 'рубл', 'валют', 'доллар', 'юан',
|
|
48
|
+
'санкц', 'дивиденд', 'инфляц', 'облигац', 'офз', 'мосбирж', 'moex', 'бирж', 'торги', 'золот', 'делистинг',
|
|
49
|
+
'листинг', 'дефолт', 'buyback', 'выкуп', 'ipo', 'эмбарг', 'brent', 'rgbi', 'ввп', 'экспорт', 'рынок акций'];
|
|
50
|
+
|
|
51
|
+
const wordRe = (w) => new RegExp(`(^|[^0-9a-zа-яё])${w}([^0-9a-zа-яё]|$)`, 'i');
|
|
52
|
+
|
|
53
|
+
function buildMatcher(vocab) {
|
|
54
|
+
const known = new Set(vocab.map((c) => c.symbol));
|
|
55
|
+
const tickers = vocab.filter((c) => c.symbol.length >= 2 && c.symbol !== 'T').map((c) => [wordRe(c.symbol.toLowerCase()), c.symbol]);
|
|
56
|
+
const prefixes = [];
|
|
57
|
+
const words = [];
|
|
58
|
+
for (const c of vocab) {
|
|
59
|
+
for (const w of c.name.toLowerCase().replace(/["«»+]/g, ' ').split(/[^0-9a-zа-яё]+/).filter(Boolean)) {
|
|
60
|
+
if (NAME_STOP.has(w)) continue;
|
|
61
|
+
if (w.length >= 5) { const p = w.slice(0, 4); if (!PREFIX_STOP.has(p)) prefixes.push([p, c.symbol]); }
|
|
62
|
+
else if (w.length >= 2 && !WORD_STOP.has(w)) words.push([wordRe(w), c.symbol]);
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
const aliases = ALIASES.filter(([, s]) => known.has(s));
|
|
66
|
+
return { known, tickers, prefixes, words, aliases };
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
// Чем заголовок интересен: затронутые тикеры (могут быть неточными — ИИ уточнит) и есть ли экономические слова
|
|
70
|
+
function matchTitle(m, title) {
|
|
71
|
+
const t = title.toLowerCase();
|
|
72
|
+
const syms = new Set();
|
|
73
|
+
for (const [re, s] of m.tickers) if (re.test(t)) syms.add(s);
|
|
74
|
+
for (const [p, s] of m.prefixes) if (t.includes(p)) syms.add(s);
|
|
75
|
+
for (const [re, s] of m.words) if (re.test(t)) syms.add(s);
|
|
76
|
+
for (const [a, s] of m.aliases) if (t.includes(a)) syms.add(s);
|
|
77
|
+
return { syms, hot: syms.size > 0 || MACRO.some((w) => t.includes(w)) };
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
// ---------- загрузка источников ----------
|
|
81
|
+
async function fetchSource(src) {
|
|
82
|
+
const res = await fetch(src.url, { signal: AbortSignal.timeout(FETCH_TIMEOUT), headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' } });
|
|
83
|
+
if (!res.ok) throw new Error(`HTTP ${res.status}`);
|
|
84
|
+
if (src.kind === 'moex') return parseMoex(await res.json());
|
|
85
|
+
const buf = Buffer.from(await res.arrayBuffer());
|
|
86
|
+
// кодировка из объявления XML или заголовка (исторически у наших лент бывает windows-1251)
|
|
87
|
+
const charset = /encoding=["']([\w-]+)["']/i.exec(buf.subarray(0, 300).toString('latin1'))?.[1]
|
|
88
|
+
|| /charset=([\w-]+)/i.exec(res.headers.get('content-type') || '')?.[1] || 'utf-8';
|
|
89
|
+
let text;
|
|
90
|
+
try { text = new TextDecoder(charset).decode(buf); } catch { text = buf.toString('utf8'); }
|
|
91
|
+
return parseRss(text);
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
const unesc = (s) => s.replace(/<!\[CDATA\[|\]\]>/g, '').replace(/<[^>]+>/g, '')
|
|
95
|
+
.replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"')
|
|
96
|
+
.replace(/�?39;|'/g, "'").replace(/ /g, ' ').replace(/&/g, '&').replace(/\s+/g, ' ').trim();
|
|
97
|
+
|
|
98
|
+
// Разбор RSS простым регулярным выражением: item → title/link/pubDate
|
|
99
|
+
function parseRss(xml) {
|
|
100
|
+
const tag = (s, name) => {
|
|
101
|
+
const m = new RegExp(`<${name}[^>]*>\\s*(?:<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>|([\\s\\S]*?))\\s*</${name}>`, 'i').exec(s);
|
|
102
|
+
return m ? (m[1] ?? m[2] ?? '') : '';
|
|
103
|
+
};
|
|
104
|
+
const out = [];
|
|
105
|
+
for (const chunk of xml.split(/<item[\s>]/).slice(1)) {
|
|
106
|
+
const body = chunk.split('</item>')[0];
|
|
107
|
+
const title = unesc(tag(body, 'title'));
|
|
108
|
+
if (title.length < 15) continue;
|
|
109
|
+
const pub = tag(body, 'pubDate') || tag(body, 'dc:date');
|
|
110
|
+
const ts = Date.parse(unesc(pub));
|
|
111
|
+
out.push({ title, link: unesc(tag(body, 'link')), ts: Number.isFinite(ts) ? ts : Date.now() });
|
|
112
|
+
}
|
|
113
|
+
return out;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
// Новости Мосбиржи — JSON из ISS (время уже московское)
|
|
117
|
+
function parseMoex(j) {
|
|
118
|
+
const cols = j.sitenews?.columns || [];
|
|
119
|
+
const ix = (c) => cols.indexOf(c);
|
|
120
|
+
return (j.sitenews?.data || []).map((r) => ({
|
|
121
|
+
title: String(r[ix('title')] || '').replace(/\s+/g, ' ').trim(),
|
|
122
|
+
link: `https://www.moex.com/ru/news/item/${r[ix('id')]}`,
|
|
123
|
+
ts: Date.parse(`${String(r[ix('published_at')]).replace(' ', 'T')}+03:00`),
|
|
124
|
+
})).filter((x) => x.title.length >= 15 && Number.isFinite(x.ts));
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// ---------- сбор ----------
|
|
128
|
+
// Дубли — по хэшу нормализованного заголовка и дня (одна новость в разных источниках не двоится)
|
|
129
|
+
function titleHash(title, ts) {
|
|
130
|
+
const norm = `${title.toLowerCase().replace(/[^0-9a-zа-яё]+/gi, '')}|${new Date(ts + MSK).toISOString().slice(0, 10)}`;
|
|
131
|
+
let h = 5381;
|
|
132
|
+
for (let i = 0; i < norm.length; i++) h = ((h * 33) ^ norm.charCodeAt(i)) >>> 0;
|
|
133
|
+
return h.toString(36);
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
async function collectOnce() {
|
|
137
|
+
const p = getSettings();
|
|
138
|
+
if (!p.newsEnabled) return;
|
|
139
|
+
db.prepare('DELETE FROM news WHERE ts < ?').run(Date.now() - KEEP_DAYS * DAY);
|
|
140
|
+
const vocab = await ensureVocab().catch(() => null);
|
|
141
|
+
if (!vocab?.length) return;
|
|
142
|
+
const m = buildMatcher(vocab);
|
|
143
|
+
const results = await Promise.allSettled(SOURCES.map(fetchSource)); // ошибка источника не роняет остальные
|
|
144
|
+
const ins = db.prepare('INSERT OR IGNORE INTO news (ts, src, title, link, hash) VALUES (?, ?, ?, ?, ?)');
|
|
145
|
+
const perSource = {};
|
|
146
|
+
let fresh = 0;
|
|
147
|
+
results.forEach((r, i) => {
|
|
148
|
+
if (r.status !== 'fulfilled') { console.error(`Новости: ${SOURCES[i].id}: ${r.reason?.message || r.reason}`); return; }
|
|
149
|
+
let n = 0;
|
|
150
|
+
for (const it of r.value) {
|
|
151
|
+
if (it.ts < Date.now() - 3 * DAY || it.ts > Date.now() + 3600000) continue; // старьё и будущее не берём
|
|
152
|
+
if (!matchTitle(m, it.title).hot) continue;
|
|
153
|
+
n += ins.run(it.ts, SOURCES[i].id, it.title, it.link || '', titleHash(it.title, it.ts)).changes;
|
|
154
|
+
}
|
|
155
|
+
perSource[SOURCES[i].id] = n;
|
|
156
|
+
});
|
|
157
|
+
fresh = Object.values(perSource).reduce((a, b) => a + b, 0);
|
|
158
|
+
if (fresh) {
|
|
159
|
+
console.log(`Новости: +${fresh} (${Object.entries(perSource).map(([k, v]) => `${k} ${v}`).join(', ')})`);
|
|
160
|
+
hub.emit({ type: 'news:update', fresh });
|
|
161
|
+
}
|
|
162
|
+
await markPending(vocab, m);
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
// ---------- разметка ИИ ----------
|
|
166
|
+
const SYSTEM = (list) => `Ты — аналитик российского рынка акций. Для каждой новости (номер, источник, заголовок) определи:
|
|
167
|
+
- stocks — каких акций из списка ниже касается новость: массив пар ["ТИКЕР", тон]. Только тикеры из списка; компания названа явно или очевидно подразумевается. У общих новостей (ставка ЦБ, нефть, курс рубля, рынок в целом) без конкретной компании — пустой массив [].
|
|
168
|
+
- тон каждой акции — число от −1 (очень плохая новость для акции) через 0 (нейтрально) до +1 (очень хорошая).
|
|
169
|
+
- imp — важность: от 0 (на цену не повлияет) до 1 (очень сильное влияние в ближайшие часы).
|
|
170
|
+
- gist — суть новости по-русски, до 12 слов, без оценок.
|
|
171
|
+
|
|
172
|
+
Суди только по заголовку, не придумывай подробностей. Ответ — только JSON вида
|
|
173
|
+
{"1":{"stocks":[["SBER",0.6]],"imp":0.7,"gist":"…"}} — по записи на каждый номер новости, без пояснений.
|
|
174
|
+
|
|
175
|
+
Список акций (тикер — название):
|
|
176
|
+
${list}`;
|
|
177
|
+
|
|
178
|
+
async function askBatch(batch, vocab) {
|
|
179
|
+
const r = await chatStream([
|
|
180
|
+
{ role: 'system', content: SYSTEM(vocab.map((c) => `${c.symbol} — ${c.name}`).join('\n')) },
|
|
181
|
+
{ role: 'user', content: `Новости:\n${batch.map((n, k) => `${k + 1}. [${n.src}] ${n.title}`).join('\n')}` },
|
|
182
|
+
], { temperature: 0, maxTokens: 6000 });
|
|
183
|
+
const j = extractJson(r.content);
|
|
184
|
+
if (!j || typeof j !== 'object' || Array.isArray(j)) throw new Error('ИИ вернул не объект');
|
|
185
|
+
return j;
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
function markRow(id, tags, imp, gist) {
|
|
189
|
+
const tones = tags.map(([, t]) => t).filter(Number.isFinite);
|
|
190
|
+
const tone = tones.length ? round(tones.reduce((a, b) => a + b, 0) / tones.length, 2) : null;
|
|
191
|
+
db.prepare('UPDATE news SET tags = ?, gist = ?, imp = ?, tone = ?, marked = 1 WHERE id = ?')
|
|
192
|
+
.run(JSON.stringify(tags), gist, imp, tone, id);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
async function markPending(vocab, m) {
|
|
196
|
+
const rows = db.prepare('SELECT * FROM news WHERE marked = 0 AND tries < 3 ORDER BY ts DESC LIMIT ?').all(MAX_PER_CYCLE);
|
|
197
|
+
if (!rows.length) return;
|
|
198
|
+
// ИИ не подключён — сопоставление только по названиям компаний, без тона и сути
|
|
199
|
+
if (!isLlmEnabled()) {
|
|
200
|
+
for (const r of rows) markRow(r.id, [...matchTitle(m, r.title).syms].map((s) => [s, null]), null, null);
|
|
201
|
+
hub.emit({ type: 'news:update' });
|
|
202
|
+
return;
|
|
203
|
+
}
|
|
204
|
+
const fail = db.prepare('UPDATE news SET tries = tries + 1, marked = CASE WHEN tries >= 2 THEN 2 ELSE marked END WHERE id = ?');
|
|
205
|
+
let marked = 0;
|
|
206
|
+
for (let i = 0; i < rows.length; i += BATCH) {
|
|
207
|
+
const batch = rows.slice(i, i + BATCH);
|
|
208
|
+
let got = null;
|
|
209
|
+
for (let a = 0; a < 2 && !got; a++) { // одна повторная попытка на пачку, как в профилях
|
|
210
|
+
try { got = await askBatch(batch, vocab); } catch { /* повтор */ }
|
|
211
|
+
}
|
|
212
|
+
if (!got) { for (const r of batch) fail.run(r.id); continue; }
|
|
213
|
+
for (let k = 0; k < batch.length; k++) {
|
|
214
|
+
const g = got[String(k + 1)];
|
|
215
|
+
const tags = (Array.isArray(g?.stocks) ? g.stocks : [])
|
|
216
|
+
.filter((x) => Array.isArray(x) && m.known.has(x[0]) && Number.isFinite(Number(x[1])))
|
|
217
|
+
.map(([s, t]) => [s, Math.max(-1, Math.min(1, Number(t)))]);
|
|
218
|
+
const imp = Number.isFinite(Number(g?.imp)) ? Math.max(0, Math.min(1, Number(g.imp))) : null;
|
|
219
|
+
const gist = typeof g?.gist === 'string' && g.gist.trim() ? g.gist.trim().slice(0, 160) : null;
|
|
220
|
+
markRow(batch[k].id, tags, imp, gist);
|
|
221
|
+
marked++;
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
if (marked) hub.emit({ type: 'news:update', marked });
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
// ---------- расписание ----------
|
|
228
|
+
// Во время торгов (будни, 7–24 МСК) опрос раз в 10 минут, вне их — раз в 30
|
|
229
|
+
export function isTradingTime(now = Date.now()) {
|
|
230
|
+
const d = new Date(now + MSK);
|
|
231
|
+
return d.getUTCDay() >= 1 && d.getUTCDay() <= 5 && d.getUTCHours() >= 7;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
let timer = null;
|
|
235
|
+
let busy = false;
|
|
236
|
+
|
|
237
|
+
function schedule(ms) {
|
|
238
|
+
clearTimeout(timer);
|
|
239
|
+
timer = setTimeout(async () => {
|
|
240
|
+
if (!busy) {
|
|
241
|
+
busy = true;
|
|
242
|
+
try { await collectOnce(); } catch (e) { console.error('Новости:', e.message); } finally { busy = false; }
|
|
243
|
+
}
|
|
244
|
+
schedule(isTradingTime() ? 10 * 60000 : 30 * 60000);
|
|
245
|
+
}, ms);
|
|
246
|
+
timer.unref?.();
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
export function startNews() {
|
|
250
|
+
if (timer) return;
|
|
251
|
+
schedule(90000); // первый цикл вскоре после запуска сервера
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
// ---------- чтение ----------
|
|
255
|
+
const parseTags = (r) => { try { return JSON.parse(r.tags || '[]'); } catch { return []; } };
|
|
256
|
+
|
|
257
|
+
// Каких акций коснулись новости за последние часы: symbol → { count, tone (средний взвешенный по важности), top, src, ts }
|
|
258
|
+
export function newsForSymbols(hours = 24) {
|
|
259
|
+
const rows = db.prepare(`SELECT ts, src, title, gist, imp, tags FROM news
|
|
260
|
+
WHERE marked = 1 AND tags IS NOT NULL AND tags != '[]' AND ts >= ?`).all(Date.now() - hours * 3600000);
|
|
261
|
+
const acc = new Map();
|
|
262
|
+
for (const r of rows) {
|
|
263
|
+
for (const [sym, tone] of parseTags(r)) {
|
|
264
|
+
const w = Number.isFinite(r.imp) ? Math.max(0.05, r.imp) : 1; // без ИИ все новости равны
|
|
265
|
+
const e = acc.get(sym) || { count: 0, sw: 0, w: 0, best: null, bestImp: -1 };
|
|
266
|
+
e.count++;
|
|
267
|
+
if (Number.isFinite(tone)) { e.sw += tone * w; e.w += w; }
|
|
268
|
+
const score = Number.isFinite(r.imp) ? r.imp : 0.1;
|
|
269
|
+
if (score > e.bestImp) { e.best = r; e.bestImp = score; }
|
|
270
|
+
acc.set(sym, e);
|
|
271
|
+
}
|
|
272
|
+
}
|
|
273
|
+
const out = new Map();
|
|
274
|
+
for (const [sym, e] of acc) {
|
|
275
|
+
out.set(sym, { count: e.count, tone: e.w ? round(e.sw / e.w, 2) : null, top: e.best.gist || e.best.title, src: e.best.src, ts: e.best.ts });
|
|
276
|
+
}
|
|
277
|
+
return out;
|
|
278
|
+
}
|
|
279
|
+
|
|
280
|
+
// Для живой проверки с newsFilter: самые важные свежие новости (важность ≥ 0.6, |тон| ≥ 0.4)
|
|
281
|
+
// по тикерам: symbol → { bad: { gist, imp, tone, ts }, good: {…} }
|
|
282
|
+
export function blockingNews(hours = 6) {
|
|
283
|
+
const rows = db.prepare(`SELECT ts, title, gist, imp, tags FROM news
|
|
284
|
+
WHERE marked = 1 AND imp >= 0.6 AND tags IS NOT NULL AND tags != '[]' AND ts >= ?`).all(Date.now() - hours * 3600000);
|
|
285
|
+
const m = new Map();
|
|
286
|
+
for (const r of rows) {
|
|
287
|
+
for (const [sym, tone] of parseTags(r)) {
|
|
288
|
+
if (!Number.isFinite(tone) || Math.abs(tone) < 0.4) continue;
|
|
289
|
+
const e = m.get(sym) || {};
|
|
290
|
+
const side = tone < 0 ? 'bad' : 'good';
|
|
291
|
+
if (!e[side] || r.imp > e[side].imp) e[side] = { tone, imp: r.imp, gist: r.gist || r.title, ts: r.ts };
|
|
292
|
+
m.set(sym, e);
|
|
293
|
+
}
|
|
294
|
+
}
|
|
295
|
+
return m;
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
// Последние размеченные новости — для интерфейса, API и Стратега
|
|
299
|
+
export function listNews({ symbol, hours = 72, limit = 30 } = {}) {
|
|
300
|
+
const sym = symbol ? String(symbol).toUpperCase() : '';
|
|
301
|
+
const rows = db.prepare(`SELECT ts, src, title, link, gist, imp, tone, tags FROM news
|
|
302
|
+
WHERE marked = 1 AND tags IS NOT NULL AND (tags != '[]' OR COALESCE(imp, 0) >= 0.7) AND ts >= ?${sym ? ' AND tags LIKE ?' : ''}
|
|
303
|
+
ORDER BY ts DESC LIMIT ?`)
|
|
304
|
+
.all(Date.now() - Math.min(336, hours) * 3600000, ...(sym ? [`%"${sym}"%`] : []), Math.min(100, limit));
|
|
305
|
+
return rows.map((r) => ({
|
|
306
|
+
ts: r.ts, src: r.src, title: r.title, link: r.link, gist: r.gist, imp: r.imp, tone: r.tone,
|
|
307
|
+
symbols: parseTags(r).map(([s, t]) => ({ symbol: s, tone: t })),
|
|
308
|
+
}));
|
|
309
|
+
}
|