@tradejs/app 1.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @tradejs/app
+
+Publishable Next.js UI package for viewing TradeJS backtests, charts, and signal flows.
+
+Typical external usage:
+
+```bash
+npm i @tradejs/app
+npx tradejs-app dev
+```
+
+The launcher reads env and `tradejs.config.ts` from the caller project directory via `PROJECT_CWD`.

package/bin/tradejs-app.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import nextEnv from '@next/env';
+
+const require = createRequire(import.meta.url);
+const { loadEnvConfig } = nextEnv;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const appDir = path.resolve(__dirname, '..');
+
+const command = process.argv[2] || 'dev';
+const rawArgs = process.argv.slice(3);
+const projectCwd = path.resolve(
+  String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
+);
+
+process.env.PROJECT_CWD = projectCwd;
+
+const dev = command === 'dev';
+loadEnvConfig(projectCwd, dev, console);
+
+const nextBin = require.resolve('next/dist/bin/next');
+const args = [nextBin, command, ...rawArgs];
+
+if (
+  command === 'start' &&
+  !rawArgs.includes('-H') &&
+  !rawArgs.includes('--hostname')
+) {
+  args.push('-H', '0.0.0.0');
+}
+
+const child = spawn(process.execPath, args, {
+  cwd: appDir,
+  env: process.env,
+  stdio: 'inherit',
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 0);
+});
+
+child.on('error', (error) => {
+  console.error('[tradejs-app] failed to start Next.js:', error);
+  process.exit(1);
+});

package/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/next.config.mjs

@@ -0,0 +1,31 @@
+/** @type {import('next').NextConfig} */
+
+const nextConfig = {
+  // webpack(config) {
+  //   config.module.parser = {
+  //     ...config.module.parser,
+  //     javascript: { ...config.module.parser?.javascript, dataUrlCondition: { maxSize: 1024 } }, // 1KB
+  //   };
+  //   return config;
+  // },
+  experimental: {
+    externalDir: true,
+    optimizePackageImports: ['@chakra-ui/react'],
+  },
+  async redirects() {
+    return [
+      {
+        source: '/routes/dashboard/:symbol/:interval',
+        destination: '/routes/dashboard/bybit/:symbol/:interval',
+        permanent: false,
+      },
+      {
+        source: '/api/kline/:symbol/:interval',
+        destination: '/api/kline/bybit/:symbol/:interval',
+        permanent: false,
+      },
+    ];
+  },
+};
+
+export default nextConfig;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@tradejs/app",
+  "version": "1.0.0",
+  "files": [
+    "README.md",
+    "bin",
+    "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "next.config.mjs",
+    "tsconfig.json",
+    "next-env.d.ts"
+  ],
+  "bin": {
+    "tradejs-app": "./bin/tradejs-app.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@chakra-ui/charts": "^3.24.0",
+    "@chakra-ui/react": "^3.24.2",
+    "@emotion/react": "^11.14.0",
+    "@langchain/core": "^0.3.68",
+    "@langchain/openai": "^0.6.11",
+    "@tradejs/connectors": "^1.0.0",
+    "@tradejs/core": "^1.0.0",
+    "@tradejs/indicators": "^1.0.0",
+    "@tradejs/infra": "^1.0.0",
+    "@tradejs/node": "^1.0.0",
+    "@tradejs/types": "^1.0.0",
+    "bcryptjs": "^2.4.3",
+    "date-fns": "^3.3.1",
+    "idb-keyval": "^6.2.2",
+    "klinecharts": "10.0.0-alpha9",
+    "lodash": "^4.17.21",
+    "next": "^16.1.1",
+    "next-auth": "^5.0.0-beta.26",
+    "next-themes": "^0.4.6",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "react-icons": "^5.5.0",
+    "react-is": "^19.2.0",
+    "react-virtualized-auto-sizer": "^1.0.26",
+    "react-window": "^1.8.11",
+    "recharts": "^3.1.1",
+    "shiki": "^3.9.2",
+    "technicalindicators": "^3.1.0",
+    "zustand": "^5.0.7"
+  },
+  "scripts": {
+    "dev": "node ./bin/tradejs-app.mjs dev",
+    "build": "NODE_ENV=production node ./bin/tradejs-app.mjs build",
+    "start": "node ./bin/tradejs-app.mjs start",
+    "lint": "yarn run -T eslint src --ext .js,.jsx,.ts,.tsx"
+  },
+  "license": "MIT",
+  "author": "aleksnick (https://github.com/aleksnick)"
+}

package/src/app/actions/ai.ts

