tradeblocks-mcp 0.4.2 → 0.4.8

package/dist/test-exports.js

@@ -20454,8 +20454,17 @@ async function discoverCsvFiles(folderPath) {
     if (csvFiles.includes("reportinglog.csv")) {
       mappings.reportinglog = "reportinglog.csv";
     }
+    if (!mappings.reportinglog) {
+      const strategyLogFile = csvFiles.find((f) => {
+        const lower = f.toLowerCase();
+        return lower.includes("strategy-trade-log") || lower.includes("strategylog") || lower.startsWith("strategy-log");
+      });
+      if (strategyLogFile) {
+        mappings.reportinglog = strategyLogFile;
+      }
+    }
     for (const csvFile of csvFiles) {
-      if (csvFile === "tradelog.csv" || csvFile === "dailylog.csv" || csvFile === "reportinglog.csv") {
+      if (csvFile === "tradelog.csv" || csvFile === "dailylog.csv" || csvFile === "reportinglog.csv" || csvFile === mappings.reportinglog) {
         continue;
       }
       const csvPath = path.join(folderPath, csvFile);
@@ -20761,6 +20770,19 @@ async function listBlocks(baseDir) {
         continue;
       }
       const hasDailyLog = !!dailylogFilename;
+      const reportingLogFilename = await findReportingLogFile(blockPath, metadata);
+      const hasReportingLog = !!reportingLogFilename;
+      let reportingLogSummary;
+      if (hasReportingLog && metadata?.reportingLogStats) {
+        const reportingLogStale = reportingLogFilename ? !await isReportingLogCacheValid(blockPath, metadata, reportingLogFilename) : false;
+        reportingLogSummary = {
+          tradeCount: metadata.reportingLogStats.totalTrades,
+          strategyCount: metadata.reportingLogStats.strategies.length,
+          totalPL: metadata.reportingLogStats.totalPL,
+          dateRange: metadata.reportingLogStats.dateRange,
+          stale: reportingLogStale
+        };
+      }
       const cacheValid = metadata?.cachedStats && !needsMetadataUpdate && await isCacheValid(blockPath, metadata);
       if (cacheValid && metadata?.cachedStats) {
         blocks.push({
@@ -20768,13 +20790,15 @@ async function listBlocks(baseDir) {
           name: metadata.name || entry.name,
           tradeCount: metadata.tradeCount,
           hasDailyLog,
+          hasReportingLog,
           dateRange: {
             start: metadata.dateRange.start ? new Date(metadata.dateRange.start) : null,
             end: metadata.dateRange.end ? new Date(metadata.dateRange.end) : null
           },
           strategies: metadata.strategies,
           totalPl: metadata.cachedStats.totalPl,
-          netPl: metadata.cachedStats.netPl
+          netPl: metadata.cachedStats.netPl,
+          reportingLog: reportingLogSummary
         });
       } else {
         try {
@@ -20800,13 +20824,15 @@ async function listBlocks(baseDir) {
             name: updatedMetadata.name,
             tradeCount: trades.length,
             hasDailyLog,
+            hasReportingLog,
             dateRange: {
               start: updatedMetadata.dateRange.start ? new Date(updatedMetadata.dateRange.start) : null,
               end: updatedMetadata.dateRange.end ? new Date(updatedMetadata.dateRange.end) : null
             },
             strategies: updatedMetadata.strategies,
             totalPl,
-            netPl: totalPl - totalCommissions
+            netPl: totalPl - totalCommissions,
+            reportingLog: reportingLogSummary
           });
           await saveMetadata(blockPath, updatedMetadata);
         } catch (error) {
@@ -20866,22 +20892,20 @@ async function loadReportingLog(baseDir, blockId) {
   try {
     await fs.access(reportingLogPath);
   } catch {
-    if (filename === "reportinglog.csv") {
-      const discovered = await discoverCsvFiles(blockPath);
-      if (discovered.mappings.reportinglog) {
-        const altPath = path.join(blockPath, discovered.mappings.reportinglog);
-        const content2 = await fs.readFile(altPath, "utf-8");
-        const records2 = parseCSV(content2);
-        const trades2 = [];
-        for (const record of records2) {
-          const trade = convertToReportingTrade(record);
-          if (trade) trades2.push(trade);
-        }
-        trades2.sort(
-          (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
-        );
-        return trades2;
-      }
+    const discovered = await discoverCsvFiles(blockPath);
+    if (discovered.mappings.reportinglog) {
+      const altPath = path.join(blockPath, discovered.mappings.reportinglog);
+      const content2 = await fs.readFile(altPath, "utf-8");
+      const records2 = parseCSV(content2);
+      const trades2 = [];
+      for (const record of records2) {
+        const trade = convertToReportingTrade(record);
+        if (trade) trades2.push(trade);
+      }
+      trades2.sort(
+        (a, b) => new Date(a.dateOpened).getTime() - new Date(b.dateOpened).getTime()
+      );
+      return trades2;
     }
     throw new Error(`reportinglog.csv not found in block: ${blockId}`);
   }
@@ -20899,6 +20923,148 @@ async function loadReportingLog(baseDir, blockId) {
   );
   return trades;
 }
+function computeReportingLogStats(trades, invalidCount = 0) {
+  const byStrategy = {};
+  const strategyTrades = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const strategyKey = trade.strategy.trim();
+    if (!strategyTrades.has(strategyKey)) {
+      strategyTrades.set(strategyKey, []);
+    }
+    strategyTrades.get(strategyKey).push(trade);
+  }
+  for (const [strategy, strategyTradeList] of strategyTrades) {
+    const tradeCount = strategyTradeList.length;
+    const winningTrades = strategyTradeList.filter((t) => t.pl > 0).length;
+    const winRate = tradeCount > 0 ? winningTrades / tradeCount : 0;
+    const totalPL = strategyTradeList.reduce((sum2, t) => sum2 + t.pl, 0);
+    const avgPL = tradeCount > 0 ? totalPL / tradeCount : 0;
+    const contractCount = strategyTradeList.reduce(
+      (sum2, t) => sum2 + t.numContracts,
+      0
+    );
+    byStrategy[strategy] = {
+      tradeCount,
+      winRate,
+      totalPL,
+      avgPL,
+      contractCount
+    };
+  }
+  const dates = trades.map((t) => new Date(t.dateOpened).getTime());
+  const dateRange = {
+    start: dates.length > 0 ? new Date(Math.min(...dates)).toISOString() : null,
+    end: dates.length > 0 ? new Date(Math.max(...dates)).toISOString() : null
+  };
+  return {
+    totalTrades: trades.length,
+    totalPL: trades.reduce((sum2, t) => sum2 + t.pl, 0),
+    dateRange,
+    strategies: Array.from(strategyTrades.keys()).sort(),
+    byStrategy,
+    invalidTrades: invalidCount,
+    calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function findReportingLogFile(blockPath, metadata) {
+  if (metadata?.csvMappings?.reportinglog) {
+    const mappedPath = path.join(blockPath, metadata.csvMappings.reportinglog);
+    try {
+      await fs.access(mappedPath);
+      return metadata.csvMappings.reportinglog;
+    } catch {
+    }
+  }
+  const standardPath = path.join(blockPath, "reportinglog.csv");
+  try {
+    await fs.access(standardPath);
+    return "reportinglog.csv";
+  } catch {
+  }
+  const discovered = await discoverCsvFiles(blockPath);
+  return discovered.mappings.reportinglog;
+}
+async function isReportingLogCacheValid(blockPath, metadata, reportingLogFilename) {
+  if (!metadata.reportingLogStats) {
+    return false;
+  }
+  if (!metadata.csvFileMtimes?.reportinglog) {
+    return false;
+  }
+  try {
+    const filePath = path.join(blockPath, reportingLogFilename);
+    const stat2 = await fs.stat(filePath);
+    return stat2.mtimeMs === metadata.csvFileMtimes.reportinglog;
+  } catch {
+    return false;
+  }
+}
+async function loadReportingLogStats(baseDir, blockId) {
+  const blockPath = path.join(baseDir, blockId);
+  const metadata = await loadMetadata(blockPath);
+  const reportingLogFilename = await findReportingLogFile(blockPath, metadata);
+  if (!reportingLogFilename) {
+    return void 0;
+  }
+  if (metadata && await isReportingLogCacheValid(blockPath, metadata, reportingLogFilename)) {
+    return {
+      stats: metadata.reportingLogStats,
+      stale: false
+    };
+  }
+  try {
+    const reportingLogPath = path.join(blockPath, reportingLogFilename);
+    const content = await fs.readFile(reportingLogPath, "utf-8");
+    const records = parseCSV(content);
+    const trades = [];
+    let invalidCount = 0;
+    for (const record of records) {
+      const trade = convertToReportingTrade(record);
+      if (trade) {
+        trades.push(trade);
+      } else {
+        invalidCount++;
+      }
+    }
+    const stats = computeReportingLogStats(trades, invalidCount);
+    const fileStat = await fs.stat(reportingLogPath);
+    const updatedMetadata = {
+      ...metadata || {
+        blockId,
+        name: blockId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tradeCount: 0,
+        dailyLogCount: 0,
+        dateRange: { start: null, end: null },
+        strategies: []
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      csvMappings: {
+        ...metadata?.csvMappings || {},
+        reportinglog: reportingLogFilename
+      },
+      csvFileMtimes: {
+        ...metadata?.csvFileMtimes || {},
+        reportinglog: fileStat.mtimeMs
+      },
+      reportingLogStats: stats
+    };
+    await saveMetadata(blockPath, updatedMetadata);
+    return {
+      stats,
+      stale: false
+    };
+  } catch (error) {
+    if (metadata?.reportingLogStats) {
+      return {
+        stats: metadata.reportingLogStats,
+        stale: true
+      };
+    }
+    throw error;
+  }
+}
 function toKebabCase(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").toLowerCase().replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -21055,6 +21221,7 @@ export {
   loadBlock,
   loadMetadata,
   loadReportingLog,
+  loadReportingLogStats,
   performTailRiskAnalysis,
   saveMetadata
 };