@backtest-kit/cli 6.2.0 → 6.4.0

package/build/index.cjs

@@ -87,64 +87,6 @@ var BacktestKitSignals__namespace = /*#__PURE__*/_interopNamespaceDefault(Backte
     });
 }
 
-{
-    BacktestKit.Storage.enable();
-    BacktestKit.Notification.enable();
-}
-{
-    BacktestKit.Markdown.enable();
-    BacktestKit.Report.enable();
-    BacktestKit.Dump.enable();
-    BacktestKit.Memory.enable();
-}
-{
-    BacktestKit.Dump.useMarkdown();
-    BacktestKit.Memory.usePersist();
-}
-{
-    BacktestKit.StorageLive.usePersist();
-    BacktestKit.StorageBacktest.useMemory();
-}
-{
-    BacktestKit.NotificationLive.usePersist();
-    BacktestKit.NotificationBacktest.useMemory();
-}
-{
-    BacktestKit.Markdown.useDummy();
-}
-BacktestKit.setConfig({
-    CC_MAX_NOTIFICATIONS: 5000,
-    CC_MAX_SIGNALS: 750,
-});
-BacktestKit.setConfig({
-    CC_ENABLE_DCA_EVERYWHERE: true,
-    CC_ENABLE_PPPL_EVERYWHERE: true,
-    CC_ENABLE_TRAILING_EVERYWHERE: true,
-});
-BacktestKit.setConfig({
-    CC_MAX_SIGNAL_GENERATION_SECONDS: 15 * 60,
-});
-BacktestKit.setConfig({
-    CC_MAX_BACKTEST_MARKDOWN_ROWS: 1000,
-    CC_MAX_BREAKEVEN_MARKDOWN_ROWS: 1000,
-    CC_MAX_HEATMAP_MARKDOWN_ROWS: 1000,
-    CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: 1000,
-    CC_MAX_LIVE_MARKDOWN_ROWS: 1000,
-    CC_MAX_PARTIAL_MARKDOWN_ROWS: 1000,
-    CC_MAX_RISK_MARKDOWN_ROWS: 1000,
-    CC_MAX_SCHEDULE_MARKDOWN_ROWS: 1000,
-    CC_MAX_STRATEGY_MARKDOWN_ROWS: 1000,
-    CC_MAX_SYNC_MARKDOWN_ROWS: 1000,
-    CC_MAX_PERFORMANCE_MARKDOWN_ROWS: 1000,
-});
-BacktestKit.setConfig({
-    CC_MAX_SIGNAL_LIFETIME_MINUTES: Infinity,
-});
-BacktestKit.setConfig({
-    CC_WALKER_MARKDOWN_TOP_N: 10,
-});
-BacktestKit.Log.useJsonl();
-
 const ERROR_HANDLER_INSTALLED = Symbol.for("error-handler-installed");
 function dumpStackTrace() {
     const trace = stackTrace__namespace.get();
@@ -829,8 +771,15 @@ class WalkerMainService {
         this.moduleConnectionService = inject(TYPES.moduleConnectionService);
         this.run = functoolsKit.singleshot(async (payload) => {
             this.loggerService.log("walkerMainService run", { payload });
+            const strategyMap = new Map();
             for (const entryPoint of payload.entryPoints) {
                 await this.resolveService.attachStrategy(entryPoint);
+                for (const { strategyName } of await BacktestKit.listStrategySchema()) {
+                    if (strategyMap.has(strategyName)) {
+                        continue;
+                    }
+                    strategyMap.set(strategyName, entryPoint);
+                }
             }
             await this.moduleConnectionService.loadModule("./walker.module");
             {
@@ -867,19 +816,42 @@ class WalkerMainService {
             if (!frameName) {
                 throw new Error("Frame name is required");
             }
+            const cwd = process.cwd();
+            const self = this;
+            const callbacks = {
+                async onStrategyStart(strategyName) {
+                    const entryPoint = strategyMap.get(strategyName);
+                    if (!entryPoint) {
+                        return;
+                    }
+                    {
+                        Setup.clear();
+                        Setup.enable();
+                    }
+                    const absolutePath = path.resolve(entryPoint);
+                    const moduleRoot = path.dirname(absolutePath);
+                    {
+                        process.chdir(moduleRoot);
+                        cwd !== moduleRoot && BacktestKit.Log.useJsonl();
+                        dotenv.config({ path: path.join(cwd, '.env'), override: true, quiet: true });
+                        dotenv.config({ path: path.join(moduleRoot, '.env'), override: true, quiet: true });
+                    }
+                    if (!payload.noCache) {
+                        await self.cacheLogicService.execute(payload.cacheInterval, {
+                            exchangeName,
+                            frameName,
+                            symbol,
+                        });
+                    }
+                },
+            };
             BacktestKit.addWalkerSchema({
                 walkerName: WALKER_NAME,
                 exchangeName,
                 frameName,
                 strategies: strategyNames,
+                callbacks,
             });
-            if (!payload.noCache) {
-                await this.cacheLogicService.execute(payload.cacheInterval, {
-                    exchangeName,
-                    frameName,
-                    symbol,
-                });
-            }
             if (payload.verbose) {
                 BacktestKit.overrideExchangeSchema({
                     exchangeName,
@@ -895,8 +867,9 @@ class WalkerMainService {
                 BacktestKit.overrideWalkerSchema({
                     walkerName: WALKER_NAME,
                     callbacks: {
-                        onStrategyStart(strategyName, symbol) {
+                        async onStrategyStart(strategyName, symbol) {
                             console.log(`Strategy started: ${strategyName} for symbol: ${symbol}`);
+                            await callbacks.onStrategyStart(strategyName);
                         },
                         onStrategyError(strategyName, symbol, error) {
                             console.error(`Strategy error: ${strategyName} for symbol: ${symbol}`, error);
@@ -917,9 +890,12 @@ class WalkerMainService {
                 unWalker();
                 res();
             });
-            payload.verbose && console.time("Walker");
-            await awaiter;
-            payload.verbose && console.timeEnd("Walker");
+            {
+                payload.verbose && console.time("Walker");
+                await awaiter;
+                payload.verbose && console.timeEnd("Walker");
+            }
+            process.chdir(cwd);
             const dumpName = payload.output || `walker_${symbol}_${Date.now()}`;
             const dumpDir = path.join(process.cwd(), "dump");
             if (payload.json) {
@@ -2119,7 +2095,7 @@ const TRANSPILE_FN = functoolsKit.memoize(([path]) => `${path}`, (path, code, se
         eval(self.params.babel.transpile(code));
     }
     catch (error) {
-        console.log(`Error during transpilation error=\`${functoolsKit.getErrorMessage(error)}\` path=${path} __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
+        console.log(`Error during transpilation error=\`${functoolsKit.getErrorMessage(error)}\` path=\`${path}\` __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
         process.exit(-1);
     }
     return {
@@ -2411,6 +2387,109 @@ const cli = {
 };
 init();
 
+class SetupUtils {
+    constructor() {
+        this.enable = functoolsKit.singleshot(() => {
+            cli.loggerService.debug("SetupUtils enable");
+            {
+                BacktestKit.Storage.enable();
+                BacktestKit.Notification.enable();
+            }
+            {
+                BacktestKit.Markdown.enable();
+                BacktestKit.Report.enable();
+                BacktestKit.Dump.enable();
+                BacktestKit.Memory.enable();
+            }
+            {
+                BacktestKit.Dump.useMarkdown();
+                BacktestKit.Memory.usePersist();
+            }
+            {
+                BacktestKit.StorageLive.usePersist();
+                BacktestKit.StorageBacktest.useMemory();
+            }
+            {
+                BacktestKit.NotificationLive.usePersist();
+                BacktestKit.NotificationBacktest.useMemory();
+            }
+            {
+                BacktestKit.Markdown.useDummy();
+                BacktestKit.Log.useJsonl();
+            }
+        });
+        this.clear = () => {
+            cli.loggerService.debug("SetupUtils clear");
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            this.enable.clear();
+            {
+                BacktestKit.PersistSignalAdapter.clear();
+                BacktestKit.PersistRiskAdapter.clear();
+                BacktestKit.PersistScheduleAdapter.clear();
+                BacktestKit.PersistPartialAdapter.clear();
+                BacktestKit.PersistBreakevenAdapter.clear();
+                BacktestKit.PersistCandleAdapter.clear();
+                BacktestKit.PersistStorageAdapter.clear();
+                BacktestKit.PersistNotificationAdapter.clear();
+                BacktestKit.PersistLogAdapter.clear();
+                BacktestKit.PersistMeasureAdapter.clear();
+                BacktestKit.PersistMemoryAdapter.clear();
+            }
+            {
+                BacktestKit.Dump.clear();
+                BacktestKit.Log.clear();
+                BacktestKit.Markdown.clear();
+                BacktestKit.Memory.clear();
+                BacktestKit.Report.clear();
+            }
+            {
+                BacktestKit.StorageLive.clear();
+                BacktestKit.StorageBacktest.clear();
+            }
+            {
+                BacktestKit.NotificationLive.clear();
+                BacktestKit.NotificationBacktest.clear();
+            }
+        };
+    }
+}
+const Setup = new SetupUtils();
+
+Setup.enable();
+BacktestKit.setConfig({
+    CC_MAX_NOTIFICATIONS: 5000,
+    CC_MAX_SIGNALS: 750,
+});
+BacktestKit.setConfig({
+    CC_ENABLE_DCA_EVERYWHERE: true,
+    CC_ENABLE_PPPL_EVERYWHERE: true,
+    CC_ENABLE_TRAILING_EVERYWHERE: true,
+});
+BacktestKit.setConfig({
+    CC_MAX_SIGNAL_GENERATION_SECONDS: 15 * 60,
+});
+BacktestKit.setConfig({
+    CC_MAX_BACKTEST_MARKDOWN_ROWS: 1000,
+    CC_MAX_BREAKEVEN_MARKDOWN_ROWS: 1000,
+    CC_MAX_HEATMAP_MARKDOWN_ROWS: 1000,
+    CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: 1000,
+    CC_MAX_LIVE_MARKDOWN_ROWS: 1000,
+    CC_MAX_PARTIAL_MARKDOWN_ROWS: 1000,
+    CC_MAX_RISK_MARKDOWN_ROWS: 1000,
+    CC_MAX_SCHEDULE_MARKDOWN_ROWS: 1000,
+    CC_MAX_STRATEGY_MARKDOWN_ROWS: 1000,
+    CC_MAX_SYNC_MARKDOWN_ROWS: 1000,
+    CC_MAX_PERFORMANCE_MARKDOWN_ROWS: 1000,
+});
+BacktestKit.setConfig({
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: Infinity,
+});
+BacktestKit.setConfig({
+    CC_WALKER_MARKDOWN_TOP_N: 10,
+});
+
 const MODES = ["backtest", "walker", "paper", "live", "pine", "dump", "init", "help", "version"];
 const ENTRY_PATH$1 = "./node_modules/@backtest-kit/cli/build/index.mjs";
 const HELP_TEXT$1 = `
@@ -2426,7 +2505,7 @@ const main$b = async () => {
     if (MODES.some((mode) => values[mode])) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n`);
     process.stdout.write("\n");
     process.stdout.write(`Run with --help to see available commands.\n`);
     process.stdout.write("\n");
@@ -2827,6 +2906,20 @@ function runScript(scriptPath, cwd) {
         child.on("error", reject);
     });
 }
+function runNpmInstall(cwd) {
+    return new Promise((resolve, reject) => {
+        const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+        const child = child_process.spawn(npm, ["install"], { cwd, stdio: "inherit", shell: true });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`npm install exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+        child.on("error", reject);
+    });
+}
 const main$2 = async () => {
     if (!getEntry((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))) {
         return;
@@ -2847,6 +2940,8 @@ const main$2 = async () => {
     await copyDir(templatePath, projectPath, { PROJECT_NAME: projectName });
     console.log(`Fetching docs...`);
     await runScript(path.join(projectPath, "scripts/fetch_docs.mjs"), projectPath);
+    console.log(`Installing dependencies...`);
+    await runNpmInstall(projectPath);
     console.log(`Done! Project created at ${projectPath}`);
     process.exit(0);
 };
@@ -2978,7 +3073,7 @@ const main$1 = async () => {
     if (!values.help) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n\n`);
     process.stdout.write(HELP_TEXT);
     process.exit(0);
 };
@@ -2992,7 +3087,7 @@ const main = async () => {
     if (!values.version) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n`);
     process.exit(0);
 };
 main();
@@ -3030,6 +3125,7 @@ async function run(mode, args) {
     throw new Error(`Invalid mode: ${mode}`);
 }
 
+exports.Setup = Setup;
 exports.cli = cli;
 exports.run = run;
 exports.setLogger = setLogger;

package/build/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import * as BacktestKit from 'backtest-kit';
-import { Storage, Notification, Markdown, Report, Dump, Memory, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, setConfig, Log, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, shutdown, listenSignal, listStrategySchema, overrideExchangeSchema, Backtest, alignToInterval, addWalkerSchema, overrideWalkerSchema, Walker, listenDoneWalker, Live, getCandles, checkCandles, warmCandles, listenRisk, listenStrategyCommit, listenSync, Exchange } from 'backtest-kit';
+import { Log, listExchangeSchema, addExchangeSchema, roundTicks, listFrameSchema, addFrameSchema, listenDoneLive, listenDoneBacktest, shutdown, listenSignal, listStrategySchema, overrideExchangeSchema, Backtest, alignToInterval, addWalkerSchema, overrideWalkerSchema, Walker, listenDoneWalker, Live, getCandles, checkCandles, warmCandles, listenRisk, listenStrategyCommit, listenSync, Storage, Notification, Markdown, Report, Dump, Memory, StorageLive, StorageBacktest, NotificationLive, NotificationBacktest, PersistSignalAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistPartialAdapter, PersistBreakevenAdapter, PersistCandleAdapter, PersistStorageAdapter, PersistNotificationAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, setConfig, Exchange } from 'backtest-kit';
 import { getErrorMessage, errorData, singleshot, str, BehaviorSubject, compose, createAwaiter, execpool, queued, sleep, randomString, TIMEOUT_SYMBOL, typo, retry, trycatch, memoize } from 'functools-kit';
 import fs, { constants } from 'fs';
 import * as stackTrace from 'stack-trace';
@@ -62,64 +62,6 @@ import { spawn } from 'child_process';
     });
 }
 
-{
-    Storage.enable();
-    Notification.enable();
-}
-{
-    Markdown.enable();
-    Report.enable();
-    Dump.enable();
-    Memory.enable();
-}
-{
-    Dump.useMarkdown();
-    Memory.usePersist();
-}
-{
-    StorageLive.usePersist();
-    StorageBacktest.useMemory();
-}
-{
-    NotificationLive.usePersist();
-    NotificationBacktest.useMemory();
-}
-{
-    Markdown.useDummy();
-}
-setConfig({
-    CC_MAX_NOTIFICATIONS: 5000,
-    CC_MAX_SIGNALS: 750,
-});
-setConfig({
-    CC_ENABLE_DCA_EVERYWHERE: true,
-    CC_ENABLE_PPPL_EVERYWHERE: true,
-    CC_ENABLE_TRAILING_EVERYWHERE: true,
-});
-setConfig({
-    CC_MAX_SIGNAL_GENERATION_SECONDS: 15 * 60,
-});
-setConfig({
-    CC_MAX_BACKTEST_MARKDOWN_ROWS: 1000,
-    CC_MAX_BREAKEVEN_MARKDOWN_ROWS: 1000,
-    CC_MAX_HEATMAP_MARKDOWN_ROWS: 1000,
-    CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: 1000,
-    CC_MAX_LIVE_MARKDOWN_ROWS: 1000,
-    CC_MAX_PARTIAL_MARKDOWN_ROWS: 1000,
-    CC_MAX_RISK_MARKDOWN_ROWS: 1000,
-    CC_MAX_SCHEDULE_MARKDOWN_ROWS: 1000,
-    CC_MAX_STRATEGY_MARKDOWN_ROWS: 1000,
-    CC_MAX_SYNC_MARKDOWN_ROWS: 1000,
-    CC_MAX_PERFORMANCE_MARKDOWN_ROWS: 1000,
-});
-setConfig({
-    CC_MAX_SIGNAL_LIFETIME_MINUTES: Infinity,
-});
-setConfig({
-    CC_WALKER_MARKDOWN_TOP_N: 10,
-});
-Log.useJsonl();
-
 const ERROR_HANDLER_INSTALLED = Symbol.for("error-handler-installed");
 function dumpStackTrace() {
     const trace = stackTrace.get();
@@ -804,8 +746,15 @@ class WalkerMainService {
         this.moduleConnectionService = inject(TYPES.moduleConnectionService);
         this.run = singleshot(async (payload) => {
             this.loggerService.log("walkerMainService run", { payload });
+            const strategyMap = new Map();
             for (const entryPoint of payload.entryPoints) {
                 await this.resolveService.attachStrategy(entryPoint);
+                for (const { strategyName } of await listStrategySchema()) {
+                    if (strategyMap.has(strategyName)) {
+                        continue;
+                    }
+                    strategyMap.set(strategyName, entryPoint);
+                }
             }
             await this.moduleConnectionService.loadModule("./walker.module");
             {
@@ -842,19 +791,42 @@ class WalkerMainService {
             if (!frameName) {
                 throw new Error("Frame name is required");
             }
+            const cwd = process.cwd();
+            const self = this;
+            const callbacks = {
+                async onStrategyStart(strategyName) {
+                    const entryPoint = strategyMap.get(strategyName);
+                    if (!entryPoint) {
+                        return;
+                    }
+                    {
+                        Setup.clear();
+                        Setup.enable();
+                    }
+                    const absolutePath = path.resolve(entryPoint);
+                    const moduleRoot = path.dirname(absolutePath);
+                    {
+                        process.chdir(moduleRoot);
+                        cwd !== moduleRoot && Log.useJsonl();
+                        dotenv.config({ path: path.join(cwd, '.env'), override: true, quiet: true });
+                        dotenv.config({ path: path.join(moduleRoot, '.env'), override: true, quiet: true });
+                    }
+                    if (!payload.noCache) {
+                        await self.cacheLogicService.execute(payload.cacheInterval, {
+                            exchangeName,
+                            frameName,
+                            symbol,
+                        });
+                    }
+                },
+            };
             addWalkerSchema({
                 walkerName: WALKER_NAME,
                 exchangeName,
                 frameName,
                 strategies: strategyNames,
+                callbacks,
             });
-            if (!payload.noCache) {
-                await this.cacheLogicService.execute(payload.cacheInterval, {
-                    exchangeName,
-                    frameName,
-                    symbol,
-                });
-            }
             if (payload.verbose) {
                 overrideExchangeSchema({
                     exchangeName,
@@ -870,8 +842,9 @@ class WalkerMainService {
                 overrideWalkerSchema({
                     walkerName: WALKER_NAME,
                     callbacks: {
-                        onStrategyStart(strategyName, symbol) {
+                        async onStrategyStart(strategyName, symbol) {
                             console.log(`Strategy started: ${strategyName} for symbol: ${symbol}`);
+                            await callbacks.onStrategyStart(strategyName);
                         },
                         onStrategyError(strategyName, symbol, error) {
                             console.error(`Strategy error: ${strategyName} for symbol: ${symbol}`, error);
@@ -892,9 +865,12 @@ class WalkerMainService {
                 unWalker();
                 res();
             });
-            payload.verbose && console.time("Walker");
-            await awaiter;
-            payload.verbose && console.timeEnd("Walker");
+            {
+                payload.verbose && console.time("Walker");
+                await awaiter;
+                payload.verbose && console.timeEnd("Walker");
+            }
+            process.chdir(cwd);
             const dumpName = payload.output || `walker_${symbol}_${Date.now()}`;
             const dumpDir = join(process.cwd(), "dump");
             if (payload.json) {
@@ -2094,7 +2070,7 @@ const TRANSPILE_FN = memoize(([path]) => `${path}`, (path, code, self, require)
         eval(self.params.babel.transpile(code));
     }
     catch (error) {
-        console.log(`Error during transpilation error=\`${getErrorMessage(error)}\` path=${path} __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
+        console.log(`Error during transpilation error=\`${getErrorMessage(error)}\` path=\`${path}\` __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
         process.exit(-1);
     }
     return {
@@ -2382,6 +2358,109 @@ const cli = {
 };
 init();
 
+class SetupUtils {
+    constructor() {
+        this.enable = singleshot(() => {
+            cli.loggerService.debug("SetupUtils enable");
+            {
+                Storage.enable();
+                Notification.enable();
+            }
+            {
+                Markdown.enable();
+                Report.enable();
+                Dump.enable();
+                Memory.enable();
+            }
+            {
+                Dump.useMarkdown();
+                Memory.usePersist();
+            }
+            {
+                StorageLive.usePersist();
+                StorageBacktest.useMemory();
+            }
+            {
+                NotificationLive.usePersist();
+                NotificationBacktest.useMemory();
+            }
+            {
+                Markdown.useDummy();
+                Log.useJsonl();
+            }
+        });
+        this.clear = () => {
+            cli.loggerService.debug("SetupUtils clear");
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            this.enable.clear();
+            {
+                PersistSignalAdapter.clear();
+                PersistRiskAdapter.clear();
+                PersistScheduleAdapter.clear();
+                PersistPartialAdapter.clear();
+                PersistBreakevenAdapter.clear();
+                PersistCandleAdapter.clear();
+                PersistStorageAdapter.clear();
+                PersistNotificationAdapter.clear();
+                PersistLogAdapter.clear();
+                PersistMeasureAdapter.clear();
+                PersistMemoryAdapter.clear();
+            }
+            {
+                Dump.clear();
+                Log.clear();
+                Markdown.clear();
+                Memory.clear();
+                Report.clear();
+            }
+            {
+                StorageLive.clear();
+                StorageBacktest.clear();
+            }
+            {
+                NotificationLive.clear();
+                NotificationBacktest.clear();
+            }
+        };
+    }
+}
+const Setup = new SetupUtils();
+
+Setup.enable();
+setConfig({
+    CC_MAX_NOTIFICATIONS: 5000,
+    CC_MAX_SIGNALS: 750,
+});
+setConfig({
+    CC_ENABLE_DCA_EVERYWHERE: true,
+    CC_ENABLE_PPPL_EVERYWHERE: true,
+    CC_ENABLE_TRAILING_EVERYWHERE: true,
+});
+setConfig({
+    CC_MAX_SIGNAL_GENERATION_SECONDS: 15 * 60,
+});
+setConfig({
+    CC_MAX_BACKTEST_MARKDOWN_ROWS: 1000,
+    CC_MAX_BREAKEVEN_MARKDOWN_ROWS: 1000,
+    CC_MAX_HEATMAP_MARKDOWN_ROWS: 1000,
+    CC_MAX_HIGHEST_PROFIT_MARKDOWN_ROWS: 1000,
+    CC_MAX_LIVE_MARKDOWN_ROWS: 1000,
+    CC_MAX_PARTIAL_MARKDOWN_ROWS: 1000,
+    CC_MAX_RISK_MARKDOWN_ROWS: 1000,
+    CC_MAX_SCHEDULE_MARKDOWN_ROWS: 1000,
+    CC_MAX_STRATEGY_MARKDOWN_ROWS: 1000,
+    CC_MAX_SYNC_MARKDOWN_ROWS: 1000,
+    CC_MAX_PERFORMANCE_MARKDOWN_ROWS: 1000,
+});
+setConfig({
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: Infinity,
+});
+setConfig({
+    CC_WALKER_MARKDOWN_TOP_N: 10,
+});
+
 const MODES = ["backtest", "walker", "paper", "live", "pine", "dump", "init", "help", "version"];
 const ENTRY_PATH$1 = "./node_modules/@backtest-kit/cli/build/index.mjs";
 const HELP_TEXT$1 = `
@@ -2397,7 +2476,7 @@ const main$b = async () => {
     if (MODES.some((mode) => values[mode])) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n`);
     process.stdout.write("\n");
     process.stdout.write(`Run with --help to see available commands.\n`);
     process.stdout.write("\n");
@@ -2798,6 +2877,20 @@ function runScript(scriptPath, cwd) {
         child.on("error", reject);
     });
 }
+function runNpmInstall(cwd) {
+    return new Promise((resolve, reject) => {
+        const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+        const child = spawn(npm, ["install"], { cwd, stdio: "inherit", shell: true });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`npm install exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+        child.on("error", reject);
+    });
+}
 const main$2 = async () => {
     if (!getEntry(import.meta.url)) {
         return;
@@ -2818,6 +2911,8 @@ const main$2 = async () => {
     await copyDir(templatePath, projectPath, { PROJECT_NAME: projectName });
     console.log(`Fetching docs...`);
     await runScript(join(projectPath, "scripts/fetch_docs.mjs"), projectPath);
+    console.log(`Installing dependencies...`);
+    await runNpmInstall(projectPath);
     console.log(`Done! Project created at ${projectPath}`);
     process.exit(0);
 };
@@ -2949,7 +3044,7 @@ const main$1 = async () => {
     if (!values.help) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n\n`);
     process.stdout.write(HELP_TEXT);
     process.exit(0);
 };
@@ -2963,7 +3058,7 @@ const main = async () => {
     if (!values.version) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.2.0"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.3.0"}\n`);
     process.exit(0);
 };
 main();
@@ -3001,4 +3096,4 @@ async function run(mode, args) {
     throw new Error(`Invalid mode: ${mode}`);
 }
 
-export { cli, run, setLogger };
+export { Setup, cli, run, setLogger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtest-kit/cli",
-  "version": "6.2.0",
+  "version": "6.4.0",
   "description": "Zero-boilerplate CLI runner for backtest-kit strategies. Run backtests, paper trading, and live bots with candle cache warming, web dashboard, and Telegram notifications — no setup code required.",
   "author": {
     "name": "Petr Tripolsky",
@@ -61,11 +61,11 @@
   "devDependencies": {
     "@babel/plugin-transform-modules-umd": "7.27.1",
     "@babel/standalone": "7.29.1",
-    "@backtest-kit/ui": "6.2.0",
-    "@backtest-kit/graph": "6.2.0",
-    "@backtest-kit/ollama": "6.2.0",
-    "@backtest-kit/pinets": "6.2.0",
-    "@backtest-kit/signals": "6.2.0",
+    "@backtest-kit/ui": "6.4.0",
+    "@backtest-kit/graph": "6.4.0",
+    "@backtest-kit/ollama": "6.4.0",
+    "@backtest-kit/pinets": "6.4.0",
+    "@backtest-kit/signals": "6.4.0",
     "@rollup/plugin-replace": "6.0.3",
     "@rollup/plugin-typescript": "11.1.6",
     "@types/image-size": "0.7.0",
@@ -73,7 +73,7 @@
     "@types/mustache": "4.2.6",
     "@types/node": "22.9.0",
     "@types/stack-trace": "0.0.33",
-    "backtest-kit": "6.2.0",
+    "backtest-kit": "6.4.0",
     "glob": "11.0.1",
     "markdown-it": "14.1.1",
     "rimraf": "6.0.1",
@@ -88,12 +88,12 @@
   "peerDependencies": {
     "@babel/plugin-transform-modules-umd": "^7.27.1",
     "@babel/standalone": "^7.29.1",
-    "@backtest-kit/ui": "^6.2.0",
-    "@backtest-kit/graph": "^6.2.0",
-    "@backtest-kit/ollama": "^6.2.0",
-    "@backtest-kit/pinets": "^6.2.0",
-    "@backtest-kit/signals": "^6.2.0",
-    "backtest-kit": "^6.2.0",
+    "@backtest-kit/ui": "^6.4.0",
+    "@backtest-kit/graph": "^6.4.0",
+    "@backtest-kit/ollama": "^6.4.0",
+    "@backtest-kit/pinets": "^6.4.0",
+    "@backtest-kit/signals": "^6.4.0",
+    "backtest-kit": "^6.4.0",
     "markdown-it": "^14.1.1",
     "typescript": "^5.0.0"
   },

package/template/project/README.md

@@ -87,7 +87,7 @@ npm start -- --live --symbol BTCUSDT --ui --telegram ./content/feb_2026.strategy
 
 Module file `./modules/live.module.ts` is loaded automatically if it exists. Use it to register a `Broker` adapter that intercepts every trade mutation before internal state changes — exchange rejection rolls back the operation atomically.
 
-## 🚶 Walker — A/B Strategy Comparison (`--walker`)
+## ⚖️ Walker — A/B Strategy Comparison (`--walker`)
 
 Runs the same historical period across multiple strategy files and prints a ranked comparison report. Use it to pick the best variant before committing to a single strategy.
 

package/template/project/package.mustache

@@ -12,7 +12,7 @@
   "license": "ISC",
   "type": "commonjs",
   "dependencies": {
-    "@backtest-kit/cli": "^6.2.0",
+    "@backtest-kit/cli": "^6.2.1",
     "@backtest-kit/graph": "^6.2.0",
     "@backtest-kit/pinets": "^6.2.0",
     "@backtest-kit/ui": "^6.2.0",

package/types.d.ts

@@ -1,291 +1,297 @@
-import * as functools_kit from 'functools-kit';
-import { CandleInterval, TrailingTakeCommit, TrailingStopCommit, BreakevenCommit, PartialProfitCommit, PartialLossCommit, IStrategyTickResultScheduled, IStrategyTickResultCancelled, IStrategyTickResultOpened, IStrategyTickResultClosed, RiskContract, AverageBuyCommit, SignalOpenContract, SignalCloseContract, CancelScheduledCommit, ClosePendingCommit } from 'backtest-kit';
-import { Input } from 'telegraf';
-
-interface ILogger {
-    log(topic: string, ...args: any[]): void;
-    debug(topic: string, ...args: any[]): void;
-    info(topic: string, ...args: any[]): void;
-    warn(topic: string, ...args: any[]): void;
-}
-
-declare class LoggerService implements ILogger {
-    private _commonLogger;
-    log: (topic: string, ...args: any[]) => Promise<void>;
-    debug: (topic: string, ...args: any[]) => Promise<void>;
-    info: (topic: string, ...args: any[]) => Promise<void>;
-    warn: (topic: string, ...args: any[]) => Promise<void>;
-    setLogger: (logger: ILogger) => void;
-}
-
-declare class PaperMainService {
-    private loggerService;
-    private resolveService;
-    private exchangeSchemaService;
-    private symbolSchemaService;
-    private frontendProviderService;
-    private telegramProviderService;
-    private moduleConnectionService;
-    run: ((payload: {
-        entryPoint: string;
-        symbol: string;
-        strategy: string;
-        exchange: string;
-        verbose: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class LiveMainService {
-    private loggerService;
-    private resolveService;
-    private exchangeSchemaService;
-    private symbolSchemaService;
-    private frontendProviderService;
-    private telegramProviderService;
-    private moduleConnectionService;
-    run: ((payload: {
-        entryPoint: string;
-        symbol: string;
-        strategy: string;
-        exchange: string;
-        verbose: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class BacktestMainService {
-    private loggerService;
-    private resolveService;
-    private exchangeSchemaService;
-    private frameSchemaService;
-    private symbolSchemaService;
-    private cacheLogicService;
-    private frontendProviderService;
-    private telegramProviderService;
-    private moduleConnectionService;
-    run: ((payload: {
-        entryPoint: string;
-        symbol: string;
-        strategy: string;
-        exchange: string;
-        frame: string;
-        cacheInterval: string[];
-        verbose: boolean;
-        noCache: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class WalkerMainService {
-    private loggerService;
-    private resolveService;
-    private exchangeSchemaService;
-    private symbolSchemaService;
-    private cacheLogicService;
-    private moduleConnectionService;
-    run: ((payload: {
-        entryPoints: string[];
-        symbol: string;
-        output: string;
-        cacheInterval: CandleInterval[];
-        json: boolean;
-        markdown: boolean;
-        verbose: boolean;
-        noCache: boolean;
-    }) => Promise<void>) & functools_kit.ISingleshotClearable;
-    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class ExchangeSchemaService {
-    readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class FrameSchemaService {
-    readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class LoaderService {
-    private readonly babelService;
-    private readonly loggerService;
-    private getInstance;
-    import: (filePath: string, basePath?: string) => any;
-    check: (filePath: string, basePath?: string) => Promise<boolean>;
-}
-
-declare class ResolveService {
-    readonly loggerService: LoggerService;
-    readonly loaderService: LoaderService;
-    readonly DEFAULT_TEMPLATE_DIR: string;
-    readonly DEFAULT_MODULES_DIR: string;
-    readonly OVERRIDE_TEMPLATE_DIR: string;
-    readonly OVERRIDE_MODULES_DIR: string;
-    getIsLaunched: () => boolean;
-    attachPine: (pinePath: string) => Promise<string>;
-    attachStrategy: (jsPath: string) => Promise<void>;
-    attachJavascript: (jsPath: string) => Promise<void>;
-}
-
-declare class ErrorService {
-    handleGlobalError: (error: Error) => Promise<void>;
-    private _listenForError;
-    protected init: (() => void) & functools_kit.ISingleshotClearable;
-}
-
-declare class SymbolSchemaService {
-    readonly loggerService: LoggerService;
-    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class FrontendProviderService {
-    private readonly loggerService;
-    enable: (() => () => void) & functools_kit.ISingleshotClearable;
-    disable: () => void;
-    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class TelegramProviderService {
-    private readonly loggerService;
-    private readonly telegramLogicService;
-    enable: (() => () => void) & functools_kit.ISingleshotClearable;
-    disable: () => void;
-    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
-}
-
-declare class CacheLogicService {
-    private readonly loggerService;
-    execute: (intervalList: CandleInterval[], dto: {
-        symbol: string;
-        frameName: string;
-        exchangeName: string;
-    }) => Promise<void>;
-}
-
-type InputFile = ReturnType<typeof Input.fromReadableStream>;
-type Image = string | InputFile;
-declare class TelegramApiService {
-    publish: (channel: string, msg: string, images?: Image[]) => Promise<"Message scheduled for publication" | "Message published successfully">;
-}
-
-declare class QuickchartApiService {
-    readonly loggerService: LoggerService;
-    getChart: (symbol: string, interval: string) => Promise<Buffer<ArrayBufferLike>>;
-}
-
-declare class TelegramWebService {
-    private readonly loggerService;
-    private readonly telegramApiService;
-    private readonly quickchartApiService;
-    publishNotify: (dto: {
-        symbol: string;
-        markdown: string;
-    }) => Promise<void>;
-}
-
-declare class TelegramLogicService {
-    private readonly loggerService;
-    private readonly telegramTemplateService;
-    private readonly telegramWebService;
-    private notifyTrailingTake;
-    private notifyTrailingStop;
-    private notifyBreakeven;
-    private notifyPartialProfit;
-    private notifyPartialLoss;
-    private notifyScheduled;
-    private notifyCancelled;
-    private notifyOpened;
-    private notifyClosed;
-    private notifyRisk;
-    private notifyAverageBuy;
-    private notifySignalOpen;
-    private notifySignalClose;
-    private notifyCancelScheduled;
-    private notifyClosePending;
-    connect: (() => () => void) & functools_kit.ISingleshotClearable;
-}
-
-declare class TelegramTemplateService {
-    readonly loggerService: LoggerService;
-    readonly resolveService: ResolveService;
-    getTrailingTakeMarkdown: (event: TrailingTakeCommit) => Promise<string>;
-    getTrailingStopMarkdown: (event: TrailingStopCommit) => Promise<string>;
-    getBreakevenMarkdown: (event: BreakevenCommit) => Promise<string>;
-    getPartialProfitMarkdown: (event: PartialProfitCommit) => Promise<string>;
-    getPartialLossMarkdown: (event: PartialLossCommit) => Promise<string>;
-    getScheduledMarkdown: (event: IStrategyTickResultScheduled) => Promise<string>;
-    getCancelledMarkdown: (event: IStrategyTickResultCancelled) => Promise<string>;
-    getOpenedMarkdown: (event: IStrategyTickResultOpened) => Promise<string>;
-    getClosedMarkdown: (event: IStrategyTickResultClosed) => Promise<string>;
-    getRiskMarkdown: (event: RiskContract) => Promise<string>;
-    getAverageBuyMarkdown: (event: AverageBuyCommit) => Promise<string>;
-    getSignalOpenMarkdown: (event: SignalOpenContract) => Promise<string>;
-    getSignalCloseMarkdown: (event: SignalCloseContract) => Promise<string>;
-    getCancelScheduledMarkdown: (event: CancelScheduledCommit) => Promise<string>;
-    getClosePendingMarkdown: (event: ClosePendingCommit) => Promise<string>;
-}
-
-declare class ModuleConnectionService {
-    readonly loggerService: LoggerService;
-    readonly resolveService: ResolveService;
-    readonly loaderService: LoaderService;
-    loadModule: (fileName: string) => Promise<boolean>;
-}
-
-interface IBabel {
-    transpile(code: string): string;
-}
-
-declare class BabelService implements IBabel {
-    readonly loggerService: LoggerService;
-    transpile: (code: string) => any;
-}
-
-declare const cli: {
-    telegramTemplateService: TelegramTemplateService;
-    telegramWebService: TelegramWebService;
-    frontendProviderService: FrontendProviderService;
-    telegramProviderService: TelegramProviderService;
-    exchangeSchemaService: ExchangeSchemaService;
-    symbolSchemaService: SymbolSchemaService;
-    frameSchemaService: FrameSchemaService;
-    cacheLogicService: CacheLogicService;
-    telegramLogicService: TelegramLogicService;
-    backtestMainService: BacktestMainService;
-    walkerMainService: WalkerMainService;
-    paperMainService: PaperMainService;
-    liveMainService: LiveMainService;
-    moduleConnectionService: ModuleConnectionService;
-    errorService: ErrorService;
-    loggerService: LoggerService;
-    resolveService: ResolveService;
-    loaderService: LoaderService;
-    babelService: BabelService;
-    telegramApiService: TelegramApiService;
-    quickchartApiService: QuickchartApiService;
-};
-
-interface ILoader {
-    import(filePath: string): any;
-    check(filePath: string): boolean;
-}
-
-declare enum ExchangeName {
-    DefaultExchange = "default_exchange"
-}
-
-declare enum FrameName {
-    DefaultFrame = "default_frame"
-}
-
-declare function setLogger(logger: ILogger): void;
-
-type PayloadBacktest = Parameters<typeof cli.backtestMainService.run>[0];
-type PayloadPaper = Parameters<typeof cli.paperMainService.run>[0];
-type PayloadLive = Parameters<typeof cli.liveMainService.run>[0];
-type Mode = "backtest" | "live" | "paper";
-type Args = Partial<PayloadBacktest> | Partial<PayloadPaper> | Partial<PayloadLive>;
-declare function run(mode: Mode, args: Args): Promise<void>;
-
-export { ExchangeName, FrameName, type IBabel, type ILoader, type ILogger, cli, run, setLogger };
+import * as functools_kit from 'functools-kit';
+import { CandleInterval, TrailingTakeCommit, TrailingStopCommit, BreakevenCommit, PartialProfitCommit, PartialLossCommit, IStrategyTickResultScheduled, IStrategyTickResultCancelled, IStrategyTickResultOpened, IStrategyTickResultClosed, RiskContract, AverageBuyCommit, SignalOpenContract, SignalCloseContract, CancelScheduledCommit, ClosePendingCommit } from 'backtest-kit';
+import { Input } from 'telegraf';
+
+interface ILogger {
+    log(topic: string, ...args: any[]): void;
+    debug(topic: string, ...args: any[]): void;
+    info(topic: string, ...args: any[]): void;
+    warn(topic: string, ...args: any[]): void;
+}
+
+declare class LoggerService implements ILogger {
+    private _commonLogger;
+    log: (topic: string, ...args: any[]) => Promise<void>;
+    debug: (topic: string, ...args: any[]) => Promise<void>;
+    info: (topic: string, ...args: any[]) => Promise<void>;
+    warn: (topic: string, ...args: any[]) => Promise<void>;
+    setLogger: (logger: ILogger) => void;
+}
+
+declare class PaperMainService {
+    private loggerService;
+    private resolveService;
+    private exchangeSchemaService;
+    private symbolSchemaService;
+    private frontendProviderService;
+    private telegramProviderService;
+    private moduleConnectionService;
+    run: ((payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        verbose: boolean;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class LiveMainService {
+    private loggerService;
+    private resolveService;
+    private exchangeSchemaService;
+    private symbolSchemaService;
+    private frontendProviderService;
+    private telegramProviderService;
+    private moduleConnectionService;
+    run: ((payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        verbose: boolean;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class BacktestMainService {
+    private loggerService;
+    private resolveService;
+    private exchangeSchemaService;
+    private frameSchemaService;
+    private symbolSchemaService;
+    private cacheLogicService;
+    private frontendProviderService;
+    private telegramProviderService;
+    private moduleConnectionService;
+    run: ((payload: {
+        entryPoint: string;
+        symbol: string;
+        strategy: string;
+        exchange: string;
+        frame: string;
+        cacheInterval: string[];
+        verbose: boolean;
+        noCache: boolean;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class WalkerMainService {
+    private loggerService;
+    private resolveService;
+    private exchangeSchemaService;
+    private symbolSchemaService;
+    private cacheLogicService;
+    private moduleConnectionService;
+    run: ((payload: {
+        entryPoints: string[];
+        symbol: string;
+        output: string;
+        cacheInterval: CandleInterval[];
+        json: boolean;
+        markdown: boolean;
+        verbose: boolean;
+        noCache: boolean;
+    }) => Promise<void>) & functools_kit.ISingleshotClearable;
+    connect: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class ExchangeSchemaService {
+    readonly loggerService: LoggerService;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class FrameSchemaService {
+    readonly loggerService: LoggerService;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class LoaderService {
+    private readonly babelService;
+    private readonly loggerService;
+    private getInstance;
+    import: (filePath: string, basePath?: string) => any;
+    check: (filePath: string, basePath?: string) => Promise<boolean>;
+}
+
+declare class ResolveService {
+    readonly loggerService: LoggerService;
+    readonly loaderService: LoaderService;
+    readonly DEFAULT_TEMPLATE_DIR: string;
+    readonly DEFAULT_MODULES_DIR: string;
+    readonly OVERRIDE_TEMPLATE_DIR: string;
+    readonly OVERRIDE_MODULES_DIR: string;
+    getIsLaunched: () => boolean;
+    attachPine: (pinePath: string) => Promise<string>;
+    attachStrategy: (jsPath: string) => Promise<void>;
+    attachJavascript: (jsPath: string) => Promise<void>;
+}
+
+declare class ErrorService {
+    handleGlobalError: (error: Error) => Promise<void>;
+    private _listenForError;
+    protected init: (() => void) & functools_kit.ISingleshotClearable;
+}
+
+declare class SymbolSchemaService {
+    readonly loggerService: LoggerService;
+    addSchema: (() => Promise<void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class FrontendProviderService {
+    private readonly loggerService;
+    enable: (() => () => void) & functools_kit.ISingleshotClearable;
+    disable: () => void;
+    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class TelegramProviderService {
+    private readonly loggerService;
+    private readonly telegramLogicService;
+    enable: (() => () => void) & functools_kit.ISingleshotClearable;
+    disable: () => void;
+    connect: (() => Promise<() => void>) & functools_kit.ISingleshotClearable;
+}
+
+declare class CacheLogicService {
+    private readonly loggerService;
+    execute: (intervalList: CandleInterval[], dto: {
+        symbol: string;
+        frameName: string;
+        exchangeName: string;
+    }) => Promise<void>;
+}
+
+type InputFile = ReturnType<typeof Input.fromReadableStream>;
+type Image = string | InputFile;
+declare class TelegramApiService {
+    publish: (channel: string, msg: string, images?: Image[]) => Promise<"Message scheduled for publication" | "Message published successfully">;
+}
+
+declare class QuickchartApiService {
+    readonly loggerService: LoggerService;
+    getChart: (symbol: string, interval: string) => Promise<Buffer<ArrayBufferLike>>;
+}
+
+declare class TelegramWebService {
+    private readonly loggerService;
+    private readonly telegramApiService;
+    private readonly quickchartApiService;
+    publishNotify: (dto: {
+        symbol: string;
+        markdown: string;
+    }) => Promise<void>;
+}
+
+declare class TelegramLogicService {
+    private readonly loggerService;
+    private readonly telegramTemplateService;
+    private readonly telegramWebService;
+    private notifyTrailingTake;
+    private notifyTrailingStop;
+    private notifyBreakeven;
+    private notifyPartialProfit;
+    private notifyPartialLoss;
+    private notifyScheduled;
+    private notifyCancelled;
+    private notifyOpened;
+    private notifyClosed;
+    private notifyRisk;
+    private notifyAverageBuy;
+    private notifySignalOpen;
+    private notifySignalClose;
+    private notifyCancelScheduled;
+    private notifyClosePending;
+    connect: (() => () => void) & functools_kit.ISingleshotClearable;
+}
+
+declare class TelegramTemplateService {
+    readonly loggerService: LoggerService;
+    readonly resolveService: ResolveService;
+    getTrailingTakeMarkdown: (event: TrailingTakeCommit) => Promise<string>;
+    getTrailingStopMarkdown: (event: TrailingStopCommit) => Promise<string>;
+    getBreakevenMarkdown: (event: BreakevenCommit) => Promise<string>;
+    getPartialProfitMarkdown: (event: PartialProfitCommit) => Promise<string>;
+    getPartialLossMarkdown: (event: PartialLossCommit) => Promise<string>;
+    getScheduledMarkdown: (event: IStrategyTickResultScheduled) => Promise<string>;
+    getCancelledMarkdown: (event: IStrategyTickResultCancelled) => Promise<string>;
+    getOpenedMarkdown: (event: IStrategyTickResultOpened) => Promise<string>;
+    getClosedMarkdown: (event: IStrategyTickResultClosed) => Promise<string>;
+    getRiskMarkdown: (event: RiskContract) => Promise<string>;
+    getAverageBuyMarkdown: (event: AverageBuyCommit) => Promise<string>;
+    getSignalOpenMarkdown: (event: SignalOpenContract) => Promise<string>;
+    getSignalCloseMarkdown: (event: SignalCloseContract) => Promise<string>;
+    getCancelScheduledMarkdown: (event: CancelScheduledCommit) => Promise<string>;
+    getClosePendingMarkdown: (event: ClosePendingCommit) => Promise<string>;
+}
+
+declare class ModuleConnectionService {
+    readonly loggerService: LoggerService;
+    readonly resolveService: ResolveService;
+    readonly loaderService: LoaderService;
+    loadModule: (fileName: string) => Promise<boolean>;
+}
+
+interface IBabel {
+    transpile(code: string): string;
+}
+
+declare class BabelService implements IBabel {
+    readonly loggerService: LoggerService;
+    transpile: (code: string) => any;
+}
+
+declare const cli: {
+    telegramTemplateService: TelegramTemplateService;
+    telegramWebService: TelegramWebService;
+    frontendProviderService: FrontendProviderService;
+    telegramProviderService: TelegramProviderService;
+    exchangeSchemaService: ExchangeSchemaService;
+    symbolSchemaService: SymbolSchemaService;
+    frameSchemaService: FrameSchemaService;
+    cacheLogicService: CacheLogicService;
+    telegramLogicService: TelegramLogicService;
+    backtestMainService: BacktestMainService;
+    walkerMainService: WalkerMainService;
+    paperMainService: PaperMainService;
+    liveMainService: LiveMainService;
+    moduleConnectionService: ModuleConnectionService;
+    errorService: ErrorService;
+    loggerService: LoggerService;
+    resolveService: ResolveService;
+    loaderService: LoaderService;
+    babelService: BabelService;
+    telegramApiService: TelegramApiService;
+    quickchartApiService: QuickchartApiService;
+};
+
+declare class SetupUtils {
+    enable: (() => void) & functools_kit.ISingleshotClearable;
+    clear: () => void;
+}
+declare const Setup: SetupUtils;
+
+interface ILoader {
+    import(filePath: string): any;
+    check(filePath: string): boolean;
+}
+
+declare enum ExchangeName {
+    DefaultExchange = "default_exchange"
+}
+
+declare enum FrameName {
+    DefaultFrame = "default_frame"
+}
+
+declare function setLogger(logger: ILogger): void;
+
+type PayloadBacktest = Parameters<typeof cli.backtestMainService.run>[0];
+type PayloadPaper = Parameters<typeof cli.paperMainService.run>[0];
+type PayloadLive = Parameters<typeof cli.liveMainService.run>[0];
+type Mode = "backtest" | "live" | "paper";
+type Args = Partial<PayloadBacktest> | Partial<PayloadPaper> | Partial<PayloadLive>;
+declare function run(mode: Mode, args: Args): Promise<void>;
+
+export { ExchangeName, FrameName, type IBabel, type ILoader, type ILogger, Setup, cli, run, setLogger };