@tradejs/app 2.0.18 → 2.0.20

package/src/app/lib/strategyEvidenceTimeline.ts

@@ -0,0 +1,298 @@
+import type { Dirent } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  canonicalStrategyEvidenceJson,
+  safeStrategyEvidenceSegment,
+  verifyStrategyEvidenceMarkerEnvelope,
+} from '@tradejs/infra/strategyReleaseEvidence';
+import {
+  type StrategyEvidenceMarker,
+  type StrategyEvidenceMarkerEnvelope,
+  type StrategyEvidenceTimeline,
+  type StrategyEvidenceTimelineSelector,
+} from '@tradejs/types';
+
+const DEFAULT_MARKER_DIRECTORY = 'data/strategy-release/markers';
+type JsonRecord = Record<string, unknown>;
+
+const asRecord = (value: unknown): JsonRecord | null =>
+  value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : null;
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.trim().length > 0;
+
+export { canonicalStrategyEvidenceJson, verifyStrategyEvidenceMarkerEnvelope };
+
+export const strategyEvidenceTimelineSelectorKey = (
+  selector: StrategyEvidenceTimelineSelector,
+) =>
+  [
+    selector.strategy,
+    selector.compositionId ?? '',
+    selector.gitSha ?? '',
+    selector.gateFingerprint ?? '',
+    selector.configFingerprint ?? '',
+    selector.contextFingerprint ?? '',
+    selector.requireCompleteLineage ? 'exact' : 'partial',
+  ].join(':');
+
+const discoverJsonFiles = async (rootDir: string): Promise<string[]> => {
+  const files: string[] = [];
+
+  const visit = async (directory: string, depth: number): Promise<void> => {
+    if (depth > 12) return;
+
+    let entries: Dirent[];
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+      throw error;
+    }
+
+    await Promise.all(
+      entries.map(async (entry) => {
+        if (entry.name.startsWith('.') || entry.name.includes('.tmp-')) return;
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+          await visit(entryPath, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith('.json')) {
+          files.push(entryPath);
+        }
+      }),
+    );
+  };
+
+  await visit(rootDir, 0);
+  return files.sort();
+};
+
+const inferMatchingStrategies = ({
+  filePath,
+  rootDir,
+  parsed,
+  strategies,
+}: {
+  filePath: string;
+  rootDir: string;
+  parsed: unknown;
+  strategies: string[];
+}) => {
+  const payload = asRecord(asRecord(parsed)?.payload);
+  const declaredStrategy = isNonEmptyString(payload?.strategy)
+    ? payload.strategy
+    : null;
+  const directoryStrategy = path.relative(rootDir, filePath).split(path.sep)[0];
+  return strategies.filter(
+    (strategy) =>
+      strategy === declaredStrategy ||
+      directoryStrategy === safeStrategyEvidenceSegment(strategy),
+  );
+};
+
+const missingTimeline = (): StrategyEvidenceTimeline => ({
+  status: 'missing',
+  observedFrom: null,
+  markers: [],
+});
+
+const invalidTimeline = (): StrategyEvidenceTimeline => ({
+  status: 'invalid',
+  observedFrom: null,
+  markers: [],
+});
+
+export const loadStrategyEvidenceTimelines = async ({
+  projectRoot,
+  markerDir,
+  selectors: requestedSelectors,
+  startTime,
+  endTime,
+}: {
+  projectRoot: string;
+  markerDir?: string | null;
+  selectors: Iterable<StrategyEvidenceTimelineSelector>;
+  startTime: number;
+  endTime: number;
+}): Promise<Map<string, StrategyEvidenceTimeline>> => {
+  const selectors = [...requestedSelectors]
+    .filter((selector) => selector.strategy.trim().length > 0)
+    .sort((left, right) =>
+      strategyEvidenceTimelineSelectorKey(left).localeCompare(
+        strategyEvidenceTimelineSelectorKey(right),
+      ),
+    );
+  const strategies = [...new Set(selectors.map(({ strategy }) => strategy))];
+  const timelines = new Map(
+    selectors.map((selector) => [
+      strategyEvidenceTimelineSelectorKey(selector),
+      missingTimeline(),
+    ]),
+  );
+  if (!selectors.length) return timelines;
+
+  const configuredDir = markerDir?.trim() || DEFAULT_MARKER_DIRECTORY;
+  const rootDir = path.isAbsolute(configuredDir)
+    ? configuredDir
+    : path.resolve(projectRoot, configuredDir);
+  let files: string[];
+  try {
+    files = await discoverJsonFiles(rootDir);
+  } catch {
+    for (const selector of selectors) {
+      timelines.set(
+        strategyEvidenceTimelineSelectorKey(selector),
+        invalidTimeline(),
+      );
+    }
+    return timelines;
+  }
+
+  const envelopesByStrategy = new Map<
+    string,
+    StrategyEvidenceMarkerEnvelope[]
+  >();
+  const invalidStrategies = new Set<string>();
+
+  for (const filePath of files) {
+    let parsed: unknown = null;
+    try {
+      parsed = JSON.parse(await fs.readFile(filePath, 'utf8')) as unknown;
+    } catch {
+      for (const strategy of inferMatchingStrategies({
+        filePath,
+        rootDir,
+        parsed,
+        strategies,
+      })) {
+        invalidStrategies.add(strategy);
+      }
+      continue;
+    }
+
+    const matchingStrategies = inferMatchingStrategies({
+      filePath,
+      rootDir,
+      parsed,
+      strategies,
+    });
+    if (!matchingStrategies.length) continue;
+
+    try {
+      const envelope = verifyStrategyEvidenceMarkerEnvelope(parsed);
+      for (const strategy of matchingStrategies) {
+        if (strategy !== envelope.payload.strategy) {
+          invalidStrategies.add(strategy);
+        }
+      }
+      if (!strategies.includes(envelope.payload.strategy)) {
+        continue;
+      }
+      const envelopes =
+        envelopesByStrategy.get(envelope.payload.strategy) ?? [];
+      envelopes.push(envelope);
+      envelopesByStrategy.set(envelope.payload.strategy, envelopes);
+    } catch {
+      for (const strategy of matchingStrategies) {
+        invalidStrategies.add(strategy);
+      }
+    }
+  }
+
+  for (const selector of selectors) {
+    const strategy = selector.strategy;
+    const selectorKey = strategyEvidenceTimelineSelectorKey(selector);
+    if (invalidStrategies.has(strategy)) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+
+    const envelopes = envelopesByStrategy.get(strategy) ?? [];
+    if (!envelopes.length) continue;
+    const hasCompleteSelector =
+      Boolean(selector.compositionId) &&
+      Boolean(selector.gitSha) &&
+      Boolean(selector.gateFingerprint) &&
+      Boolean(selector.configFingerprint) &&
+      Boolean(selector.contextFingerprint);
+    if (selector.requireCompleteLineage && !hasCompleteSelector) continue;
+
+    const markersById = new Map<string, StrategyEvidenceMarker>();
+    let hasConflict = false;
+    for (const envelope of envelopes) {
+      for (const marker of envelope.payload.markers) {
+        const existing = markersById.get(marker.id);
+        if (
+          existing &&
+          canonicalStrategyEvidenceJson(existing) !==
+            canonicalStrategyEvidenceJson(marker)
+        ) {
+          hasConflict = true;
+          break;
+        }
+        markersById.set(marker.id, marker);
+      }
+      if (hasConflict) break;
+    }
+
+    if (hasConflict) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+
+    const matchingMarkers = [...markersById.values()]
+      .filter(
+        (marker) =>
+          (!selector.compositionId ||
+            marker.compositionId === selector.compositionId) &&
+          (!selector.gitSha || marker.gitSha === selector.gitSha) &&
+          (!selector.gateFingerprint ||
+            marker.gateFingerprint === selector.gateFingerprint) &&
+          (!selector.configFingerprint ||
+            marker.configFingerprint === selector.configFingerprint) &&
+          (!selector.contextFingerprint ||
+            marker.contextFingerprint === selector.contextFingerprint) &&
+          marker.timestamp >= startTime &&
+          marker.timestamp < endTime,
+      )
+      .sort(
+        (left, right) =>
+          left.timestamp - right.timestamp ||
+          left.type.localeCompare(right.type) ||
+          left.id.localeCompare(right.id),
+      );
+    let lastLossValue: number | null | undefined;
+    let hasLastLossValue = false;
+    const markers = matchingMarkers.filter((marker) => {
+      if (marker.type !== 'L') return true;
+      if (hasLastLossValue && marker.maxLossValue === lastLossValue) {
+        return false;
+      }
+      hasLastLossValue = true;
+      lastLossValue = marker.maxLossValue;
+      return true;
+    });
+    if (
+      !markers.length &&
+      (selector.compositionId ||
+        selector.gitSha ||
+        selector.gateFingerprint ||
+        selector.configFingerprint ||
+        selector.contextFingerprint)
+    ) {
+      continue;
+    }
+    timelines.set(selectorKey, {
+      status: 'verified',
+      observedFrom: markers.length
+        ? Math.min(...markers.map((marker) => marker.timestamp))
+        : Math.min(...envelopes.map((envelope) => envelope.payload.createdAt)),
+      markers,
+    });
+  }
+
+  return timelines;
+};

