@backtest-kit/cli 6.1.5 → 6.2.1

package/build/index.mjs

@@ -1,10 +1,10 @@
 #!/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, Live, getCandles, checkCandles, warmCandles, listenRisk, listenStrategyCommit, listenSync, alignToInterval, Exchange } from 'backtest-kit';
-import { getErrorMessage, errorData, singleshot, str, BehaviorSubject, compose, execpool, queued, sleep, randomString, createAwaiter, TIMEOUT_SYMBOL, typo, retry, trycatch, memoize } from 'functools-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 { 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';
-import path, { basename, extname, join, resolve, dirname } from 'path';
+import path, { join, resolve, basename, extname, dirname } from 'path';
 import fs$1, { access, readFile, mkdir, writeFile, readdir, copyFile } from 'fs/promises';
 import dotenv from 'dotenv';
 import { createActivator } from 'di-kit';
@@ -224,6 +224,7 @@ const connectionServices$1 = {
 };
 const mainServices$1 = {
     backtestMainService: Symbol('backtestMainService'),
+    walkerMainService: Symbol('walkerMainService'),
     paperMainService: Symbol('paperMainService'),
     liveMainService: Symbol('liveMainService'),
 };
@@ -292,6 +293,19 @@ class ResolveService {
             _is_launched = true;
             return await readFile(absolutePath, "utf-8");
         };