@@ -0,0 +1,33 @@
+import { API } from '@tradejs/core/api';
+import { AIChatMessage, AIChatHistory, Filters } from '@tradejs/types';
+
+interface SendMessageProps {
+  message: AIChatMessage;
+  filters: Filters;
+}
+
+const API_PATH = '/api/ai';
+
+export const getHistory = async (symbol: string): Promise<AIChatHistory> => {
+  if (!symbol) {
+    return [];
+  }
+
+  const data = await API.get<{ history?: AIChatHistory }>(
+    `${API_PATH}?symbol=${encodeURIComponent(symbol)}`,
+  );
+
+  return data.history ?? [];
+};
+
+export const sendMessage = async ({
+  message,
+  filters,
+}: SendMessageProps): Promise<AIChatMessage> => {
+  const data = await API.post<{ message: AIChatMessage }>(API_PATH, {
+    message,
+    filters,
+  });
+
+  return data.message;
+};

package/src/app/actions/backtest.ts

@@ -0,0 +1,55 @@
+import { API } from '@tradejs/core/api';
+import { Item, OrderLogData, TestResult } from '@tradejs/types';
+
+const API_BASE = '/api/backtest';
+
+export const getBacktestFiles = async (): Promise<Item[]> => {
+  const data = await API.get<{ items?: Item[] }>(`${API_BASE}/files`);
+
+  return data.items ?? [];
+};
+
+export const getOrderLog = async (
+  name: string | undefined,
+  strategyName: string | undefined,
+): Promise<OrderLogData | null> => {
+  if (!name || !strategyName) {
+    return null;
+  }
+
+  const data = await API.get<{ orderLog?: OrderLogData }>(
+    `${API_BASE}/order-log/${strategyName}/${name}`,
+  );
+
+  return data.orderLog ?? null;
+};
+
+export const getBacktest = async (
+  name: string | undefined,
+  strategyName: string | undefined,
+): Promise<TestResult | null> => {
+  if (!name || !strategyName) {
+    return null;
+  }
+
+  const data = await API.get<{ result?: TestResult }>(
+    `${API_BASE}/result/${strategyName}/${name}`,
+  );
+
+  return data.result ?? null;
+};
+
+export const deleteBacktest = async (
+  name: string | undefined,
+  strategyName: string | undefined,
+): Promise<boolean> => {
+  if (!name || !strategyName) {
+    return false;
+  }
+
+  const data = await API.delete<{ deleted?: boolean }>(
+    `${API_BASE}/test/${encodeURIComponent(strategyName)}/${encodeURIComponent(name)}`,
+  );
+
+  return data.deleted === true;
+};

package/src/app/actions/kline.ts

@@ -0,0 +1,18 @@
+import { API } from '@tradejs/core/api';
+import { KlineChartData, KlineRequest, Provider } from '@tradejs/types';
+
+const API_PATH = '/api/kline';
+
+export const kline = async ({
+  provider = 'bybit',
+  symbol,
+  interval,
+  ...options
+}: KlineRequest & { provider?: Provider }) => {
+  const data = await API.post<{ data?: KlineChartData }>(
+    `${API_PATH}/${provider}/${symbol}/${interval}`,
+    options,
+  );
+
+  return data.data ?? [];
+};

package/src/app/actions/scanner.ts

@@ -0,0 +1,10 @@
+import { API } from '@tradejs/core/api';
+import { Items } from '@tradejs/types';
+
+const API_PATH = '/api/scanner';
+
+export const scan = async (provider = 'bybit'): Promise<Items> => {
+  const data = await API.get<{ tickers?: Items }>(`${API_PATH}/${provider}`);
+
+  return data.tickers ?? [];
+};

package/src/app/actions/signal.ts

@@ -0,0 +1,19 @@
+import { API } from '@tradejs/core/api';
+import { Signal } from '@tradejs/types';
+
+const API_PATH = '/api/signal';
+
+export const getSignal = async (
+  symbol: string,
+  signalId: string | undefined,
+): Promise<Signal | null> => {
+  if (!signalId) {
+    return null;
+  }
+
+  const data = await API.get<{ signal?: Signal }>(
+    `${API_PATH}/${symbol}/${signalId}`,
+  );
+
+  return data.signal ?? null;
+};

package/src/app/api/ai/route.ts