package/src/app/lib/strategyPerformance.ts

@@ -0,0 +1,387 @@
+export type EquityLog = ReadonlyArray<readonly [number, number]>;
+
+export type TradingSession = 'Asia' | 'Europe' | 'US';
+
+export interface StrategyTradePoint {
+  index: number;
+  timestamp: number;
+  pnl: number;
+  equity: number;
+  hour: number;
+  session: TradingSession;
+}
+
+export interface DrawdownPoint {
+  timestamp: number;
+  drawdownPercent: number;
+}
+
+export interface RollingPerformancePoint {
+  index: number;
+  winRate: number;
+  pnl: number;
+}
+
+export interface DistributionBin {
+  id: string;
+  min: number;
+  max: number;
+  count: number;
+}
+
+export interface SessionPnlStat {
+  session: TradingSession;
+  pnl: number;
+  orders: number;
+}
+
+export interface HourlyPnlStat {
+  hour: number;
+  pnl: number;
+  orders: number;
+}
+
+export interface MonthlyStat {
+  id: string;
+  year: number;
+  monthIndex: number;
+  monthLabel: string;
+  orders: number;
+  wins: number;
+  pnl: number;
+}
+
+export interface YearlyMonthlyStats {
+  year: number;
+  months: MonthlyStat[];
+}
+
+export interface QuarterlyMonthlyStats {
+  label: string;
+  monthIndexes: readonly number[];
+  months: (MonthlyStat | null)[];
+  hasData: boolean;
+}
+
+export interface StrategyPerformanceViewModel {
+  monthlyStats: YearlyMonthlyStats[];
+  tradePoints: StrategyTradePoint[];
+  drawdownPoints: DrawdownPoint[];
+  rollingPerformancePoints: RollingPerformancePoint[];
+  pnlDistributionBins: DistributionBin[];
+  sessionPnlStats: SessionPnlStat[];
+  hourlyPnlStats: HourlyPnlStat[];
+}
+
+const resolveTradingSession = (hour: number): TradingSession => {
+  if (hour < 8) return 'Asia';
+  if (hour < 16) return 'Europe';
+  return 'US';
+};
+
+export const getEquityStepPnl = (orderLog: EquityLog, index: number) => {
+  const current = orderLog[index];
+  const previous = orderLog[index - 1];
+  if (!current || !previous) return null;
+
+  const pnl = current[1] - previous[1];
+  return Number.isFinite(pnl) ? pnl : null;
+};
+
+const calculateMaxPnlStreak = (
+  orderLog: EquityLog,
+  isStreakPnl: (pnl: number) => boolean,
+) => {
+  let currentStreak = 0;
+  let maxStreak = 0;
+
+  for (let index = 1; index < orderLog.length; index += 1) {
+    const pnl = getEquityStepPnl(orderLog, index);
+    if (pnl == null) continue;
+
+    if (isStreakPnl(pnl)) {
+      currentStreak += 1;
+      maxStreak = Math.max(maxStreak, currentStreak);
+    } else {
+      currentStreak = 0;
+    }
+  }
+
+  return maxStreak;
+};
+
+export const calculateMaxGrossStreak = (orderLog: EquityLog) =>
+  calculateMaxPnlStreak(orderLog, (pnl) => pnl > 0);
+
+export const calculateMaxLossStreak = (orderLog: EquityLog) =>
+  calculateMaxPnlStreak(orderLog, (pnl) => pnl < 0);
+
+export const calculateMaxDrawdownValue = (orderLog: EquityLog) => {
+  if (!orderLog.length) return null;
+
+  let peak = orderLog[0]?.[1] ?? 0;
+  let maxDrawdownPercent = 0;
+
+  for (const [, amount] of orderLog) {
+    if (!Number.isFinite(amount)) continue;
+
+    peak = Math.max(peak, amount);
+    if (peak <= 0) continue;
+
+    maxDrawdownPercent = Math.max(
+      maxDrawdownPercent,
+      ((peak - amount) / peak) * 100,
+    );
+  }
+
+  return maxDrawdownPercent;
+};
+
+export const formatMaxDrawdownPercent = (orderLog: EquityLog) => {
+  const value = calculateMaxDrawdownValue(orderLog);
+  return value == null ? null : `${value.toFixed(1)}%`;
+};
+
+export const buildStrategyTradePoints = (
+  orderLog: EquityLog,
+): StrategyTradePoint[] => {
+  const points: StrategyTradePoint[] = [];
+
+  for (let index = 1; index < orderLog.length; index += 1) {
+    const current = orderLog[index];
+    const previous = orderLog[index - 1];
+    if (!current || !previous) continue;
+
+    const [timestamp, equity] = current;
+    const pnl = equity - previous[1];
+    if (
+      !Number.isFinite(timestamp) ||
+      !Number.isFinite(equity) ||
+      !Number.isFinite(pnl)
+    ) {
+      continue;
+    }
+
+    const hour = new Date(timestamp).getUTCHours();
+    points.push({
+      index,
+      timestamp,
+      pnl,
+      equity,
+      hour,
+      session: resolveTradingSession(hour),
+    });
+  }
+
+  return points;
+};
+
+export const buildDrawdownPoints = (orderLog: EquityLog): DrawdownPoint[] => {
+  let peak = orderLog[0]?.[1] ?? 0;
+
+  return orderLog
+    .map(([timestamp, equity]) => {
+      if (!Number.isFinite(timestamp) || !Number.isFinite(equity)) return null;
+
+      peak = Math.max(peak, equity);
+      return {
+        timestamp,
+        drawdownPercent: peak > 0 ? ((peak - equity) / peak) * 100 : 0,
+      };
+    })
+    .filter((point): point is DrawdownPoint => point != null);
+};
+
+export const buildRollingPerformance = (
+  trades: StrategyTradePoint[],
+  windowSize = 50,
+): RollingPerformancePoint[] =>
+  trades.map((trade, index) => {
+    const windowTrades = trades.slice(
+      Math.max(0, index - windowSize + 1),
+      index + 1,
+    );
+    const wins = windowTrades.filter((item) => item.pnl > 0).length;
+
+    return {
+      index: trade.index,
+      winRate: windowTrades.length > 0 ? (wins / windowTrades.length) * 100 : 0,
+      pnl: windowTrades.reduce((sum, item) => sum + item.pnl, 0),
+    };
+  });
+
+export const buildPnlDistribution = (
+  trades: StrategyTradePoint[],
+  binCount = 12,
+): DistributionBin[] => {
+  if (!trades.length) return [];
+
+  const pnlValues = trades.map((trade) => trade.pnl);
+  const min = Math.min(...pnlValues);
+  const max = Math.max(...pnlValues);
+  if (!Number.isFinite(min) || !Number.isFinite(max)) return [];
+
+  if (min === max) {
+    return [{ id: `${min}:${max}`, min, max, count: trades.length }];
+  }
+
+  const step = (max - min) / binCount;
+  const bins = Array.from({ length: binCount }, (_, index) => ({
+    id: String(index),
+    min: min + step * index,
+    max: index === binCount - 1 ? max : min + step * (index + 1),
+    count: 0,
+  }));
+
+  for (const pnl of pnlValues) {
+    const rawIndex = Math.floor((pnl - min) / step);
+    const bin = bins[Math.max(0, Math.min(binCount - 1, rawIndex))];
+    if (bin) bin.count += 1;
+  }
+
+  return bins;
+};
+
+export const buildSessionPnlStats = (
+  trades: StrategyTradePoint[],
+): SessionPnlStat[] => {
+  const stats = new Map<TradingSession, SessionPnlStat>(
+    (['Asia', 'Europe', 'US'] as const).map((session) => [
+      session,
+      { session, pnl: 0, orders: 0 },
+    ]),
+  );
+
+  for (const trade of trades) {
+    const stat = stats.get(trade.session);
+    if (!stat) continue;
+    stat.pnl += trade.pnl;
+    stat.orders += 1;
+  }
+
+  return [...stats.values()];
+};
+
+export const buildHourlyPnlStats = (
+  trades: StrategyTradePoint[],
+): HourlyPnlStat[] => {
+  const stats = Array.from({ length: 24 }, (_, hour) => ({
+    hour,
+    pnl: 0,
+    orders: 0,
+  }));
+
+  for (const trade of trades) {
+    const stat = stats[trade.hour];
+    if (!stat) continue;
+    stat.pnl += trade.pnl;
+    stat.orders += 1;
+  }
+
+  return stats;
+};
+
+const getMonthLabel = (monthIndex: number) =>
+  new Date(Date.UTC(2026, monthIndex - 1, 1)).toLocaleString('en-US', {
+    month: 'short',
+  });
+
+const monthQuarters = [
+  { label: 'Q1', months: [1, 2, 3] },
+  { label: 'Q2', months: [4, 5, 6] },
+  { label: 'Q3', months: [7, 8, 9] },
+  { label: 'Q4', months: [10, 11, 12] },
+] as const;
+
+export const buildQuarterlyMonthlyStats = (
+  months: MonthlyStat[],
+): QuarterlyMonthlyStats[] => {
+  const byMonth = new Map(months.map((month) => [month.monthIndex, month]));
+
+  return monthQuarters
+    .map((quarter) => {
+      const quarterMonths = quarter.months.map(
+        (monthIndex) => byMonth.get(monthIndex) ?? null,
+      );
+
+      return {
+        label: quarter.label,
+        monthIndexes: quarter.months,
+        months: quarterMonths,
+        hasData: quarterMonths.some((month) => month != null),
+      };
+    })
+    .filter((quarter) => quarter.hasData);
+};
+
+export const buildMonthlyStats = (
+  orderLog: EquityLog,
+): YearlyMonthlyStats[] => {
+  const grouped = new Map<string, MonthlyStat>();
+
+  for (let index = 1; index < orderLog.length; index += 1) {
+    const current = orderLog[index];
+    const previous = orderLog[index - 1];
+    if (!current || !previous) continue;
+
+    const [timestamp, amount] = current;
+    const previousAmount = previous[1];
+    if (
+      !Number.isFinite(timestamp) ||
+      !Number.isFinite(amount) ||
+      !Number.isFinite(previousAmount)
+    ) {
+      continue;
+    }
+
+    const date = new Date(timestamp);
+    const year = date.getUTCFullYear();
+    const monthIndex = date.getUTCMonth() + 1;
+    const id = `${year}-${String(monthIndex).padStart(2, '0')}`;
+    const pnl = amount - previousAmount;
+    const existing = grouped.get(id) ?? {
+      id,
+      year,
+      monthIndex,
+      monthLabel: getMonthLabel(monthIndex),
+      orders: 0,
+      wins: 0,
+      pnl: 0,
+    };
+
+    existing.orders += 1;
+    existing.wins += pnl > 0 ? 1 : 0;
+    existing.pnl += pnl;
+    grouped.set(id, existing);
+  }
+
+  const yearlyStats = new Map<number, MonthlyStat[]>();
+  for (const month of [...grouped.values()].sort(
+    (left, right) =>
+      left.year - right.year || left.monthIndex - right.monthIndex,
+  )) {
+    const months = yearlyStats.get(month.year) ?? [];
+    months.push(month);
+    yearlyStats.set(month.year, months);
+  }
+
+  return [...yearlyStats.entries()]
+    .sort(([leftYear], [rightYear]) => leftYear - rightYear)
+    .map(([year, months]) => ({ year, months }));
+};
+
+export const buildStrategyPerformanceViewModel = (
+  orderLog: EquityLog,
+): StrategyPerformanceViewModel => {
+  const tradePoints = buildStrategyTradePoints(orderLog);
+
+  return {
+    monthlyStats: buildMonthlyStats(orderLog),
+    tradePoints,
+    drawdownPoints: buildDrawdownPoints(orderLog),
+    rollingPerformancePoints: buildRollingPerformance(tradePoints, 50),
+    pnlDistributionBins: buildPnlDistribution(tradePoints),
+    sessionPnlStats: buildSessionPnlStats(tradePoints),
+    hourlyPnlStats: buildHourlyPnlStats(tradePoints),
+  };
+};

package/src/app/routes/dashboard/Dashboard.tsx

@@ -7,12 +7,8 @@ import { Box, Button, Flex, ClientOnly } from '@chakra-ui/react';
 import { useFilters, useTickers, useTestList } from '#store';
 import { Filters } from '#shared/Filters';
 import { MainChart } from '#app/components/Dashboard/MainChart';
-import {
-  Interval,
-  MarketUniverse,
-  OnChangeFilters,
-  Provider,
-} from '@tradejs/types';
+import { Interval, MarketUniverse, Provider } from '@tradejs/types';
+import type { OnChangeFilters } from '#app/types/ui';
 import {
   buildDashboardPath,
   parseDashboardPath as parseMarketDashboardPath,