+        this.attachStrategy = async (jsPath) => {
+            this.loggerService.log("resolveService attachStrategy", {
+                jsPath
+            });
+            const absolutePath = path.resolve(jsPath);
+            await access(absolutePath, constants.F_OK | constants.R_OK);
+            const moduleRoot = path.dirname(absolutePath);
+            {
+                const cwd = process.cwd();
+                dotenv.config({ path: path.join(cwd, '.env'), override: true, quiet: true });
+            }
+            this.loaderService.import(absolutePath, moduleRoot);
+        };
         this.attachJavascript = async (jsPath) => {
             this.loggerService.log("resolveService attachJavascript", {
                 jsPath
@@ -459,6 +473,10 @@ const getArgs = singleshot(() => {
                 type: "boolean",
                 default: false,
             },
+            walker: {
+                type: "boolean",
+                default: false,
+            },
             live: {
                 type: "boolean",
                 default: false,
@@ -549,12 +567,11 @@ const getArgs = singleshot(() => {
         positionals,
     };
 });
-const getPositional = singleshot(() => {
+const getPositionals = singleshot(() => {
     const { positionals = [] } = getArgs();
-    const result = positionals
+    return positionals
         .filter((value) => !DISALLOWED_PATHS.some((path) => value.includes(path)))
-        .find((value) => ALLOWED_EXTENSIONS.some((ext) => value.endsWith(ext)));
-    return result || null;
+        .filter((value) => ALLOWED_EXTENSIONS.some((ext) => value.endsWith(ext)));
 });
 
 const ADD_FRAME_FN = (self) => {
@@ -659,11 +676,11 @@ const notifyVerbose = singleshot(() => {
     });
 });
 
-const DEFAULT_CACHE_LIST = ["1m", "15m", "30m", "1h", "4h"];
-const GET_CACHE_INTERVAL_LIST_FN = () => {
+const DEFAULT_CACHE_LIST$1 = ["1m", "15m", "30m", "1h", "4h"];
+const GET_CACHE_INTERVAL_LIST_FN$1 = () => {
     const { values } = getArgs();
     if (!values.cacheInterval) {
-        return DEFAULT_CACHE_LIST;
+        return DEFAULT_CACHE_LIST$1;
     }
     return String(values.cacheInterval)
         .split(",")
@@ -688,7 +705,10 @@ class BacktestMainService {
                 this.frontendProviderService.connect();
                 this.telegramProviderService.connect();
             }
-            await this.resolveService.attachJavascript(payload.entryPoint);
+            {
+                await this.resolveService.attachJavascript(payload.entryPoint);
+                await this.moduleConnectionService.loadModule("./backtest.module");
+            }
             {
                 this.exchangeSchemaService.addSchema();
                 this.symbolSchemaService.addSchema();
@@ -728,7 +748,6 @@ class BacktestMainService {
                 });
                 notifyVerbose();
             }
-            await this.moduleConnectionService.loadModule("./backtest.module");
             Backtest.background(symbol, {
                 strategyName,
                 frameName,
@@ -745,11 +764,11 @@ class BacktestMainService {
             if (!values.backtest) {
                 return;
             }
-            const entryPoint = getPositional();
+            const [entryPoint = null] = getPositionals();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
-            const cacheInterval = GET_CACHE_INTERVAL_LIST_FN();
+            const cacheInterval = GET_CACHE_INTERVAL_LIST_FN$1();
             return await this.run({
                 symbol: values.symbol,
                 entryPoint,
@@ -764,6 +783,200 @@ class BacktestMainService {
     }
 }
 
+const DEFAULT_CACHE_LIST = ["1m", "15m", "30m", "1h", "4h"];
+const WALKER_NAME = "cli-walker";
+const GET_CACHE_INTERVAL_LIST_FN = () => {
+    const { values } = getArgs();
+    if (!values.cacheInterval) {
+        return DEFAULT_CACHE_LIST;
+    }
+    return String(values.cacheInterval)
+        .split(",")
+        .map((timeframe) => timeframe.trim());
+};
+class WalkerMainService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.resolveService = inject(TYPES.resolveService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.symbolSchemaService = inject(TYPES.symbolSchemaService);
+        this.cacheLogicService = inject(TYPES.cacheLogicService);
+        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");
+            {
+                this.exchangeSchemaService.addSchema();
+                this.symbolSchemaService.addSchema();
+            }
+            {
+                const { length } = await listFrameSchema();
+                if (!length) {
+                    const endDate = alignToInterval(new Date(Date.now() - 1 * 24 * 60 * 60 * 1000), "1m");
+                    const startDate = alignToInterval(new Date(Date.now() - 31 * 24 * 60 * 60 * 1000), "1m");
+                    console.warn(`Warning: The default frame schema is set to the interval ${startDate.toISOString()} — ${endDate.toISOString()}. Please make sure to update it according to your needs using addFrameSchema in your strategy files.`);
+                    addFrameSchema({
+                        frameName: FrameName$1.DefaultFrame,
+                        interval: "1m",
+                        startDate,
+                        endDate,
+                    });
+                }
+            }
+            const symbol = payload.symbol || "BTCUSDT";
+            const strategyList = await listStrategySchema();
+            const strategyNames = strategyList.map((s) => s.strategyName);
+            if (!strategyNames.length) {
+                throw new Error("No strategies found in provided entry points");
+            }
+            const [defaultExchangeName = null] = await listExchangeSchema();
+            const [defaultFrameName = null] = await listFrameSchema();
+            const exchangeName = defaultExchangeName?.exchangeName;
+            const frameName = defaultFrameName?.frameName;
+            if (!exchangeName) {
+                throw new Error("Exchange name is required");
+            }
+            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;
+                    }
+                    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.verbose) {
+                overrideExchangeSchema({
+                    exchangeName,
+                    callbacks: {
+                        onCandleData(symbol, interval, since) {
+                            console.log(`Received candle data for symbol: ${symbol}, interval: ${interval}, since: ${since.toUTCString()}`);
+                        },
+                    },
+                });
+                notifyVerbose();
+            }
+            if (payload.verbose) {
+                overrideWalkerSchema({
+                    walkerName: WALKER_NAME,
+                    callbacks: {
+                        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);
+                        },
+                        onStrategyComplete(strategyName, symbol) {
+                            console.log(`Strategy completed: ${strategyName} for symbol: ${symbol}`);
+                        },
+                        onComplete(results) {
+                            console.log(`Walker completed for symbol: ${results.symbol}`, results);
+                        }
+                    }
+                });
+            }
+            Walker.background(symbol, { walkerName: WALKER_NAME });
+            const [awaiter, { resolve: res }] = createAwaiter();
+            const unWalker = listenDoneWalker(() => {
+                console.log("Walker comparison finished");
+                unWalker();
+                res();
+            });
+            {
+                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) {
+                const filePath = resolve(dumpDir, `${dumpName}.json`);
+                const data = await Walker.getData(symbol, { walkerName: WALKER_NAME });
+                await mkdir(dumpDir, { recursive: true });
+                await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+                console.log(`Saved: ${filePath}`);
+                process.exit(0);
+                return;
+            }
+            if (payload.markdown) {
+                const filePath = resolve(dumpDir, `${dumpName}.md`);
+                const report = await Walker.getReport(symbol, { walkerName: WALKER_NAME });
+                await mkdir(dumpDir, { recursive: true });
+                await writeFile(filePath, report, "utf-8");
+                console.log(`Saved: ${filePath}`);
+                process.exit(0);
+                return;
+            }
+            const report = await Walker.getReport(symbol, { walkerName: WALKER_NAME });
+            console.log(report);
+            process.exit(0);
+        });
+        this.connect = singleshot(async () => {
+            this.loggerService.log("walkerMainService connect");
+            if (!getEntry(import.meta.url)) {
+                return;
+            }
+            const { values } = getArgs();
+            if (!values.walker) {
+                return;
+            }
+            const entryPoints = getPositionals();
+            if (!entryPoints.length) {
+                throw new Error("At least one entry point is required");
+            }
+            const cacheInterval = GET_CACHE_INTERVAL_LIST_FN();
+            return await this.run({
+                entryPoints,
+                json: values.json,
+                markdown: values.markdown,
+                symbol: values.symbol,
+                output: values.output,
+                cacheInterval,
+                verbose: values.verbose,
+                noCache: values.noCache,
+            });
+        });
+    }
+}
+
 class LiveMainService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
@@ -781,7 +994,10 @@ class LiveMainService {
                 this.frontendProviderService.connect();
                 this.telegramProviderService.connect();
             }
-            await this.resolveService.attachJavascript(payload.entryPoint);
+            {
+                await this.resolveService.attachJavascript(payload.entryPoint);
+                await this.moduleConnectionService.loadModule("./live.module");
+            }
             {
                 this.exchangeSchemaService.addSchema();
                 this.symbolSchemaService.addSchema();
@@ -808,7 +1024,6 @@ class LiveMainService {
                 });
                 notifyVerbose();
             }
-            await this.moduleConnectionService.loadModule("./live.module");
             Live.background(symbol, {
                 strategyName,
                 exchangeName,
@@ -824,7 +1039,7 @@ class LiveMainService {
             if (!values.live) {
                 return;
             }
-            const entryPoint = getPositional();
+            const [entryPoint = null] = getPositionals();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
@@ -854,7 +1069,10 @@ class PaperMainService {
                 this.frontendProviderService.connect();
                 this.telegramProviderService.connect();
             }
-            await this.resolveService.attachJavascript(payload.entryPoint);
+            {
+                await this.resolveService.attachJavascript(payload.entryPoint);
+                await this.moduleConnectionService.loadModule("./paper.module");
+            }
             {
                 this.exchangeSchemaService.addSchema();
                 this.symbolSchemaService.addSchema();
@@ -881,7 +1099,6 @@ class PaperMainService {
                 });
                 notifyVerbose();
             }
-            await this.moduleConnectionService.loadModule("./paper.module");
             Live.background(symbol, {
                 strategyName,
                 exchangeName,
@@ -897,7 +1114,7 @@ class PaperMainService {
             if (!values.paper) {
                 return;
             }
-            const entryPoint = getPositional();
+            const [entryPoint = null] = getPositionals();
             if (!entryPoint) {
                 throw new Error("Entry point is required");
             }
@@ -1898,8 +2115,7 @@ class BabelService {
     }
 }
 
-const TRANSPILE_FN = (code, self) => {
-    const require = self.getBaseRequire();
+const TRANSPILE_FN = memoize(([path]) => `${path}`, (path, code, self, require) => {
     const __filename = self.__filename;
     const __dirname = self.__dirname;
     const module = { exports: {} };
@@ -1908,7 +2124,7 @@ const TRANSPILE_FN = (code, self) => {
         eval(self.params.babel.transpile(code));
     }
     catch (error) {
-        console.log(`Error during transpilation error=\`${getErrorMessage(error)}\` __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
+        console.log(`Error during transpilation error=\`${getErrorMessage(error)}\` path=\`${path}\` __filename=\`${__filename}\` __dirname=\`${__dirname}\``);
         process.exit(-1);
     }
     return {
@@ -1918,18 +2134,18 @@ const TRANSPILE_FN = (code, self) => {
         exports,
         module,
     };
-};
-const REQUIRE_ENTRY_FACTORY = (filePath, self) => {
+});
+const REQUIRE_ENTRY_FACTORY = (filePath, self, seen) => {
     {
         return null;
     }
 };
-const BABEL_ENTRY_FACTORY = (filePath, self) => {
+const BABEL_ENTRY_FACTORY = (filePath, self, seen) => {
     try {
         const resolvedPath = path.resolve(self.__dirname, filePath);
         const code = fs.readFileSync(resolvedPath, "utf-8");
         const child = self.fork(path.dirname(resolvedPath));
-        const { module } = TRANSPILE_FN(code, child);
+        const { module } = TRANSPILE_FN(resolvedPath, code, child, CREATE_BASE_REQUIRE_FN(child, seen));
         return "default" in module.exports
             ? module.exports.default
             : module.exports;
@@ -1970,21 +2186,20 @@ const GET_RESOLVED_EXT_FN = (filePath) => {
     }
     return filePath;
 };
-const ENTRY_FACTORY = (filePath, self) => {
-    filePath = GET_RESOLVED_EXT_FN(filePath);
+const ENTRY_FACTORY = (filePath, self, seen) => {
     {
         let result = null;
         if ((result = REQUIRE_ENTRY_FACTORY())) {
             return result;
         }
-        if ((result = BABEL_ENTRY_FACTORY(filePath, self))) {
+        if ((result = BABEL_ENTRY_FACTORY(filePath, self, seen))) {
             return result;
         }
     }
     throw new Error(`Failed to load module at ${filePath} (basepath: ${self.params.path})`);
 };
-const CREATE_BASE_REQUIRE_FN = (self) => {
-    const baseRequire = createRequire(self.__filename);
+const CREATE_BASE_REQUIRE_FN = (self, seen) => {
+    const baseRequire = self.baseRequire();
     return new Proxy(baseRequire, {
         apply(_target, _this, args) {
             const id = args[0];
@@ -2005,7 +2220,7 @@ const CREATE_BASE_REQUIRE_FN = (self) => {
             if (id.startsWith("./") || id.startsWith("../")) {
                 const resolved = path.resolve(self.__dirname, id);
                 const child = self.fork(path.dirname(resolved));
-                return child.import(resolved);
+                return child.import(resolved, seen);
             }
             return baseRequire(id);
         },
@@ -2019,11 +2234,11 @@ const BacktestKitCli = new Proxy({}, {
 class ClientLoader {
     constructor(params) {
         this.params = params;
-        this.getBaseRequire = singleshot(() => {
-            this.params.logger.log("ClientLoader getBaseRequire", {
+        this.baseRequire = singleshot(() => {
+            this.params.logger.log("ClientLoader baseRequire", {
                 basePath: this.params.path,
             });
-            return CREATE_BASE_REQUIRE_FN(this);
+            return createRequire(this.__filename);
         });
         this.__filename = path.join(params.path, "index.cjs");
         this.__dirname = path.dirname(this.__filename);
@@ -2039,12 +2254,21 @@ class ClientLoader {
             logger: this.params.logger,
         });
     }
-    import(filePath) {
+    import(filePath, seen = new Set()) {
         this.params.logger.log("ClientLoader import", {
             filePath,
             basePath: this.params.path,
         });
-        return ENTRY_FACTORY(filePath, this);
+        const resolved = GET_RESOLVED_EXT_FN(filePath);
+        if (seen.has(resolved)) {
+            throw new Error(`Circular dependency detected: ${resolved} (seen: ${[...seen].join("->")}->${resolved})`);
+        }
+        const currentSeen = new Set(seen);
+        if (!seen.size) {
+            currentSeen.add(path.resolve(this.__dirname, filePath));
+        }
+        currentSeen.add(resolved);
+        return ENTRY_FACTORY(resolved, this, currentSeen);
     }
     check(filePath) {
         this.params.logger.log("ClientLoader check", {
@@ -2112,6 +2336,7 @@ class LoaderService {
 }
 {
     provide(TYPES.backtestMainService, () => new BacktestMainService());
+    provide(TYPES.walkerMainService, () => new WalkerMainService());
     provide(TYPES.paperMainService, () => new PaperMainService());
     provide(TYPES.liveMainService, () => new LiveMainService());
 }
@@ -2151,6 +2376,7 @@ const connectionServices = {
 };
 const mainServices = {
     backtestMainService: inject(TYPES.backtestMainService),
+    walkerMainService: inject(TYPES.walkerMainService),
     paperMainService: inject(TYPES.paperMainService),
     liveMainService: inject(TYPES.liveMainService),
 };
@@ -2186,14 +2412,14 @@ const cli = {
 };
 init();
 
-const MODES = ["backtest", "paper", "live", "pine", "dump", "init", "help", "version"];
+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 = `
-Example:
-
-  node ${ENTRY_PATH$1} --help
+const HELP_TEXT$1 = `
+Example:
+
+  node ${ENTRY_PATH$1} --help
 `.trimStart();
-const main$a = async () => {
+const main$b = async () => {
     if (!getEntry(import.meta.url)) {
         return;
     }
@@ -2201,21 +2427,21 @@ const main$a = async () => {
     if (MODES.some((mode) => values[mode])) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.1.1"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.2.1"}\n`);
     process.stdout.write("\n");
     process.stdout.write(`Run with --help to see available commands.\n`);
     process.stdout.write("\n");
     process.stdout.write(HELP_TEXT$1);
     process.exit(0);
 };
-main$a();
+main$b();
 
 const notifyShutdown = singleshot(async () => {
     console.log("Graceful shutdown initiated. Press Ctrl+C again to force quit.");
 });
 
-const BEFORE_EXIT_FN$4 = singleshot(async () => {
-    process.off("SIGINT", BEFORE_EXIT_FN$4);
+const BEFORE_EXIT_FN$5 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$5);
     const [running = null] = await Backtest.list();
     if (!running) {
         return;
@@ -2231,6 +2457,35 @@ const BEFORE_EXIT_FN$4 = singleshot(async () => {
         frameName,
     });
 });
+const listenGracefulShutdown$5 = singleshot(() => {
+    process.on("SIGINT", BEFORE_EXIT_FN$5);
+});
+const main$a = async () => {
+    if (!getEntry(import.meta.url)) {
+        return;
+    }
+    const { values } = getArgs();
+    if (!values.backtest) {
+        return;
+    }
+    await cli.backtestMainService.connect();
+    listenGracefulShutdown$5();
+};
+main$a();
+
+const BEFORE_EXIT_FN$4 = singleshot(async () => {
+    process.off("SIGINT", BEFORE_EXIT_FN$4);
+    const [running = null] = await Walker.list();
+    if (!running) {
+        return;
+    }
+    notifyShutdown();
+    const { walkerName, symbol, status } = running;
+    if (status === "fulfilled") {
+        return;
+    }
+    Walker.stop(symbol, { walkerName });
+});
 const listenGracefulShutdown$4 = singleshot(() => {
     process.on("SIGINT", BEFORE_EXIT_FN$4);
 });
@@ -2239,11 +2494,11 @@ const main$9 = async () => {
         return;
     }
     const { values } = getArgs();
-    if (!values.backtest) {
+    if (!values.walker) {
         return;
     }
-    await cli.backtestMainService.connect();
     listenGracefulShutdown$4();
+    await cli.walkerMainService.connect();
 };
 main$9();
 
@@ -2379,7 +2634,7 @@ const main$4 = async () => {
     if (!values.pine) {
         return;
     }
-    const entryPoint = getPositional();
+    const [entryPoint = null] = getPositionals();
     if (!entryPoint) {
         return;
     }
@@ -2573,6 +2828,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;
@@ -2593,109 +2862,130 @@ 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);
 };
 main$2();
 
 const ENTRY_PATH = "./node_modules/@backtest-kit/cli/build/index.mjs";
-const HELP_TEXT = `
-@backtest-kit/cli
-
-Usage:
-  node index.mjs --<mode> [flags] [entry-point]
-
-Modes:
-
-  --backtest <entry>    Run strategy against historical candle data
-  --paper    <entry>    Paper trading (live prices, no real orders)
-  --live     <entry>    Live trading with real orders
-  --pine     <entry>    Execute a local .pine indicator file
-  --dump                Fetch and save raw OHLCV candles
-  --init                Scaffold a new project in the current directory
-  --help                Print this help message
-
-Backtest flags:
-
-  --symbol      <string>   Trading pair (default: BTCUSDT)
-  --strategy    <string>   Strategy name from addStrategySchema (default: first registered)
-  --exchange    <string>   Exchange name from addExchangeSchema (default: first registered)
-  --frame       <string>   Frame name from addFrameSchema (default: first registered)
-  --cacheInterval <string> Comma-separated intervals to pre-cache (default: "1m, 15m, 30m, 4h")
-  --noCache                Skip candle cache warming before the run
-  --verbose                Log every candle fetch to stdout
-  --ui                     Start web dashboard at http://localhost:60050
-  --telegram               Send trade notifications to Telegram
-
-Paper / Live flags:
-
-  --symbol    <string>   Trading pair (default: BTCUSDT)
-  --strategy  <string>   Strategy name (default: first registered)
-  --exchange  <string>   Exchange name (default: first registered)
-  --verbose              Log every candle fetch to stdout
-  --ui                   Start web dashboard
-  --telegram             Send Telegram notifications
-
-PineScript flags (--pine):
-
-  --symbol      <string>   Trading pair (default: BTCUSDT)
-  --timeframe   <string>   Candle interval (default: 15m)
-  --limit       <string>   Number of candles to fetch (default: 250)
-  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
-  --exchange    <string>   Exchange name (default: first registered)
-  --output      <string>   Output file base name without extension
-  --json                   Save output as JSON array to <pine-dir>/dump/<output>.json
-  --jsonl                  Save output as JSONL to <pine-dir>/dump/<output>.jsonl
-  --markdown               Save output as Markdown table to <pine-dir>/dump/<output>.md
-
-  Only plot() calls with display=display.data_window produce output columns.
-  Module file ./modules/pine.module is loaded automatically if it exists.
-
-Candle dump flags (--dump):
-
-  --symbol      <string>   Trading pair (default: BTCUSDT)
-  --timeframe   <string>   Candle interval (default: 15m)
-  --limit       <string>   Number of candles (default: 250)
-  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
-  --exchange    <string>   Exchange name (default: first registered)
-  --output      <string>   Output file base name (default: {SYMBOL}_{LIMIT}_{TIMEFRAME}_{TIMESTAMP})
-  --json                   Save as JSON array to ./dump/<output>.json
-  --jsonl                  Save as JSONL to ./dump/<output>.jsonl
-
-  Module file ./modules/dump.module is loaded automatically if it exists.
-
-Init flags (--init):
-
-  --output <string>   Target directory name (default: backtest-kit-project)
-
-  Scaffolds a project and runs scripts/fetch_docs.mjs to download library docs.
-
-Module hooks (loaded automatically by each mode):
-
-  modules/backtest.module   --backtest   Broker adapter for backtest
-  modules/paper.module      --paper      Broker adapter for paper trading
-  modules/live.module       --live       Broker adapter for live trading
-  modules/pine.module       --pine       Exchange schema for PineScript runs
-  modules/dump.module       --dump       Exchange schema for candle dumps
-
-  Extensions .ts, .mjs, .cjs are tried automatically. Missing module = soft warning.
-
-Environment variables:
-
-  CC_TELEGRAM_TOKEN    Telegram bot token (required for --telegram)
-  CC_TELEGRAM_CHANNEL  Telegram channel or chat ID (required for --telegram)
-  CC_WWWROOT_HOST      UI server bind address (default: 0.0.0.0)
-  CC_WWWROOT_PORT      UI server port (default: 60050)
-
-Examples:
-
-  node ${ENTRY_PATH} --backtest ./content/feb_2026.strategy.ts
-  node ${ENTRY_PATH} --backtest --symbol BTCUSDT --noCache --ui ./content/feb_2026.strategy.ts
-  node ${ENTRY_PATH} --paper --symbol ETHUSDT ./content/feb_2026.strategy.ts
-  node ${ENTRY_PATH} --live --ui --telegram ./content/feb_2026.strategy.ts
-  node ${ENTRY_PATH} --pine ./math/feb_2026.pine --timeframe 15m --limit 500 --jsonl
-  node ${ENTRY_PATH} --dump --symbol BTCUSDT --timeframe 15m --limit 500 --jsonl
-  node ${ENTRY_PATH} --init --output my-trading-bot
+const HELP_TEXT = `
+Usage:
+  node index.mjs --<mode> [flags] [entry-point]
+
+Modes:
+
+  --backtest <entry>          Run strategy against historical candle data
+  --walker   <entry...>       Run Walker A/B strategy comparison across multiple strategies
+  --paper    <entry>          Paper trading (live prices, no real orders)
+  --live     <entry>          Live trading with real orders
+  --pine     <entry>    Execute a local .pine indicator file
+  --dump                Fetch and save raw OHLCV candles
+  --init                Scaffold a new project in the current directory
+  --help                Print this help message
+
+Backtest flags:
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --strategy    <string>   Strategy name from addStrategySchema (default: first registered)
+  --exchange    <string>   Exchange name from addExchangeSchema (default: first registered)
+  --frame       <string>   Frame name from addFrameSchema (default: first registered)
+  --cacheInterval <string> Comma-separated intervals to pre-cache (default: "1m, 15m, 30m, 4h")
+  --noCache                Skip candle cache warming before the run
+  --verbose                Log every candle fetch to stdout
+  --ui                     Start web dashboard at http://localhost:60050
+  --telegram               Send trade notifications to Telegram
+
+Walker flags (--walker):
+
+  --symbol        <string>   Trading pair (default: BTCUSDT)
+  --cacheInterval <string>   Comma-separated intervals to pre-cache (default: "1m, 15m, 30m, 4h")
+  --noCache                  Skip candle cache warming before the run
+  --verbose                  Log every candle fetch to stdout
+  --output        <string>   Output file base name (default: walker_{SYMBOL}_{TIMESTAMP})
+  --json                     Save results as JSON to ./dump/<output>.json
+  --markdown                 Save report as Markdown to ./dump/<output>.md
+
+  Each positional argument is a strategy entry point. All strategy files are loaded without
+  changing process.cwd() — .env is read from the working directory only.
+  addWalkerSchema is called automatically using the registered exchange and frame.
+  After comparison completes the report is printed to stdout (or saved if --json/--markdown).
+
+  Module file ./modules/walker.module is loaded automatically if it exists.
+
+Paper / Live flags:
+
+  --symbol    <string>   Trading pair (default: BTCUSDT)
+  --strategy  <string>   Strategy name (default: first registered)
+  --exchange  <string>   Exchange name (default: first registered)
+  --verbose              Log every candle fetch to stdout
+  --ui                   Start web dashboard
+  --telegram             Send Telegram notifications
+
+PineScript flags (--pine):
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --timeframe   <string>   Candle interval (default: 15m)
+  --limit       <string>   Number of candles to fetch (default: 250)
+  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
+  --exchange    <string>   Exchange name (default: first registered)
+  --output      <string>   Output file base name without extension
+  --json                   Save output as JSON array to <pine-dir>/dump/<output>.json
+  --jsonl                  Save output as JSONL to <pine-dir>/dump/<output>.jsonl
+  --markdown               Save output as Markdown table to <pine-dir>/dump/<output>.md
+
+  Only plot() calls with display=display.data_window produce output columns.
+  Module file ./modules/pine.module is loaded automatically if it exists.
+
+Candle dump flags (--dump):
+
+  --symbol      <string>   Trading pair (default: BTCUSDT)
+  --timeframe   <string>   Candle interval (default: 15m)
+  --limit       <string>   Number of candles (default: 250)
+  --when        <string>   End date — ISO 8601 or Unix ms (default: now)
+  --exchange    <string>   Exchange name (default: first registered)
+  --output      <string>   Output file base name (default: {SYMBOL}_{LIMIT}_{TIMEFRAME}_{TIMESTAMP})
+  --json                   Save as JSON array to ./dump/<output>.json
+  --jsonl                  Save as JSONL to ./dump/<output>.jsonl
+
+  Module file ./modules/dump.module is loaded automatically if it exists.
+
+Init flags (--init):
+
+  --output <string>   Target directory name (default: backtest-kit-project)
+
+  Scaffolds a project and runs scripts/fetch_docs.mjs to download library docs.
+
+Module hooks (loaded automatically by each mode):
+
+  modules/backtest.module   --backtest   Broker adapter for backtest
+  modules/walker.module     --walker     Broker adapter for walker comparison
+  modules/paper.module      --paper      Broker adapter for paper trading
+  modules/live.module       --live       Broker adapter for live trading
+  modules/pine.module       --pine       Exchange schema for PineScript runs
+  modules/dump.module       --dump       Exchange schema for candle dumps
+
+  Extensions .ts, .mjs, .cjs are tried automatically. Missing module = soft warning.
+
+Environment variables:
+
+  CC_TELEGRAM_TOKEN    Telegram bot token (required for --telegram)
+  CC_TELEGRAM_CHANNEL  Telegram channel or chat ID (required for --telegram)
+  CC_WWWROOT_HOST      UI server bind address (default: 0.0.0.0)
+  CC_WWWROOT_PORT      UI server port (default: 60050)
+
+Examples:
+
+  node ${ENTRY_PATH} --backtest ./content/feb_2026.strategy.ts
+  node ${ENTRY_PATH} --backtest --symbol BTCUSDT --noCache --ui ./content/feb_2026.strategy.ts
+  node ${ENTRY_PATH} --walker ./content/feb_2026_v1.strategy.ts ./content/feb_2026_v2.strategy.ts ./content/feb_2026_v3.strategy.ts
+  node ${ENTRY_PATH} --walker --symbol BTCUSDT --noCache --markdown ./content/feb_2026_v1.ts ./content/feb_2026_v2.ts
+  node ${ENTRY_PATH} --paper --symbol ETHUSDT ./content/feb_2026.strategy.ts
+  node ${ENTRY_PATH} --live --ui --telegram ./content/feb_2026.strategy.ts
+  node ${ENTRY_PATH} --pine ./math/feb_2026.pine --timeframe 15m --limit 500 --jsonl
+  node ${ENTRY_PATH} --dump --symbol BTCUSDT --timeframe 15m --limit 500 --jsonl
+  node ${ENTRY_PATH} --init --output my-trading-bot
 `.trimStart();
 const main$1 = async () => {
     if (!getEntry(import.meta.url)) {
@@ -2705,6 +2995,7 @@ const main$1 = async () => {
     if (!values.help) {
         return;
     }
+    process.stdout.write(`@backtest-kit/cli ${"6.2.1"}\n\n`);
     process.stdout.write(HELP_TEXT);
     process.exit(0);
 };
@@ -2718,7 +3009,7 @@ const main = async () => {
     if (!values.version) {
         return;
     }
-    process.stdout.write(`@backtest-kit/cli ${"6.1.1"}\n`);
+    process.stdout.write(`@backtest-kit/cli ${"6.2.1"}\n`);
     process.exit(0);
 };
 main();
@@ -2740,7 +3031,7 @@ async function run(mode, args) {
     }
     if (mode === "backtest") {
         await cli.backtestMainService.run(args);
-        listenGracefulShutdown$4();
+        listenGracefulShutdown$5();
         return;
     }
     if (mode === "paper") {