@@ -0,0 +1,151 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ChatOpenAI } from '@langchain/openai';
+import {
+  BaseMessage,
+  HumanMessage,
+  SystemMessage,
+} from '@langchain/core/messages';
+import { toJson } from '@tradejs/core/json';
+import { getConnectorCreatorByProvider } from '@tradejs/node/connectors';
+import {
+  AIChatHistory,
+  AIChatMessage,
+  ConnectorCreator,
+  Filters,
+} from '@tradejs/types';
+import { getFile, setFile } from '@tradejs/infra/files';
+import { logger } from '@tradejs/infra/logger';
+
+export const dynamic = 'force-dynamic';
+
+const HISTORY_DIR = 'data/chats';
+
+const getHistory = async (symbol: string): Promise<AIChatHistory> => {
+  const history = await getFile(HISTORY_DIR, symbol);
+  return history;
+};
+
+const appendMessagesToHistory = async (
+  symbol: string,
+  messages: AIChatHistory,
+): Promise<void> => {
+  const history = await getHistory(symbol);
+  await setFile(HISTORY_DIR, symbol, [...history, ...messages]);
+};
+
+const buildMessages = (
+  filters: Filters,
+  historyEntry: AIChatMessage,
+  historyData: unknown,
+) => {
+  const messages = new Array<BaseMessage>();
+
+  messages.push(
+    new SystemMessage(
+      'Ты – помощник крипто-трейдера. Отвечай на русском языке',
+    ),
+  );
+
+  messages.push(
+    new SystemMessage(
+      `Вот данные по монете ${filters.symbol}: ${toJson(historyData)}`,
+    ),
+  );
+
+  if (historyEntry.command === '/line') {
+    messages.push(new HumanMessage(historyEntry.text));
+  }
+
+  if (historyEntry.command === 'prompt') {
+    messages.push(new HumanMessage(historyEntry.text));
+  }
+
+  return messages;
+};
+
+const invokeChatModel = async (messages: BaseMessage[]) => {
+  const model = new ChatOpenAI({
+    temperature: 0.7,
+    modelName: 'gpt-4o',
+    openAIApiKey: process.env.OPENAI_API_KEY,
+    configuration: {
+      baseURL: process.env.OPENAI_API_ENDPOINT || 'https://api.openai.com/v1',
+    },
+  });
+
+  return model.invoke(messages);
+};
+
+export const GET = async (request: NextRequest) => {
+  try {
+    const symbol = request.nextUrl.searchParams.get('symbol');
+
+    if (!symbol) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: symbol' },
+        { status: 400 },
+      );
+    }
+
+    const history = await getHistory(symbol);
+    return NextResponse.json({ history });
+  } catch (error) {
+    logger.log('error', `AI history error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};
+
+export const POST = async (request: NextRequest) => {
+  try {
+    const body = await request.json();
+    const { message, filters } = body as {
+      message?: AIChatMessage;
+      filters?: Filters;
+    };
+
+    if (!message || !filters) {
+      return NextResponse.json(
+        { error: 'Missing required fields: message, filters' },
+        { status: 400 },
+      );
+    }
+
+    await appendMessagesToHistory(filters.symbol, [message]);
+
+    const connectorCreator = await getConnectorCreatorByProvider('bybit');
+    if (!connectorCreator) {
+      throw new Error('No connector available for provider');
+    }
+
+    const byBitConnector = await (connectorCreator as ConnectorCreator)({
+      userName: 'root',
+    });
+
+    const data = await byBitConnector.kline({
+      ...filters,
+      interval: '60',
+    });
+
+    const chatMessages = buildMessages(filters, message, data.slice(-100));
+
+    const response = await invokeChatModel(chatMessages);
+
+    const responseMessage: AIChatMessage = {
+      from: 'ai',
+      text: response.content as string,
+    };
+
+    await appendMessagesToHistory(filters.symbol, [responseMessage]);
+
+    return NextResponse.json({ message: responseMessage });
+  } catch (error) {
+    logger.log('error', `AI message error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,5 @@
+import { handlers } from '@app/auth';
+
+export const runtime = 'nodejs';
+
+export const { GET, POST } = handlers;

package/src/app/api/backtest/files/route.ts

@@ -0,0 +1,60 @@
+import { NextResponse } from 'next/server';
+import { Item, TestStat } from '@tradejs/types';
+import { parseTestName } from '@tradejs/core/backtest';
+import { getData, getKeys, redisKeys } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+import { auth } from '@app/auth';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async () => {
+  try {
+    const session = await auth();
+    const userName = session?.user?.id || session?.user?.name;
+
+    if (!userName) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const result = new Array<Item>();
+    const testsPrefix = redisKeys.tests(userName);
+    const keys = await getKeys(testsPrefix);
+    const configKeys = keys.filter((key) => key.endsWith(':config'));
+
+    for await (const key of configKeys) {
+      const parts = key.split(':');
+      if (parts.length < 5) {
+        continue;
+      }
+      const strategyName = parts[3];
+      const testName = parts[4];
+      const { symbol, testId } = parseTestName(testName);
+
+      const stat: TestStat = await getData(
+        redisKeys.testStat(userName, strategyName, testName),
+      );
+
+      if (!stat) {
+        continue;
+      }
+
+      result.push({
+        value: testName,
+        label: `${symbol}_${testId}`,
+        description: `${stat.netProfit}$`,
+        data: {
+          netProfit: stat.netProfit || 0,
+          strategyName,
+        },
+      });
+    }
+
+    return NextResponse.json({ items: result });
+  } catch (error) {
+    logger.log('error', `Backtest list error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/backtest/order-log/[strategy]/[name]/route.ts

@@ -0,0 +1,47 @@
+'use server';
+
+import { NextResponse } from 'next/server';
+import { OrderLogData } from '@tradejs/types';
+import { getData, redisKeys } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+import { auth } from '@app/auth';
+
+interface Params {
+  strategy: string;
+  name: string;
+}
+
+export const GET = async (
+  _req: Request,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { name, strategy } = await params;
+
+    if (!name || !strategy) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: name/strategy' },
+        { status: 400 },
+      );
+    }
+
+    const session = await auth();
+    const userName = session?.user?.id || session?.user?.name;
+
+    if (!userName) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const orderLog: OrderLogData = await getData(
+      redisKeys.testOrders(userName, strategy, name),
+    );
+
+    return NextResponse.json({ orderLog });
+  } catch (error) {
+    logger.log('error', `Backtest order log error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/backtest/result/[strategy]/[name]/route.ts

@@ -0,0 +1,63 @@
+'use server';
+
+import { NextResponse } from 'next/server';
+import { OrderLogData, Test, TestResult, TestStat } from '@tradejs/types';
+import { compactOrderLog, getTimeline } from '@tradejs/core/backtest';
+import { getData, redisKeys } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+import { auth } from '@app/auth';
+
+interface Params {
+  strategy: string;
+  name: string;
+}
+
+export const GET = async (
+  _req: Request,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { name, strategy } = await params;
+
+    if (!name || !strategy) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: name/strategy' },
+        { status: 400 },
+      );
+    }
+
+    const session = await auth();
+    const userName = session?.user?.id || session?.user?.name;
+
+    if (!userName) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const orderLog: OrderLogData = await getData(
+      redisKeys.testOrders(userName, strategy, name),
+    );
+    const test: Test = await getData(
+      redisKeys.testConfig(userName, strategy, name),
+    );
+    const stat: TestStat = await getData(
+      redisKeys.testStat(userName, strategy, name),
+    );
+
+    // TODO: Validate test/test.options payload and return 404/422 instead of falling into 500 on malformed cache data.
+    const timeline = getTimeline(test.options.start, test.options.end);
+
+    const payload: TestResult = {
+      test,
+      orderLog: compactOrderLog(timeline, orderLog),
+      stat,
+    };
+
+    return NextResponse.json({ result: payload });
+  } catch (error) {
+    logger.log('error', `Backtest load error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/backtest/test/[strategy]/[name]/route.ts

@@ -0,0 +1,57 @@
+'use server';
+
+import { NextResponse } from 'next/server';
+import { delKey, redisKeys } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+import { auth } from '@app/auth';
+
+interface Params {
+  strategy: string;
+  name: string;
+}
+
+export const DELETE = async (
+  _req: Request,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { name, strategy } = await params;
+
+    if (!name || !strategy) {
+      return NextResponse.json(
+        { error: 'Missing required parameter: name/strategy' },
+        { status: 400 },
+      );
+    }
+
+    const session = await auth();
+    const userName = session?.user?.id || session?.user?.name;
+
+    if (!userName) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const removeResults = await Promise.all([
+      delKey(redisKeys.testConfig(userName, strategy, name)),
+      delKey(redisKeys.testStat(userName, strategy, name)),
+      delKey(redisKeys.testOrders(userName, strategy, name)),
+    ]);
+
+    const removedKeys = removeResults.filter(Boolean).length;
+
+    if (removedKeys === 0) {
+      return NextResponse.json(
+        { error: 'Backtest not found' },
+        { status: 404 },
+      );
+    }
+
+    return NextResponse.json({ deleted: true, removedKeys });
+  } catch (error) {
+    logger.log('error', 'Backtest delete error: %o', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};