backtest-kit 1.4.11 → 1.4.13

package/build/index.cjs

@@ -7,6 +7,7 @@ var fs = require('fs/promises');
 var path = require('path');
 var crypto = require('crypto');
 var os = require('os');
+var fs$1 = require('fs');
 
 const GLOBAL_CONFIG = {
     /**
@@ -162,6 +163,7 @@ const markdownServices$1 = {
     walkerMarkdownService: Symbol('walkerMarkdownService'),
     heatMarkdownService: Symbol('heatMarkdownService'),
     partialMarkdownService: Symbol('partialMarkdownService'),
+    outlineMarkdownService: Symbol('outlineMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -10462,6 +10464,11 @@ const columns = [
         label: "Symbol",
         format: (data) => data.symbol,
     },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+    },
     {
         key: "signalId",
         label: "Signal ID",
@@ -10496,7 +10503,7 @@ const columns = [
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS = 250;
 /**
- * Storage class for accumulating partial profit/loss events per symbol.
+ * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
 class ReportStorage {
@@ -10507,17 +10514,17 @@ class ReportStorage {
     /**
      * Adds a profit event to the storage.
      *
-     * @param symbol - Trading pair symbol
      * @param data - Signal row data
      * @param currentPrice - Current market price
      * @param level - Profit level reached
      * @param backtest - True if backtest mode
      */
-    addProfitEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+    addProfitEvent(data, currentPrice, level, backtest, timestamp) {
         this._eventList.push({
             timestamp,
             action: "profit",
-            symbol,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
             signalId: data.id,
             position: data.position,
             currentPrice,
@@ -10532,17 +10539,17 @@ class ReportStorage {
     /**
      * Adds a loss event to the storage.
      *
-     * @param symbol - Trading pair symbol
      * @param data - Signal row data
      * @param currentPrice - Current market price
      * @param level - Loss level reached
      * @param backtest - True if backtest mode
      */
-    addLossEvent(symbol, data, currentPrice, level, backtest, timestamp) {
+    addLossEvent(data, currentPrice, level, backtest, timestamp) {
         this._eventList.push({
             timestamp,
             action: "loss",
-            symbol,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
             signalId: data.id,
             position: data.position,
             currentPrice,
@@ -10578,35 +10585,37 @@ class ReportStorage {
         };
     }
     /**
-     * Generates markdown report with all partial events for a symbol (View).
+     * Generates markdown report with all partial events for a symbol-strategy pair (View).
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol) {
+    async getReport(symbol, strategyName) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
-            return functoolsKit.str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", "No partial profit/loss events recorded yet.");
+            return functoolsKit.str.newline(`# Partial Profit/Loss Report: ${symbol}:${strategyName}`, "", "No partial profit/loss events recorded yet.");
         }
         const header = columns.map((col) => col.label);
         const separator = columns.map(() => "---");
         const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = functoolsKit.str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
-        return functoolsKit.str.newline(`# Partial Profit/Loss Report: ${symbol}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Profit events:** ${stats.totalProfit}`, `**Loss events:** ${stats.totalLoss}`);
+        return functoolsKit.str.newline(`# Partial Profit/Loss Report: ${symbol}:${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Profit events:** ${stats.totalProfit}`, `**Loss events:** ${stats.totalLoss}`);
     }
     /**
-     * Saves symbol report to disk.
+     * Saves symbol-strategy report to disk.
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/partial")
      */
-    async dump(symbol, path$1 = "./dump/partial") {
-        const markdown = await this.getReport(symbol);
+    async dump(symbol, strategyName, path$1 = "./dump/partial") {
+        const markdown = await this.getReport(symbol, strategyName);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
-            const filename = `${symbol}.md`;
+            const filename = `${symbol}_${strategyName}.md`;
             const filepath = path.join(dir, filename);
             await fs.writeFile(filepath, markdown, "utf-8");
             console.log(`Partial profit/loss report saved: ${filepath}`);
@@ -10621,10 +10630,10 @@ class ReportStorage {
  *
  * Features:
  * - Listens to partial profit and loss events via partialProfitSubject/partialLossSubject
- * - Accumulates all events (profit, loss) per symbol
+ * - Accumulates all events (profit, loss) per symbol-strategy pair
  * - Generates markdown tables with detailed event information
  * - Provides statistics (total profit/loss events)
- * - Saves reports to disk in dump/partial/{symbol}.md
+ * - Saves reports to disk in dump/partial/{symbol}_{strategyName}.md
  *
  * @example
  * ```typescript
@@ -10634,7 +10643,7 @@ class ReportStorage {
  * // No manual callback setup needed
  *
  * // Later: generate and save report
- * await service.dump("BTCUSDT");
+ * await service.dump("BTCUSDT", "my-strategy");
  * ```
  */
 class PartialMarkdownService {
@@ -10642,10 +10651,10 @@ class PartialMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol.
-         * Each symbol gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol]) => `${symbol}`, () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => JSON.stringify([symbol, strategyName]), () => new ReportStorage());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -10662,8 +10671,8 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickProfit", {
                 data,
             });
-            const storage = this.getStorage(data.symbol);
-            storage.addProfitEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            storage.addProfitEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
          * Processes loss events and accumulates them.
@@ -10681,101 +10690,113 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickLoss", {
                 data,
             });
-            const storage = this.getStorage(data.symbol);
-            storage.addLossEvent(data.symbol, data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
+            const storage = this.getStorage(data.symbol, data.data.strategyName);
+            storage.addLossEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
-         * Gets statistical data from all partial profit/loss events for a symbol.
+         * Gets statistical data from all partial profit/loss events for a symbol-strategy pair.
          * Delegates to ReportStorage.getData().
          *
          * @param symbol - Trading pair symbol to get data for
+         * @param strategyName - Strategy name to get data for
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const stats = await service.getData("BTCUSDT");
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
          * console.log(stats.totalProfit, stats.totalLoss);
          * ```
          */
-        this.getData = async (symbol) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("partialMarkdownService getData", {
                 symbol,
+                strategyName,
             });
-            const storage = this.getStorage(symbol);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all partial events for a symbol.
+         * Generates markdown report with all partial events for a symbol-strategy pair.
          * Delegates to ReportStorage.getReport().
          *
          * @param symbol - Trading pair symbol to generate report for
+         * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
+                strategyName,
             });
-            const storage = this.getStorage(symbol);
-            return storage.getReport(symbol);
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getReport(symbol, strategyName);
         };
         /**
-         * Saves symbol report to disk.
+         * Saves symbol-strategy report to disk.
          * Creates directory if it doesn't exist.
          * Delegates to ReportStorage.dump().
          *
          * @param symbol - Trading pair symbol to save report for
+         * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/partial")
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Save to default path: ./dump/partial/BTCUSDT.md
-         * await service.dump("BTCUSDT");
+         * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy");
          *
-         * // Save to custom path: ./custom/path/BTCUSDT.md
-         * await service.dump("BTCUSDT", "./custom/path");
+         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, path = "./dump/partial") => {
+        this.dump = async (symbol, strategyName, path = "./dump/partial") => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
+                strategyName,
                 path,
             });
-            const storage = this.getStorage(symbol);
-            await storage.dump(symbol, path);
+            const storage = this.getStorage(symbol, strategyName);
+            await storage.dump(symbol, strategyName, path);
         };
         /**
          * Clears accumulated event data from storage.
-         * If symbol is provided, clears only that symbol's data.
-         * If symbol is omitted, clears all symbols' data.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
          *
-         * @param symbol - Optional symbol to clear specific symbol data
+         * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Clear specific symbol data
-         * await service.clear("BTCUSDT");
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
-         * // Clear all symbols' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (symbol) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("partialMarkdownService clear", {
-                symbol,
+                ctx,
             });
-            this.getStorage.clear(symbol);
+            if (ctx) {
+                const key = JSON.stringify([ctx.symbol, ctx.strategyName]);
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to partial profit/loss events.
@@ -10906,6 +10927,145 @@ class PartialGlobalService {
     }
 }
 
+/**
+ * Warning threshold for message size in kilobytes.
+ * Messages exceeding this size trigger console warnings.
+ */
+const WARN_KB = 100;
+/**
+ * Internal function for dumping signal data to markdown files.
+ * Creates a directory structure with system prompts, user messages, and LLM output.
+ *
+ * @param signalId - Unique identifier for the result
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO with trade parameters
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ */
+const DUMP_SIGNAL_FN = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+    // Extract system messages and system reminders from existing data
+    const systemMessages = history.filter((m) => m.role === "system");
+    const userMessages = history.filter((m) => m.role === "user");
+    const subfolderPath = path.join(outputDir, String(signalId));
+    try {
+        await fs$1.promises.access(subfolderPath);
+        return;
+    }
+    catch {
+        await fs$1.promises.mkdir(subfolderPath, { recursive: true });
+    }
+    {
+        let summary = "# Outline Result Summary\n";
+        {
+            summary += "\n";
+            summary += `**ResultId**: ${String(signalId)}\n`;
+            summary += "\n";
+        }
+        if (signal) {
+            summary += "## Output Data\n\n";
+            summary += "```json\n";
+            summary += JSON.stringify(signal, null, 2);
+            summary += "\n```\n\n";
+        }
+        // Add system messages to summary
+        if (systemMessages.length > 0) {
+            summary += "## System Messages\n\n";
+            systemMessages.forEach((msg, idx) => {
+                summary += `### System Message ${idx + 1}\n\n`;
+                summary += msg.content;
+                summary += "\n";
+            });
+        }
+        const summaryFile = path.join(subfolderPath, "00_system_prompt.md");
+        await fs$1.promises.writeFile(summaryFile, summary, "utf8");
+    }
+    {
+        await Promise.all(Array.from(userMessages.entries()).map(async ([idx, message]) => {
+            const messageNum = String(idx + 1).padStart(2, "0");
+            const contentFileName = `${messageNum}_user_message.md`;
+            const contentFilePath = path.join(subfolderPath, contentFileName);
+            {
+                const messageSizeBytes = Buffer.byteLength(message.content, "utf8");
+                const messageSizeKb = Math.floor(messageSizeBytes / 1024);
+                if (messageSizeKb > WARN_KB) {
+                    console.warn(`User message ${idx + 1} is ${messageSizeBytes} bytes (${messageSizeKb}kb), which exceeds warning limit`);
+                }
+            }
+            let content = `# User Input ${idx + 1}\n\n`;
+            content += `**ResultId**: ${String(signalId)}\n\n`;
+            content += message.content;
+            content += "\n";
+            await fs$1.promises.writeFile(contentFilePath, content, "utf8");
+        }));
+    }
+    {
+        const messageNum = String(userMessages.length + 1).padStart(2, "0");
+        const contentFileName = `${messageNum}_llm_output.md`;
+        const contentFilePath = path.join(subfolderPath, contentFileName);
+        let content = "# Full Outline Result\n\n";
+        content += `**ResultId**: ${String(signalId)}\n\n`;
+        if (signal) {
+            content += "## Output Data\n\n";
+            content += "```json\n";
+            content += JSON.stringify(signal, null, 2);
+            content += "\n```\n";
+        }
+        await fs$1.promises.writeFile(contentFilePath, content, "utf8");
+    }
+};
+/**
+ * Service for generating markdown documentation from LLM outline results.
+ * Used by AI Strategy Optimizer to save debug logs and conversation history.
+ *
+ * Creates directory structure:
+ * - ./dump/strategy/{signalId}/00_system_prompt.md - System messages and output data
+ * - ./dump/strategy/{signalId}/01_user_message.md - First user input
+ * - ./dump/strategy/{signalId}/02_user_message.md - Second user input
+ * - ./dump/strategy/{signalId}/XX_llm_output.md - Final LLM output
+ */
+class OutlineMarkdownService {
+    constructor() {
+        /** Logger service injected via DI */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Dumps signal data and conversation history to markdown files.
+         * Skips if directory already exists to avoid overwriting previous results.
+         *
+         * Generated files:
+         * - 00_system_prompt.md - System messages and output summary
+         * - XX_user_message.md - Each user message in separate file (numbered)
+         * - XX_llm_output.md - Final LLM output with signal data
+         *
+         * @param signalId - Unique identifier for the result (used as directory name)
+         * @param history - Array of message models from LLM conversation
+         * @param signal - Signal DTO with trade parameters (priceOpen, TP, SL, etc.)
+         * @param outputDir - Output directory path (default: "./dump/strategy")
+         * @returns Promise that resolves when all files are written
+         *
+         * @example
+         * ```typescript
+         * await outlineService.dumpSignal(
+         *   "strategy-1",
+         *   conversationHistory,
+         *   { position: "long", priceTakeProfit: 51000, priceStopLoss: 49000, minuteEstimatedTime: 60 }
+         * );
+         * // Creates: ./dump/strategy/strategy-1/00_system_prompt.md
+         * //          ./dump/strategy/strategy-1/01_user_message.md
+         * //          ./dump/strategy/strategy-1/02_llm_output.md
+         * ```
+         */
+        this.dumpSignal = async (signalId, history, signal, outputDir = "./dump/strategy") => {
+            this.loggerService.log("outlineMarkdownService dumpSignal", {
+                signalId,
+                history,
+                signal,
+                outputDir,
+            });
+            return await DUMP_SIGNAL_FN(signalId, history, signal, outputDir);
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -10963,6 +11123,7 @@ class PartialGlobalService {
     provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
     provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
+    provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -11034,6 +11195,7 @@ const markdownServices = {
     walkerMarkdownService: inject(TYPES.walkerMarkdownService),
     heatMarkdownService: inject(TYPES.heatMarkdownService),
     partialMarkdownService: inject(TYPES.partialMarkdownService),
+    outlineMarkdownService: inject(TYPES.outlineMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -12700,6 +12862,83 @@ async function getMode() {
     return bt ? "backtest" : "live";
 }
 
+const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
+/**
+ * Dumps signal data and LLM conversation history to markdown files.
+ * Used by AI-powered strategies to save debug logs for analysis.
+ *
+ * Creates a directory structure with:
+ * - 00_system_prompt.md - System messages and output summary
+ * - XX_user_message.md - Each user message in separate file (numbered)
+ * - XX_llm_output.md - Final LLM output with signal data
+ *
+ * Skips if directory already exists to avoid overwriting previous results.
+ *
+ * @param signalId - Unique identifier for the result (used as directory name, e.g., UUID)
+ * @param history - Array of message models from LLM conversation
+ * @param signal - Signal DTO returned by LLM (position, priceOpen, TP, SL, etc.)
+ * @param outputDir - Output directory path (default: "./dump/strategy")
+ * @returns Promise that resolves when all files are written
+ *
+ * @example
+ * ```typescript
+ * import { dumpSignal, getCandles } from "backtest-kit";
+ * import { v4 as uuid } from "uuid";
+ *
+ * addStrategy({
+ *   strategyName: "llm-strategy",
+ *   interval: "5m",
+ *   getSignal: async (symbol) => {
+ *     const messages = [];
+ *
+ *     // Build multi-timeframe analysis conversation
+ *     const candles1h = await getCandles(symbol, "1h", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 1h trend:\n${formatCandles(candles1h)}` },
+ *       { role: "assistant", content: "Trend analyzed" }
+ *     );
+ *
+ *     const candles5m = await getCandles(symbol, "5m", 24);
+ *     messages.push(
+ *       { role: "user", content: `Analyze 5m structure:\n${formatCandles(candles5m)}` },
+ *       { role: "assistant", content: "Structure analyzed" }
+ *     );
+ *
+ *     // Request signal
+ *     messages.push({
+ *       role: "user",
+ *       content: "Generate trading signal. Use position: 'wait' if uncertain."
+ *     });
+ *
+ *     const resultId = uuid();
+ *     const signal = await llmRequest(messages);
+ *
+ *     // Save conversation and result for debugging
+ *     await dumpSignal(resultId, messages, signal);
+ *
+ *     return signal;
+ *   }
+ * });
+ *
+ * // Creates: ./dump/strategy/{uuid}/00_system_prompt.md
+ * //          ./dump/strategy/{uuid}/01_user_message.md (1h analysis)
+ * //          ./dump/strategy/{uuid}/02_assistant_message.md
+ * //          ./dump/strategy/{uuid}/03_user_message.md (5m analysis)
+ * //          ./dump/strategy/{uuid}/04_assistant_message.md
+ * //          ./dump/strategy/{uuid}/05_user_message.md (signal request)
+ * //          ./dump/strategy/{uuid}/06_llm_output.md (final signal)
+ * ```
+ */
+async function dumpSignal(signalId, history, signal, outputDir = "./dump/strategy") {
+    backtest$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
+        signalId,
+        history,
+        signal,
+        outputDir,
+    });
+    return await backtest$1.outlineMarkdownService.dumpSignal(signalId, history, signal, outputDir);
+}
+
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
 const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
@@ -13920,26 +14159,26 @@ const PARTIAL_METHOD_NAME_DUMP = "PartialUtils.dump";
  *
  * Data source:
  * - PartialMarkdownService listens to partialProfitSubject/partialLossSubject
- * - Accumulates events in ReportStorage (max 250 events per symbol)
- * - Events include: timestamp, action, symbol, signalId, position, level, price, mode
+ * - Accumulates events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: timestamp, action, symbol, strategyName, signalId, position, level, price, mode
  *
  * @example
  * ```typescript
  * import { Partial } from "./classes/Partial";
  *
- * // Get statistical data for BTCUSDT
- * const stats = await Partial.getData("BTCUSDT");
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Partial.getData("BTCUSDT", "my-strategy");
  * console.log(`Total events: ${stats.totalEvents}`);
  * console.log(`Profit events: ${stats.totalProfit}`);
  * console.log(`Loss events: ${stats.totalLoss}`);
  *
  * // Generate markdown report
- * const markdown = await Partial.getReport("BTCUSDT");
+ * const markdown = await Partial.getReport("BTCUSDT", "my-strategy");
  * console.log(markdown); // Formatted table with all events
  *
  * // Export report to file
- * await Partial.dump("BTCUSDT"); // Saves to ./dump/partial/BTCUSDT.md
- * await Partial.dump("BTCUSDT", "./custom/path"); // Custom directory
+ * await Partial.dump("BTCUSDT", "my-strategy"); // Saves to ./dump/partial/BTCUSDT_my-strategy.md
+ * await Partial.dump("BTCUSDT", "my-strategy", "./custom/path"); // Custom directory
  * ```
  */
 class PartialUtils {
@@ -13951,11 +14190,12 @@ class PartialUtils {
          * Returns aggregated metrics calculated from all profit and loss events.
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
          * @returns Promise resolving to PartialStatistics object with counts and event list
          *
          * @example
          * ```typescript
-         * const stats = await Partial.getData("BTCUSDT");
+         * const stats = await Partial.getData("BTCUSDT", "my-strategy");
          *
          * console.log(`Total events: ${stats.totalEvents}`);
          * console.log(`Profit events: ${stats.totalProfit} (${(stats.totalProfit / stats.totalEvents * 100).toFixed(1)}%)`);
@@ -13967,16 +14207,17 @@ class PartialUtils {
          * }
          * ```
          */
-        this.getData = async (symbol) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol });
-            return await backtest$1.partialMarkdownService.getData(symbol);
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            return await backtest$1.partialMarkdownService.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all partial profit/loss events for a symbol.
+         * Generates markdown report with all partial profit/loss events for a symbol-strategy pair.
          *
          * Creates formatted table containing:
          * - Action (PROFIT/LOSS)
          * - Symbol
+         * - Strategy
          * - Signal ID
          * - Position (LONG/SHORT)
          * - Level % (+10%, -20%, etc)
@@ -13987,35 +14228,36 @@ class PartialUtils {
          * Also includes summary statistics at the end.
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Partial.getReport("BTCUSDT");
+         * const markdown = await Partial.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          *
          * // Output:
-         * // # Partial Profit/Loss Report: BTCUSDT
+         * // # Partial Profit/Loss Report: BTCUSDT:my-strategy
          * //
-         * // | Action | Symbol | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
-         * // | --- | --- | --- | --- | --- | --- | --- | --- |
-         * // | PROFIT | BTCUSDT | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
-         * // | LOSS | BTCUSDT | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
+         * // | Action | Symbol | Strategy | Signal ID | Position | Level % | Current Price | Timestamp | Mode |
+         * // | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+         * // | PROFIT | BTCUSDT | my-strategy | abc123 | LONG | +10% | 51500.00000000 USD | 2024-01-15T10:30:00.000Z | Backtest |
+         * // | LOSS | BTCUSDT | my-strategy | abc123 | LONG | -10% | 49000.00000000 USD | 2024-01-15T11:00:00.000Z | Backtest |
          * //
          * // **Total events:** 2
          * // **Profit events:** 1
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol });
-            return await backtest$1.partialMarkdownService.getReport(symbol);
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName);
         };
         /**
          * Generates and saves markdown report to file.
          *
          * Creates directory if it doesn't exist.
-         * Filename format: {symbol}.md (e.g., "BTCUSDT.md")
+         * Filename format: {symbol}_{strategyName}.md (e.g., "BTCUSDT_my-strategy.md")
          *
          * Delegates to PartialMarkdownService.dump() which:
          * 1. Generates markdown report via getReport()
@@ -14024,26 +14266,27 @@ class PartialUtils {
          * 4. Logs success/failure to console
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/partial")
          * @returns Promise that resolves when file is written
          *
          * @example
          * ```typescript
-         * // Save to default path: ./dump/partial/BTCUSDT.md
-         * await Partial.dump("BTCUSDT");
+         * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
+         * await Partial.dump("BTCUSDT", "my-strategy");
          *
-         * // Save to custom path: ./reports/partial/BTCUSDT.md
-         * await Partial.dump("BTCUSDT", "./reports/partial");
+         * // Save to custom path: ./reports/partial/BTCUSDT_my-strategy.md
+         * await Partial.dump("BTCUSDT", "my-strategy", "./reports/partial");
          *
          * // After multiple symbols backtested, export all reports
          * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
-         *   await Partial.dump(symbol, "./backtest-results");
+         *   await Partial.dump(symbol, "my-strategy", "./backtest-results");
          * }
          * ```
          */
-        this.dump = async (symbol, path) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, path });
-            await backtest$1.partialMarkdownService.dump(symbol, path);
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path);
         };
     }
 }
@@ -14056,9 +14299,9 @@ class PartialUtils {
  * import { Partial } from "backtest-kit";
  *
  * // Usage same as PartialUtils methods
- * const stats = await Partial.getData("BTCUSDT");
- * const report = await Partial.getReport("BTCUSDT");
- * await Partial.dump("BTCUSDT");
+ * const stats = await Partial.getData("BTCUSDT", "my-strategy");
+ * const report = await Partial.getReport("BTCUSDT", "my-strategy");
+ * await Partial.dump("BTCUSDT", "my-strategy");
  * ```
  */
 const Partial = new PartialUtils();
@@ -14168,6 +14411,7 @@ exports.addRisk = addRisk;
 exports.addSizing = addSizing;
 exports.addStrategy = addStrategy;
 exports.addWalker = addWalker;
+exports.dumpSignal = dumpSignal;
 exports.emitters = emitters;
 exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;